Fix links to classes

reference/gdscript.rst

@@ -246,7 +246,7 @@ float
 
 Used to contain a floating point value (real numbers).
 
-`String <https://github.com/okamstudio/godot/wiki/class_string>`__
+:ref:`String <class_String>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 A sequence of characters in Unicode format. Strings can contain the
@@ -255,43 +255,43 @@ standard C escape sequences.
 Vector Built-In Types
 ~~~~~~~~~~~~~~~~~~~~~
 
-`Vector2 <https://github.com/okamstudio/godot/wiki/class_vector2>`__
+:ref:`Vector2 <class_Vector2>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 2D vector type containing ``x`` and ``y`` fields. Can alternatively
 access fields as ``width`` and ``height`` for readability. Can also be
 accessed as array.
 
-`Rect2 <https://github.com/okamstudio/godot/wiki/class_rect2>`__
+:ref:`Rect2 <class_Rect2>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 2D Rectangle type containing two vectors fields: ``pos`` and ``size``.
 Alternatively contains an ``end`` field which is ``pos+size``.
 
-`Vector3 <https://github.com/okamstudio/godot/wiki/class_vector3>`__
+:ref:`Vector3 <class_Vector3>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 3D vector type containing ``x``, ``y`` and ``z`` fields. This can also
 be accessed as an array.
 
-`Matrix32 <https://github.com/okamstudio/godot/wiki/class_matrix32>`__
+:ref:`Matrix32 <class_Matrix32>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 3x2 matrix used for 2D transforms.
 
-`Plane <https://github.com/okamstudio/godot/wiki/class_plane>`__
+:ref:`Plane <class_Plane>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 3D Plane type in normalized form that contains a ``normal`` vector field
 and a ``d`` scalar distance.
 
-`Quat <https://github.com/okamstudio/godot/wiki/class_quat>`__
+:ref:`Quat <class_Quat>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Quaternion is a datatype used for representing a 3D rotation. It's
 useful for interpolating rotations.
 
-`AABB <https://github.com/okamstudio/godot/wiki/class_aabb>`__
+:ref:`AABB <class_AABB>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Axis Aligned bounding box (or 3D box) contains 2 vectors fields: ``pos``
@@ -299,14 +299,14 @@ and ``size``. Alternatively contains an ``end`` field which is
 ``pos+size``. As an alias of this type, ``Rect3`` can be used
 interchangeably.
 
-`Matrix3 <https://github.com/okamstudio/godot/wiki/class_matrix3>`__
+:ref:`Matrix3 <class_Matrix3>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 3x3 matrix used for 3D rotation and scale. It contains 3 vector fields
 (``x``, ``y`` and ``z``) and can also be accessed as an array of 3D
 vectors.
 
-`Transform <https://github.com/okamstudio/godot/wiki/class_transform>`__
+:ref:`Transform <class_Transform>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 3D Transform contains a Matrix3 field ``basis`` and a Vector3 field
@@ -315,35 +315,35 @@ vectors.
 Engine Built-In Types
 ~~~~~~~~~~~~~~~~~~~~~
 
-`Color <https://github.com/okamstudio/godot/wiki/class_color>`__
+:ref:`Color <class_Color>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Color data type contains ``r``, ``g``, ``b``, and ``a`` fields. It can
 also be accessed as ``h``, ``s``, and ``v`` for hue/saturation/value.
 
-`Image <https://github.com/okamstudio/godot/wiki/class_image>`__
+:ref:`Image <class_Image>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Contains a custom format 2D image and allows direct access to the
 pixels.
 
-`NodePath <https://github.com/okamstudio/godot/wiki/class_nodepath>`__
+:ref:`NodePath <class_NodePath>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Compiled path to a node used mainly in the scene system. It can be
 easily assigned to, and from, a String.
 
-`RID <https://github.com/okamstudio/godot/wiki/class_rid>`__
+:ref:`RID <class_RID>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Resource ID (RID). Servers use generic RIDs to reference opaque data.
 
-`Object <https://github.com/okamstudio/godot/wiki/class_object>`__
+:ref:`Object <class_Object>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Base class for anything that is not a built-in type.
 
-`InputEvent <https://github.com/okamstudio/godot/wiki/class_inputevent>`__
+:ref:`InputEvent <class_InputEvent>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Events from input devices are contained in very compact form in
@@ -353,7 +353,7 @@ amounts from frame to frame they are optimized as their own data type.
 Container Built-In Types
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
-`Array <https://github.com/okamstudio/godot/wiki/class_array>`__
+:ref:`Array <class_Array>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Generic sequence of objects. Its size can be changed to anything and
@@ -374,7 +374,7 @@ which do not suffer from this and use less memory, but they are atomic
 and generally run a little slower, so they are only justified for very
 large amount of data.
 
-`Dictionary <https://github.com/okamstudio/godot/wiki/class_dictionary>`__
+:ref:`Dictionary <class_Dictionary>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Associative container which contains values referenced by unique keys.
@@ -396,7 +396,7 @@ write and read:
         morekey = "Hello"
     }
 
-`ByteArray <https://github.com/okamstudio/godot/wiki/class_bytearray>`__
+:ref:`ByteArray <class_ByteArray>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 An array of bytes can only contain bytes (integers from 0 to 255).
@@ -404,32 +404,32 @@ An array of bytes can only contain bytes (integers from 0 to 255).
 This, and all of the following specialized array types, are optimized
 for memory usage and can't fragment the memory.
 
-`IntArray <https://github.com/okamstudio/godot/wiki/class_intarray>`__
+:ref:`IntArray <class_IntArray>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Array of integers can only contain integers.
 
-`FloatArray <https://github.com/okamstudio/godot/wiki/class_floatarray>`__
+:ref:`FloatArray <class_FloatArray>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Array of floats can only contain floats.
 
-`StringArray <https://github.com/okamstudio/godot/wiki/class_stringarray>`__
+:ref:`StringArray <class_StringArray>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Array of strings can only contain strings.
 
-`Vector2Array <https://github.com/okamstudio/godot/wiki/class_vector2array>`__
+:ref:`Vector2Array <class_Vector2Array>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Array of Vector2 can only contain 2D Vectors.
 
-`Vector3Array <https://github.com/okamstudio/godot/wiki/class_vector3array>`__
+:ref:`Vector3Array <class_Vector3Array>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Array of Vector3 can only contain 3D Vectors.
 
-`ColorArray <https://github.com/okamstudio/godot/wiki/class_colorarray>`__
+:ref:`ColorArray <class_ColorArray>`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Array of Color can only contains colors.

tutorials/2d/canvas_layers.rst

@@ -7,23 +7,23 @@ Viewport and Canvas Items
 -------------------------
 
 Regular 2D nodes, such as
-`Node2D <https://github.com/okamstudio/godot/wiki/class_node2d>`__ or
-`Control <https://github.com/okamstudio/godot/wiki/class_control>`__
+:ref:`Node2D <class_Node2D>` or
+:ref:`Control <class_Control>`
 both inherit from
-`CanvasItem <https://github.com/okamstudio/godot/wiki/class_canvasitem>`__,
+:ref:`CanvasItem <class_CanvasItem>`,
 which is the base for all 2D nodes. CanvasItems can be arranged in trees
 and they will inherit their transform. This means that, moving the
 parent, the children will be moved too.
 
 | These nodes are placed as direct or indirect children to a
-  `Viewport <https://github.com/okamstudio/godot/wiki/class_viewport>`__,
+  :ref:`Viewport <class_Viewport>`,
   and will be displayed through it.
 | Viewport has a property "canvas\_transform"
   :ref:`Viewport.set_canvas_transform() <class_Viewport_set_canvas_transform>`,
   which allows to transform all the CanvasItem hierarchy by a custom
-  `Matrix32 <https://github.com/okamstudio/godot/wiki/class_matrix32>`__
+  :ref:`Matrix32 <class_Matrix32>`
   transform. Nodes such as
-  `Camera2D <https://github.com/okamstudio/godot/wiki/class_camera2d>`__,
+  :ref:`Camera2D <class_Camera2D>`,
   work by changing that transform.
 
 Changing the canvas transform is useful because it is a lot more
@@ -51,7 +51,7 @@ CanvasLayers
 ------------
 
 The answer is
-`CanvasLayer <https://github.com/okamstudio/godot/wiki/class_canvaslayer>`__,
+:ref:`CanvasLayer <class_CanvasLayer>`,
 which is a node that adds a separate 2D rendering layer for all it's
 children and grand-children. Viewport children will draw by default at
 layer "0", while a CanvasLayer will draw at any numeric layer. Layers

tutorials/2d/custom_drawing_in_2d.rst

@@ -11,8 +11,8 @@ stuff. For far most cases this is enough, but not always. If something
 desired is not supported, and before crying in fear, angst and range
 because a node to draw that-specific-something does not exist.. it would
 be good to know that it is possible to easily make any 2D node (be it
-`Control <https://github.com/okamstudio/godot/wiki/class_control>`__ or
-`Node2D <https://github.com/okamstudio/godot/wiki/class_node2d>`__
+:ref:`Control <class_Control>` or
+:ref:`Node2D <class_Node2D>`
 based) draw custom commands. It is *really* easy to do it too.
 
 But..
@@ -38,10 +38,10 @@ OK, How?
 --------
 
 Add a script to any
-`CanvasItem <https://github.com/okamstudio/godot/wiki/class_canvasitem>`__
+:ref:`CanvasItem <class_CanvasItem>`
 derived node, like
-`Control <https://github.com/okamstudio/godot/wiki/class_control>`__ or
-`Node2D <https://github.com/okamstudio/godot/wiki/class_node2d>`__.
+:ref:`Control <class_Control>` or
+:ref:`Node2D <class_Node2D>`.
 Override the \_draw() function.
 
 ::
@@ -53,7 +53,7 @@ Override the \_draw() function.
         pass
 
 Draw commands are described in the
-`CanvasItem <https://github.com/okamstudio/godot/wiki/class_canvasitem>`__
+:ref:`CanvasItem <class_CanvasItem>`
 class reference. There are plenty of them.
 
 Updating

tutorials/2d/custom_gui_controls.rst

@@ -59,7 +59,7 @@ them to lay out properly, when set into grids, containers, or anchored.
 Controls most of the time provide a *minimum size* to help to properly
 lay them out. For example, if controls are placed vertically on top of
 each other using a
-`VBoxContainer <https://github.com/okamstudio/godot/wiki/class_vboxcontainer>`__,
+:ref:`VBoxContainer <class_VBoxContainer>`,
 the minimum size will make sure your custom control is not squished by
 the other controls in the container.
 

tutorials/2d/cutout_animation.rst

@@ -40,7 +40,7 @@ unlike other tools meant for this, Godot has the following advantages:
    to be mixed, very useful for complex objects, such as shape of hands
    and foot, changing face expression, etc.
 -  **Custom Shaped Elements**: Can be created with
-   `Polygon2D <https://github.com/okamstudio/godot/wiki/class_polygon2d>`__
+   :ref:`Polygon2D <class_Polygon2D>`
    allowing the mixing of UV animation, deformations, etc.
 -  **Particle Systems**: Can also be mixed with the traditional
    animation hierarchy, useful for magic effecs, jetpacks, etc.
@@ -88,7 +88,7 @@ rotating the torso:
 | Ouch, that doesn't look good! The rotation pivot is wrong, this means
   it needs to be adjusted.
 | This small little cross in the middle of the
-  `Sprite <https://github.com/okamstudio/godot/wiki/class_sprite>`__ is
+  :ref:`Sprite <class_Sprite>` is
   the rotation pivot:
 
 .. image:: /img/tuto_cutout4.png
@@ -138,7 +138,7 @@ RemoteTransform2D Node
 ~~~~~~~~~~~~~~~~~~~~~~
 
 | Godot provides a special node,
-  `RemoteTransform2D <https://github.com/okamstudio/godot/wiki/class_remotetransform2d>`__.
+  :ref:`RemoteTransform2D <class_RemoteTransform2D>`.
   This node will transform nodes that are sitting somewhere else in the
   hierarchy, by copying it's transform to the remote node.
 | This enables to have a visibility order independent from the
@@ -214,7 +214,7 @@ useful skeleton.
 
 The first step is creating an endpoint node. Any kind of node will do,
 but
-`Position2D <https://github.com/okamstudio/godot/wiki/class_position2d>`__
+:ref:`Position2D <class_Position2D>`
 is preferred because it's visible in the editor. The endpoint node will
 ensure that the last bone has orientation
 

tutorials/2d/gui_skinning.rst

@@ -8,11 +8,11 @@ Oh Beautiful GUI!
 
 This tutorial is about advanced skinning of an user interface. Most
 games generally don't need this, as they end up just relying on
-`Label <https://github.com/okamstudio/godot/wiki/class_label>`__,
-`TextureFrame <https://github.com/okamstudio/godot/wiki/class_textureframe>`__,
-`TextureButton <https://github.com/okamstudio/godot/wiki/class_texturebutton>`__
+:ref:`Label <class_Label>`,
+:ref:`TextureFrame <class_TextureFrame>`,
+:ref:`TextureButton <class_TextureButton>`
 and
-`TextureProgress <https://github.com/okamstudio/godot/wiki/class_textureprogress>`__.
+:ref:`TextureProgress <class_TextureProgress>`.
 
 However, many types of games often need complex user interfaces, like
 MMOs, traditional RPGs, Simulators, Strategy, etc. These kind of
@@ -27,7 +27,7 @@ Theme
 -----
 
 The GUI is skinned through the
-`Theme <https://github.com/okamstudio/godot/wiki/class_theme>`__
+:ref:`Theme <class_Theme>`
 resource. Theme contains all the information required to change the
 entire visual styling of all controls. Theme options are named, so it's
 not obvious which name changes what (specialy from code), but several

tutorials/2d/kinematic_character_2d.rst

@@ -99,7 +99,7 @@ now! Kinematic body will do nothing by default, but it has a really
 useful function called
 `move(motion\_vector:Vector2) <https://github.com/okamstudio/godot/wiki/class_kinematicbody2d#move>`__.
 This function takes a
-`Vector2 <https://github.com/okamstudio/godot/wiki/class_vector2>`__ as
+:ref:`Vector2 <class_Vector2>` as
 an argument, and tries to apply that motion to the kinematic body. If a
 collision happens, it stops right at the moment of the collision.
 

tutorials/2d/particle_systems_2d.rst

@@ -21,7 +21,7 @@ Particles2D
 ~~~~~~~~~~~
 
 Particle systems are added to the scene via the
-`Particles2D <https://github.com/okamstudio/godot/wiki/class_particles2d>`__
+:ref:`Particles2D <class_Particles2D>`
 node. They are enabled by default and start emitting white points
 downwards (as affected by the gravity). This provides a reasonable
 starting point to start adapting it to our needs.

tutorials/2d/physics_introduction.rst

@@ -16,18 +16,18 @@ Shapes
 ------
 
 The base collidable object in Godot's 2D world is a
-`Shape2D <https://github.com/okamstudio/godot/wiki/class_shape2d>`__.
+:ref:`Shape2D <class_Shape2D>`.
 There are many types of shapes, all of them inherit this base class:
 
--  `CircleShape2D <https://github.com/okamstudio/godot/wiki/class_circleshape2d>`__
--  `RectangleShape2D <https://github.com/okamstudio/godot/wiki/class_rectangleshape2d>`__
--  `CapsuleShape2D <https://github.com/okamstudio/godot/wiki/class_capsuleshape2d>`__
--  `ConvexPolygonShape2D <https://github.com/okamstudio/godot/wiki/class_convexpolygonshape2d>`__
--  `ConcavePolygonShape2D <https://github.com/okamstudio/godot/wiki/class_concavepolygonshape2d>`__
+-  :ref:`CircleShape2D <class_CircleShape2D>`
+-  :ref:`RectangleShape2D <class_RectangleShape2D>`
+-  :ref:`CapsuleShape2D <class_CapsuleShape2D>`
+-  :ref:`ConvexPolygonShape2D <class_ConvexPolygonShape2D>`
+-  :ref:`ConcavePolygonShape2D <class_ConcavePolygonShape2D>`
 -  etc. (there are others check the class list).
 
 Shapes are of type
-`Resource <https://github.com/okamstudio/godot/wiki/class_resource>`__,
+:ref:`Resource <class_Resource>`,
 but they can be created via code easily. For example:
 
 ::
@@ -62,7 +62,7 @@ Transforming Shapes
 
 As seen before in the collide functions, 2D shapes in godot can be
 transformed by using a regular
-`Matrix32 <https://github.com/okamstudio/godot/wiki/class_matrix32>`__
+:ref:`Matrix32 <class_Matrix32>`
 transform, meaning the can check collision while scaled, moved and
 rotated. The only limitation to this is that shapes with curved sections
 (such as circle and capsule) can only be scaled uniformly. This means
@@ -123,13 +123,13 @@ levels and layers of functionality. The built-in physics engine can be
 used for:
 
 -  Simple Collision Detection: See
-   `Shape2D <https://github.com/okamstudio/godot/wiki/class_shape2d>`__
+   :ref:`Shape2D <class_Shape2D>`
    API.
 -  Scene Kinematics: Handle shapes, collisions, broadphase, etc as
    nodes. See
-   `Area2D <https://github.com/okamstudio/godot/wiki/class_area2d,"StaticBody2D":https://github.com/okamstudio/godot/wiki/class_staticbody2d,"KinematicBody2D":https://github.com/okamstudio/godot/wiki/class_kinematicbody2d>`__.
+   :ref:`Area2D <class_Area2D>`.
 -  Scene Physics: Rigid bodies and constraints as nodes. See
-   `RigidBody2D <https://github.com/okamstudio/godot/wiki/class_rigidbody2d>`__,
+   :ref:`RigidBody2D <class_RigidBody2D>`,
    and the joint nodes.
 
 Units of Measure
@@ -145,7 +145,7 @@ straightforward.
 CollisionObject2D
 -----------------
 
-`CollisionObject2D <https://github.com/okamstudio/godot/wiki/class_collisionobject2d>`__
+:ref:`CollisionObject2D <class_CollisionObject2D>`
 is the (virtual) base node for everything that can be collided in 2D.
 Area2D, StaticBody2D, KinematicBody2D and RigidBody2D all inherit from
 it. This node contains a list of shapes (Shape2D) and a relative
@@ -178,7 +178,7 @@ CollisionShape2D
 
 This node is a helper node. It must be created as a direct children of a
 CollisionObject2D derived node
-(`Area2D <https://github.com/okamstudio/godot/wiki/class_area2d,"StaticBody2D":https://github.com/okamstudio/godot/wiki/class_staticbody2d,"KinematicBody2D":https://github.com/okamstudio/godot/wiki/class_kinematicbody2d,"RigidBody2D":https://github.com/okamstudio/godot/wiki/class_rigidbody2d)>`__.
+:ref:`Area2D <class_Area2D>`.
 
 By itself it does nothing, but when created as a child of the above
 mentioned nodes, it adds collision shapes to them. Any amount of
@@ -231,7 +231,7 @@ the CollisionObject2D:
 KinematicBody2D
 ~~~~~~~~~~~~~~~
 
-`Kinematic <https://github.com/okamstudio/godot/wiki/class_kinematicbody2d>`__
+:ref:`Kinematic <class_Kinematic>`
 bodies are special types of bodies that are meant to be user-controlled.
 They are not affected by the physics at all (to other types of bodies,
 such a character or a rigidbody, these are the same as a staticbody).
@@ -239,7 +239,7 @@ They have however, two main uses:
 
 -  **Simulated Motion**: When these bodies are moved manually, either
    from code or from an
-   `AnimationPlayer <https://github.com/okamstudio/godot/wiki/class_animationplayer>`__
+   :ref:`AnimationPlayer <class_AnimationPlayer>`
    (with process mode set to fixed!), the physics will automatically
    compute an estimate of their linear and angular velocity. This makes
    them very useful for moving platforms or other
@@ -258,7 +258,7 @@ RigidBody2D
 This type of body simulates newtonian physics. It has mass, friction,
 bounce, and the 0,0 coordinates simulates the center of mass. When real
 physics are needed,
-`RigidBody2D <https://github.com/okamstudio/godot/wiki/class_rigidbody2d>`__
+:ref:`RigidBody2D <class_RigidBody2D>`
 is the node to use. The motion of this body is affected by gravity
 and/or other bodies.
 
@@ -289,7 +289,7 @@ function must be overridden:
        [use state to change the object]
 
 The \`state\` parameter is of type
-`Physics2DDirectBodyState <https://github.com/okamstudio/godot/wiki/class_physics2ddirectbodystate>`__.
+:ref:`Physics2DDirectBodyState <class_Physics2DDirectBodyState>`.
 Please do not use this object (state) outside the callback as it will
 result in an error.
 
@@ -395,7 +395,7 @@ and record the intersection.
 
 At the moment there isn't a high level API for this, so the physics
 server must be used directly. For this, the
-`Physics2DDirectspaceState <https://github.com/okamstudio/godot/wiki/class_physics2ddirectspacestate>`__
+:ref:`Physics2DDirectspaceState <class_Physics2DDirectspaceState>`
 class must be used. To obtain it, the following steps must be taken:
 
 | 1. It must be used inside the \_fixed\_process() callback, or at

tutorials/2d/screen-reading_shaders.rst

@@ -75,7 +75,7 @@ source for texscreen() as the first one below, so the first one
 "dissapears", or is not visible.
 
 To correct this, a
-`BackBufferCopy <https://github.com/okamstudio/godot/wiki/class_backbuffercopy>`__
+:ref:`BackBufferCopy <class_BackBufferCopy>`
 node can be instanced between both spheres. BackBufferCopy can work by
 either specifying a screen region or the whole screen:
 

tutorials/2d/tilemap.rst

@@ -30,7 +30,7 @@ Create the TileSet Scene
 ------------------------
 
 We will be creating a
-`TileSet <https://github.com/okamstudio/godot/wiki/class_tileset>`__
+:ref:`TileSet <class_TileSet>`
 resource. While this resource exports properties, it's pretty difficult
 to get complex data into it and maintain it:
 
@@ -114,7 +114,7 @@ Using the TileSet in a TileMap
 ------------------------------
 
 Create a new scene, use any node or node2d as root, then create a
-`TileMap <https://github.com/okamstudio/godot/wiki/class_tilemap>`__ as
+:ref:`TileMap <class_TileMap>` as
 a child.
 
 .. image:: /img/tilemap_scene.png

tutorials/2d/viewport_and_canvas_transforms.rst

@@ -19,11 +19,11 @@ CanvasItem node (remember that Node2D and Control based nodes use
 CanvasItem as their common root) will reside in a *Canvas Layer*. Every
 canvas layer has a transform (translation, rotation, scale, etc) that
 can be accessed as a
-`Matrix32 <https://github.com/okamstudio/godot/wiki/class_matrix32>`__.
+:ref:`Matrix32 <class_Matrix32>`.
 
 By default, nodes are drawn in Layer 0, in the built-in canvas. To put
 nodes in a different layer, a
-`CanvasLayer <https://github.com/okamstudio/godot/wiki/class_canvaslayer>`__
+:ref:`CanvasLayer <class_CanvasLayer>`
 node can be used. This was covered in the previous tutorial anyway, just
 refreshing.
 
@@ -31,7 +31,7 @@ Global Canvas Transform
 -----------------------
 
 Viewports also have a Global Canvas transform (also a
-`Matrix32 <https://github.com/okamstudio/godot/wiki/class_matrix32>`__
+:ref:`Matrix32 <class_Matrix32>`
 ). This is the master transform and affects all individual *Canvas
 Layer* transforms. Generally this transform is not of much use, but is
 used in the CanvasItem Editor in Godot's editor.

tutorials/3d/3d_performance_and_limitations.rst

@@ -49,7 +49,7 @@ Reuse Shaders and Materials
 
 Godot renderer is a little different to what is out there. It's designed
 to minimize GPU state changes as much as possible.
-`FixedMaterial <https://github.com/okamstudio/godot/wiki/class_fixedmaterial>`__
+:ref:`FixedMaterial <class_FixedMaterial>`
 does a good job at reusing materials that need similar shaders but, if
 custom shaders are used, make sure to reuse them as much as possible.
 Godot's priorities will be like this:
@@ -162,7 +162,7 @@ Level of Detail (LOD)
 As also mentioned before, using objects with less vertices can improve
 performance in some cases. Godot has a very simple system to use level
 of detail,
-`GeometryInstance <https://github.com/okamstudio/godot/wiki/class_geometryinstance>`__
+:ref:`GeometryInstance <class_GeometryInstance>`
 based objects have a visibility range that can be defined. Having
 several GeometryInstance objects in different ranges works as LOD.
 
@@ -171,7 +171,7 @@ Use Instancing (MultiMesh)
 
 If several identical objects have to be drawn in the same place or
 nearby, try using
-`MultiMesh <https://github.com/okamstudio/godot/wiki/class_multimesh>`__
+:ref:`MultiMesh <class_MultiMesh>`
 instead. MultiMesh allows drawing of dozens of thousands of objects at
 very little performance cost, making it ideal for flocks, grass,
 particles, etc.

tutorials/3d/fixed_materials.rst

@@ -12,7 +12,7 @@ in 3D DCCs (such as Maya, 3DS Max or Blender). The big advantage of
 using them is that 3D artists are very familiar with this layout. They
 also allow to try out different things quickly without the need of
 writing shaders. Fixed Materials inherit from
-`Material <https://github.com/okamstudio/godot/wiki/class_material>`__,
+:ref:`Material <class_Material>`,
 which also has several options. If you haven't read it before, reading
 the :ref:`doc_materials` tutorial is recommended.
 

tutorials/3d/high_dynamic_range.rst

@@ -90,7 +90,7 @@ Linear -> sRGB at the end.
 After all the rendering is done, the linear-space rendered image must be
 converted back to sRGB. To do this, simply enable sRGB conversion in the
 current
-`Environment <https://github.com/okamstudio/godot/wiki/class_environment>`__
+:ref:`Environment <class_Environment>`
 (more on that below).
 
 Keep in mind that sRGB [STRIKEOUT:> Linear and Linear]> sRGB conversions
@@ -102,9 +102,9 @@ Parameters of HDR
 -----------------
 
 HDR is found in the
-`Environment <https://github.com/okamstudio/godot/wiki/class_environment>`__
+:ref:`Environment <class_Environment>`
 resource. These are found most of the time inside a
-`WorldEnvironment <https://github.com/okamstudio/godot/wiki/class_worldenvironment>`__
+:ref:`WorldEnvironment <class_WorldEnvironment>`
 node, or set in a camera. There are many parameters for HDR:
 
 .. image:: /img/hdr_parameters.png

tutorials/3d/introduction.rst

@@ -19,12 +19,12 @@ efficiently developing 3D games.
 Spatial Node
 ~~~~~~~~~~~~
 
-`Node2D <https://github.com/okamstudio/godot/wiki/class_node2d>`__ is
+:ref:`Node2D <class_Node2D>` is
 the base node for 2D.
-`Control <https://github.com/okamstudio/godot/wiki/class_control>`__ is
+:ref:`Control <class_Control>` is
 the base node for everything GUI. Following this reasoning, the 3D
 engine uses the
-`Spatial <https://github.com/okamstudio/godot/wiki/class_spatial>`__
+:ref:`Spatial <class_Spatial>`
 node for everything 3D.
 
 .. image:: /img/tuto_3d1.png
@@ -32,9 +32,9 @@ node for everything 3D.
 Spatial nodes have a local transform, which is relative to the parent
 node (as long as the parent node is also **or inherits** of type
 Spatial). This transform can be accessed as a 4x3
-`Transform <https://github.com/okamstudio/godot/wiki/class_transform>`__,
+:ref:`Transform <class_Transform>`,
 or as 3
-`Vector3 <https://github.com/okamstudio/godot/wiki/class_vector3>`__
+:ref:`Vector3 <class_Vector3>`
 members representing location, euler rotation (x,y and z angles) and
 scale.
 
@@ -60,18 +60,18 @@ skeletal rigs, blend shapes, etc.
 The second pipeline is through the :ref:`doc_importing_3d_meshes` importer. This
 second method allows importing simple .OBJ files as mesh resources,
 which can be then put inside a
-`MeshInstance <https://github.com/okamstudio/godot/wiki/class_meshinstance>`__
+:ref:`MeshInstance <class_MeshInstance>`
 node for display.
 
 Generated Geometry
 ------------------
 
 It is possible to create custom geometry by using the
-`Mesh <https://github.com/okamstudio/godot/wiki/class_mesh>`__ resource
+:ref:`Mesh <class_Mesh>` resource
 directly, simply create your arrays and use the
 :ref:`Mesh.add_surface() <class_Mesh_add_surface>`
 function. A helper class is also available,
-`SurfaceTool <https://github.com/okamstudio/godot/wiki/class_surfacetool>`__,
+:ref:`SurfaceTool <class_SurfaceTool>`,
 which provides a more straightforward API and helpers for indexing,
 generating normals, tangents, etc.
 
@@ -84,7 +84,7 @@ Immediate Geometry
 
 If, instead, there is a requirement to generate simple geometry that
 will be updated often, Godot provides a special node,
-`ImmediateGeometry <https://github.com/okamstudio/godot/wiki/class_immediategeometry>`__
+:ref:`ImmediateGeometry <class_ImmediateGeometry>`
 which provides an OpenGL 1.x style immediate-mode API to create points,
 lines, triangles, etc.
 
@@ -94,9 +94,9 @@ lines, triangles, etc.
 While Godot packs a powerful 2D engine, many types of games use 2D in a
 3D environment. By using a fixed camera (either orthogonal or
 perspective) that does not rotate, nodes such as
-`Sprite3D <https://github.com/okamstudio/godot/wiki/class_sprite3d>`__
+:ref:`Sprite3D <class_Sprite3D>`
 and
-`AnimatedSprite3D <https://github.com/okamstudio/godot/wiki/class_animatedsprite3d>`__
+:ref:`AnimatedSprite3D <class_AnimatedSprite3D>`
 can be used to create 2D games that take advantage of mixing with 3D
 backgrounds, more realistic parallax, lighting/shadow effects, etc.
 
@@ -109,7 +109,7 @@ Environment
 
 Besides editing a scene, it is often common to edit the environment.
 Godot provides a
-`WorldEnvironment <https://github.com/okamstudio/godot/wiki/class_worldenvironment>`__
+:ref:`WorldEnvironment <class_WorldEnvironment>`
 node that allows changing the background color, mode (as in, put a
 skybox), and applying several types of built-in post-processing effects.
 Environments can also be overriden in the Camera.
@@ -209,7 +209,7 @@ Cameras
 
 No matter how many objects are placed in 3D space, nothing will be
 displayed unless a
-`Camera <https://github.com/okamstudio/godot/wiki/class_camera>`__ is
+:ref:`Camera <class_Camera>` is
 also added to the scene. Cameras can either work in orthogonal or
 perspective projections:
 

tutorials/3d/lighting.rst

@@ -13,7 +13,7 @@ result. Light can come from several types of sources in a scene:
    it does not affect nearby objects unless baked).
 -  Light Nodes: Directional, Omni and Spot.
 -  Ambient Light in the
-   `Environment <https://github.com/okamstudio/godot/wiki/class_worldenvironment>`__.
+   :ref:`Environment <class_Environment>`.
 -  Baked Light (read :ref:`doc_light_baking`).
 
 The emission color is a material property, as seen in the previous

tutorials/3d/materials.rst

@@ -9,9 +9,9 @@ Introduction
 | Materials can be applied to most visible 3D objects, they basically
   are a description to how light reacts to that object. There are many
   types of materials, but the main ones are the
-  `FixedMaterial <https://github.com/okamstudio/godot/wiki/class_fixedmaterial>`__
+  :ref:`FixedMaterial <class_FixedMaterial>`
   and
-  `ShaderMaterial <https://github.com/okamstudio/godot/wiki/class_shadermaterial>`__.
+  :ref:`ShaderMaterial <class_ShaderMaterial>`.
   Tutorials for each of them exist :ref:`doc_fixed_materials` and :ref:`doc_shader_materials`.
 | This tutorial is about the basic properties shared between them.
 

tutorials/engine/encrypting_save_games.rst

@@ -32,7 +32,7 @@ encrypt savegames and protect the world order.
 How?
 ----
 
-The class `File <https://github.com/okamstudio/godot/wiki/class_file>`__
+The class :ref:`File <class_File>`
 is simple to use, just open a location and read/write data (integers,
 strings and variants). To create an encrypted file, a passphrase must be
 provided, like this:

tutorials/engine/handling_quit_request.rst

@@ -15,7 +15,7 @@ Handling the Notification
 -------------------------
 
 The
-`MainLoop <https://github.com/okamstudio/godot/wiki/class_mainloop>`__
+:ref:`MainLoop <class_MainLoop>`
 has a special notification that is sent to all nodes when quit is
 requested: MainLoop.NOTIFICATION\_WM\_QUIT.
 

tutorials/engine/internationalizing_a_game.rst

@@ -47,8 +47,7 @@ locale.
 Converting Keys to Text
 -----------------------
 
-Some controls such as
-`Button <https://github.com/okamstudio/godot/wiki/class_button,"Label":https://github.com/okamstudio/godot/wiki/class_label,etc>`__.
+Some controls such as :ref:`Button <class_Button>`, :ref:`Label <class_Label>`, etc.
 will automatically fetch a translation each time they are set a key
 instead of a text. For example, if a label is assigned
 "MAIN\_SCREEN\_GREETING1" and a key to different languages exists in the
@@ -73,9 +72,9 @@ Making Controls Resizeable
 The same text in different languages can vary greatly in length. For
 this, make sure to read the tutorial on :ref:`doc_size_and_anchors`, as having
 dynamically adjusted control sizes may help.
-`Containers <https://github.com/okamstudio/godot/wiki/class_container>`__
+:ref:`Containers <class_Containers>`
 can be very useful, as well as the multiple options in
-`Label <https://github.com/okamstudio/godot/wiki/class_label>`__ for
+:ref:`Label <class_Label>` for
 text wrapping.
 
 TranslationServer
@@ -83,7 +82,7 @@ TranslationServer
 
 Godot has a server for handling the low level translation management
 called the
-`TranslationServer <https://github.com/okamstudio/godot/wiki/class_translationserver>`__.
+:ref:`TranslationServer <class_TranslationServer>`.
 Translations can be added or removed during run-time, and the current
 language be changed too.
 

tutorials/engine/multiple_resolutions.rst

@@ -26,7 +26,7 @@ There are several types of devices, with several types of screens, which
 in turn have different pixel density and resolutions. Handling all of
 them can be a lot of work, so Godot tries to make the developer's life a
 little easier. The
-`Viewport <https://github.com/okamstudio/godot/wiki/class_viewport>`__
+:ref:`Viewport <class_Viewport>`
 node has several functions to handle resizing, and the root node of the
 scene tree is always a viewport (scenes loaded are instanced as a child
 of it, and it can always be accessed by calling
@@ -57,7 +57,7 @@ Stretch Mode
    to higher-res) and 2D will also be rendered at higher-res, just
    enlarged.
 -  **Viewport**: Viewport scaling is different, the root
-   `Viewport <https://github.com/okamstudio/godot/wiki/class_viewport>`__
+   :ref:`Viewport <class_Viewport>`
    is set as a render target, and still renders precisely to the
    resolution specified in the ``display/`` section of the project
    settings. Finally, this viewport is copied and scaled to fit the

tutorials/engine/viewports.rst

@@ -10,7 +10,7 @@ Godot has a small but very useful feature called viewports. Viewports
 are, as they name implies, rectangles where the world is drawn. They
 have three main uses, but can flexibly adapted to a lot more. All this
 is done via the
-`Viewport <https://github.com/okamstudio/godot/wiki/class_viewport>`__
+:ref:`Viewport <class_Viewport>`
 node.
 
 .. image:: /img/viewportnode.png
@@ -22,11 +22,11 @@ The main uses in question are:
    know this by having read previous tutorials!)
 -  **Sub-Viewports**: These can be created when a Viewport is a child of
    a
-   `Control <https://github.com/okamstudio/godot/wiki/class_control>`__.
+   :ref:`Control <class_Control>`.
 -  **Render Targets**: Viewports can be set to "RenderTarget" mode. This
    means that the viewport is not directly visible, but it's contents
    can be accessed via a
-   `Texture <https://github.com/okamstudio/godot/wiki/class_texture>`__.
+   :ref:`Texture <class_Texture>`.
 
 Input
 -----
@@ -51,8 +51,8 @@ Cameras (2D & 3D)
 -----------------
 
 When using a 2D or 3D
-`Camera <https://github.com/okamstudio/godot/wiki/class_camera>`__ /
-`Camera2D <https://github.com/okamstudio/godot/wiki/class_camera2d>`__,
+:ref:`Camera <class_Camera>` /
+:ref:`Camera2D <class_Camera2D>`,
 cameras will always display on the closest parent viewport (going
 towards the root). For example, in the following hierarchy:
 
@@ -101,7 +101,7 @@ Worlds
 ------
 
 For 3D, a Viewport will contain a
-`World <https://github.com/okamstudio/godot/wiki/class_world>`__. This
+:ref:`World <class_World>`. This
 is basically, the universe that links physics and rendering together.
 Spatial-base nodes will register using the World of the closest
 viewport. By default, newly created viewports do not contain a World but
@@ -119,7 +119,7 @@ the option to use it's own World. This is very useful when you want to
 instance 3D characters or objects in the 2D world.
 
 For 2D, each Viewport always contains it's own
-`World2D <https://github.com/okamstudio/godot/wiki/class_World2D>`__.
+:ref:`World2D <class_World2D>`.
 This suffices in most cases, but in case sharing them may be desired, it
 is possible to do so by calling the viewport API manually.
 
@@ -181,11 +181,11 @@ rendering (once), or always render, no matter if visible or not.
 A few classes are created to make this easier in most common cases
 inside the editor:
 
--  `ViewportSprite <https://github.com/okamstudio/godot/wiki/class_viewportsprite>`__
+-  :ref:`ViewportSprite <class_ViewportSprite>`
    (for 2D).
--  `ViewportQuad <https://github.com/okamstudio/godot/wiki/class_viewportquad>`__
+-  :ref:`ViewportQuad <class_ViewportQuad>`
    (for 3D).
--  `ViewportFrame <https://github.com/okamstudio/godot/wiki/class_viewportframe>`__
+-  :ref:`ViewportFrame <class_ViewportFrame>`
    (for GUI).
 
 Make sure to check the viewport demos! Viewport folder in the demo.zip

tutorials/http_client_class.rst

@@ -4,7 +4,7 @@ HTTP client class example
 =========================
 
 Here's an example of using the
-`HTTPClient <https://github.com/okamstudio/godot/wiki/class_httpclient>`__
+:ref:`HTTPClient <class_HTTPClient>`
 class. It's just a script, so it can be run by executing:
 
 .. raw:: html

tutorials/matrices_and_transforms.rst

@@ -141,7 +141,7 @@ tutorial. We'll just explain how to use transforms.
 Matrix32
 --------
 
-`Matrix32 <https://github.com/okamstudio/godot/wiki/class_matrix32>`__
+:ref:`Matrix32 <class_Matrix32>`
 is a 3x2 matrix. It has 3 Vector2 elements and it's used for 2D. The "X"
 axis is the element 0, "Y" axis is the element 1 and "Origin" is element
 2. It's not divided in basis/origin for convenience, due to it's
@@ -426,14 +426,14 @@ Matrices & Transforms in 3D
 ---------------------------
 
 As mentioned before, for 3D, we deal with 3
-`Vector3 <https://github.com/okamstudio/godot/wiki/class_vector3>`__
+:ref:`Vector3 <class_Vector3>`
 vectors for the rotation matrix, and an extra one for the origin.
 
 Matrix3
 -------
 
 Godot has a special type for a 3x3 matrix, named
-`Matrix3 <https://github.com/okamstudio/godot/wiki/class_matrix3>`__. It
+:ref:`Matrix3 <class_Matrix3>`. It
 can be used to represent a 3D rotation and scale. Sub vectors can be
 accessed as:
 
@@ -477,13 +477,13 @@ Transform
 ---------
 
 To add the final component to the mix, Godot provides the
-`Transform <https://github.com/okamstudio/godot/wiki/class_transform>`__
+:ref:`Transform <class_Transform>`
 type. Transform has two members:
 
 -  *basis* (of type
-   `Matrix3 <https://github.com/okamstudio/godot/wiki/class_matrix3)>`__
+   :ref:`Matrix3 <class_Matrix3>`
 -  *origin* (of type
-   `Vector3 <https://github.com/okamstudio/godot/wiki/class_vector3)>`__
+   :ref:`Vector3 <class_Vector3>`
 
 Any 3D transform can be represented with Transform, and the separation
 of basis and origin makes it easier to work translation and rotation

tutorials/ray-casting.rst

@@ -14,8 +14,8 @@ Introduction
 Godot stores all the low level game information in servers, while the
 scene is just a frontend. As such, ray casting is generally a
 lower-level task. For simple raycasts, node such as
-`RayCast <https://github.com/okamstudio/godot/wiki/class_raycast>`__ and
-`RayCast2D <https://github.com/okamstudio/godot/wiki/class_raycast2d>`__
+:ref:`RayCast <class_RayCast>` and
+:ref:`RayCast2D <class_RayCast2D>`
 will work, as they will return every frame what the result of a raycast
 is.
 
@@ -33,11 +33,11 @@ For 3D, it's
 `Spatial.get\_world().get\_space() <https://github.com/okamstudio/godot/wiki/class_spatial#get_world>`__.
 
 The resulting space
-`RID <https://github.com/okamstudio/godot/wiki/class_rid>`__ can be used
+:ref:`RID <class_RID>` can be used
 in
-`PhysicsServer <https://github.com/okamstudio/godot/wiki/class_physicsserver>`__
+:ref:`PhysicsServer <class_PhysicsServer>`
 and
-`Physics2DServer <https://github.com/okamstudio/godot/wiki/class_physics2dserver>`__
+:ref:`Physics2DServer <class_Physics2DServer>`
 respectively for 3D and 2D.
 
 Acessing Space
@@ -51,9 +51,9 @@ callback. Accessing it from outside this function may result in an error
 due to space being *locked*.
 
 To perform queries into physics space, the
-`Physics2DDirectSpaceState <https://github.com/okamstudio/godot/wiki/class_physics2ddirectspacestate>`__
+:ref:`Physics2DDirectSpaceState <class_Physics2DDirectSpaceState>`
 and
-`PhysicsDirectSpaceState <https://github.com/okamstudio/godot/wiki/class_physicsdirectspacestate>`__
+:ref:`PhysicsDirectSpaceState <class_PhysicsDirectSpaceState>`
 must be used.
 
 In code, for 2D spacestate, this code must be used:
@@ -148,12 +148,12 @@ The extra argument is a list of exceptions, can be objects (need Godot
 
 Casting a ray from screen to 3D physics space is useful for object
 picking. There is not much of a need to do this because
-`CollisionObject <https://github.com/okamstudio/godot/wiki/class_collisionobject>`__
+:ref:`CollisionObject <class_CollisionObject>`
 has an "input\_event" signal that will let you know when it was clicked,
 but in case there is any desire to do it manually, here's how.
 
 To cast a ray from the screen, the
-`Camera <https://github.com/okamstudio/godot/wiki/class_camera>`__ node
+:ref:`Camera <class_Camera>` node
 is needed. Camera can be in two projection modes, perspective and
 orthogonal. Because of this, both the ray origin and direction must be
 obtained. (origin changes in orthogonal, while direction changes in

tutorials/ssl_certificates.rst

@@ -8,9 +8,9 @@ Introduction
 
 It is often desired to use SSL connections for communications to avoid
 "man in the middle" attacks. Godot has a connection wrapper,
-`StreamPeerSSL <https://github.com/okamstudio/godot/wiki/class_streampeerssl>`__,
+:ref:`StreamPeerSSL <class_StreamPeerSSL>`,
 which can take a regular connection and add security around it. The
-`HTTPClient <https://github.com/okamstudio/godot/wiki/class_httpclient>`__
+:ref:`HTTPClient <class_HTTPClient>`
 class also supports HTTPS by using this same wrapper.
 
 For SSL to work, certificates need to be provided. A .crt file must be

tutorials/step_by_step/animations.rst

@@ -17,7 +17,7 @@ Creating the Animation
 ----------------------
 
 First of all, add an
-`AnimationPlayer <https://github.com/okamstudio/godot/wiki/class_animationplayer>`__
+:ref:`AnimationPlayer <class_AnimationPlayer>`
 node to the scene, make it a child of bg (the root node):
 
 .. image:: /img/animplayer.png

tutorials/step_by_step/gui_tutorial.rst

@@ -35,7 +35,7 @@ Control
 ~~~~~~~
 
 The basic node for UI elements is
-`Control <https://github.com/okamstudio/godot/wiki/class_control>`__
+:ref:`Control <class_Control>`
 (sometimes called "Widget" or "Box" in other toolkits). Every node that
 provides user interface functionality descends from it.
 
@@ -62,7 +62,7 @@ button is released, even if the pointer moves outside the control
 boundary.
 
 Like any class that inherits from
-`CanvasItem <https://github.com/okamstudio/godot/wiki/class_canvasitem>`__
+:ref:`CanvasItem <class_CanvasItem>`
 (Control does), a
 :ref:`CanvasItem.draw() <class_CanvasItem_draw>`
 callback will be received at the begining and every time the control
@@ -77,9 +77,9 @@ input events directly when building UIs, (that is more useful when
 creating custom controls). Instead, controls emit different kinds of
 signals with contextural information for when action occurs. For
 example, a
-`Button <https://github.com/okamstudio/godot/wiki/class_button>`__ emits
+:ref:`Button <class_Button>` emits
 a "pressed" signal when pressed, a
-`Slider <https://github.com/okamstudio/godot/wiki/class_slider>`__ will
+:ref:`Slider <class_Slider>` will
 emit a "value\_changed" when dragged, etc.
 
 Custom Control Mini Tutorial
@@ -145,14 +145,14 @@ This set of controls is enough for most games, where complex
 interactions or ways to present information are not necessary. The can
 be skinned easily with regular textures.
 
--  `Label <https://github.com/okamstudio/godot/wiki/class_label>`__ :
+-  :ref:`Label <class_Label>` :
    Node used for showing text.
--  `TextureFrame <https://github.com/okamstudio/godot/wiki/class_textureframe>`__
+-  :ref:`TextureFrame <class_TextureFrame>`
    : Displays a single texture, which can be scaled or kept fixed.
--  `TextureButton <https://github.com/okamstudio/godot/wiki/class_texturebutton>`__
+-  :ref:`TextureButton <class_TextureButton>`
    : Displays a simple texture buttons, states such as pressed, hover,
    disabled, etc can be set.
--  `TextureProgress <https://github.com/okamstudio/godot/wiki/class_textureprogress>`__
+-  :ref:`TextureProgress <class_TextureProgress>`
    : Displays a single textured progress bar.
 
 Additionally, re-positioning of controls is most efficiently done with
@@ -162,9 +162,9 @@ info).
 In any case, it will happen often that even for simple games, more
 complex UI behaviors will be required. An example of this is a scrolling
 list of elements (for a high score table, for example), which needs a
-`ScrollContainer <https://github.com/okamstudio/godot/wiki/class_scrollcontainer>`__
+:ref:`ScrollContainer <class_ScrollContainer>`
 and a
-`VBoxContainer <https://github.com/okamstudio/godot/wiki/class_vboxcontainer>`__.
+:ref:`VBoxContainer <class_VBoxContainer>`.
 These kind of more advanced controls can be mixed with the regular ones
 seamlessly (they are all controls anyway).
 

tutorials/step_by_step/resources.rst

@@ -6,11 +6,11 @@ Resources
 Nodes and Resources
 -------------------
 
-So far, `Node <https://github.com/okamstudio/godot/wiki/class_node>`__
+So far, :ref:`Node <class_Node>`
 have been the most important datatype in Godot, as most of the behaviors
 and features of the engine are implemented through them. There is,
 though, another datatype that is equally as important. That is
-`Resource <https://github.com/okamstudio/godot/wiki/class_resource.>`__.
+:ref:`Resource <class_Resource>`.
 
 | Where *Nodes* focus on behaviors, such as drawing a sprite, drawing a
   3D model, physics, GUI controls, etc,
@@ -19,14 +19,14 @@ though, another datatype that is equally as important. That is
   data.
 
 Examples of resources are
-`Texture <https://github.com/okamstudio/godot/wiki/class_texture>`__,
-`Script <https://github.com/okamstudio/godot/wiki/class_script>`__,
-`Mesh <https://github.com/okamstudio/godot/wiki/class_mesh>`__,
-`Animation <https://github.com/okamstudio/godot/wiki/class_animation>`__,
-`Sample <https://github.com/okamstudio/godot/wiki/class_sample>`__,
-`AudioStream <https://github.com/okamstudio/godot/wiki/class_audiostream>`__,
-`Font <https://github.com/okamstudio/godot/wiki/class_font>`__,
-`Translation <https://github.com/okamstudio/godot/wiki/class_translation>`__,
+:ref:`Texture <class_Texture>`,
+:ref:`Script <class_Script>`,
+:ref:`Mesh <class_Mesh>`,
+:ref:`Animation <class_Animation>`,
+:ref:`Sample <class_Sample>`,
+:ref:`AudioStream <class_AudioStream>`,
+:ref:`Font <class_Font>`,
+:ref:`Translation <class_Translation>`,
 etc.
 
 When Godot saves or loads (from disk) a scene (.scn or .xml), an image
@@ -53,9 +53,9 @@ External vs Built-In
 | The resource properties can reference resources in two ways,
   *external* (on disk) or **built-in**.
 | To be more specific, here's a
-  `Texture <https://github.com/okamstudio/godot/wiki/class_texture>`__
+  :ref:`Texture <class_Texture>`
   in a
-  `Sprite <https://github.com/okamstudio/godot/wiki/class_sprite>`__
+  :ref:`Sprite <class_Sprite>`
   node:
 
 .. image:: /img/spriteprop.png
@@ -104,7 +104,7 @@ Loading Scenes
 
 Scenes are also resources, but there is a catch. Scenes saved to disk
 are resources of type
-`PackedScene <https://github.com/okamstudio/godot/wiki/class_packedscene>`__,
+:ref:`PackedScene <class_PackedScene>`,
 this means that the scene is packed inside a resource.
 
 To obtain an instance of the scene, the method
@@ -121,7 +121,7 @@ must be used.
   the properties) and returns the root node of the scene, which can be
   added to any other node.
 | The approach has several advantages. As the
-  `instance <https://github.com/okamstudio/godot/wiki/class_packedscene#instance()>`__
+  :ref:`PackedScene.instance() <class_PackedScene_instance>`
   function is pretty fast, adding extra content to the scene can be done
   efficiently. New enemies, bullets, effects, etc can be added or
   removed quickly, without having to load them again from disk each
@@ -132,7 +132,7 @@ Freeing Resources
 -----------------
 
 Resource extends from
-`Reference <https://github.com/okamstudio/godot/wiki/class_reference>`__.
+:ref:`Reference <class_Reference>`.
 As such, when a resource is no longer in use, it will automatically free
 itelf. Since, in most cases, Resources are contained in Nodes, scripts
 or other resources, when a node is removed or freed, all the children

tutorials/step_by_step/scene_tree.rst

@@ -22,13 +22,13 @@ MainLoop
 --------
 
 | The way Godot works internally is as follows. There is the the
-  `OS <https://github.com/okamstudio/godot/wiki/class_os>`__ class,
+  :ref:`OS <class_OS>` class,
   which is the only instance that runs at the beginning. Afterwards, all
   drivers, servers, scripting languages, scene system, etc are loaded.
 | When initialization is complete,
-  `OS <https://github.com/okamstudio/godot/wiki/class_os>`__ needs to be
+  :ref:`OS <class_OS>` needs to be
   supplied a
-  `MainLoop <https://github.com/okamstudio/godot/wiki/class_mainloop>`__
+  :ref:`MainLoop <class_MainLoop>`
   to run. Up to this point, all this is internals working (you can check
   main/main.cpp file in the source code if you are ever interested to
   see how this works internally).
@@ -45,11 +45,11 @@ SceneTree
 | One of the ways to explain how Godot works, is that it's a high level
   game engine over a low level middleware.
 | The scene system is the game engine, while the
-  `OS <https://github.com/okamstudio/godot/wiki/class_os>`__ and servers
+  :ref:`OS <class_OS>` and servers
   are the low level API.
 
 | In any case, the scene system provides it's own main loop to OS,
-  `SceneTree <https://github.com/okamstudio/godot/wiki/class_scenetree>`__.
+  :ref:`SceneTree <class_SceneTree>`.
 | This is automatically instanced and set when running a scene, no need
   to do any extra work.
 
@@ -57,7 +57,7 @@ It's important to know that this class exists because it has a few
 important uses:
 
 -  It contains the root
-   `Viewport <https://github.com/okamstudio/godot/wiki/class_viewport>`__,
+   :ref:`Viewport <class_Viewport>`,
    when a scene is first opened, it's added as a child of it to become
    part of the *Scene Tree* (more on that next)
 -  It contains information about the groups, and has means to call all
@@ -66,7 +66,7 @@ important uses:
    mode, or quitting the process.
 
 When a node is part of the Scene Tree, the
-`SceneTree <https://github.com/okamstudio/godot/wiki/class_scenemainloop>`__
+:ref:`SceneTree <class_SceneTree>`
 singleton can be obtained by simply calling
 :ref:`Node.get_tree() <class_Node_get_tree>`.
 
@@ -74,7 +74,7 @@ Root Viewport
 -------------
 
 The root
-`Viewport <https://github.com/okamstudio/godot/wiki/class_viewport>`__
+:ref:`Viewport <class_Viewport>`
 is always a top of the scene. From a node, it can be obtained in two
 different ways:
 
@@ -84,7 +84,7 @@ different ways:
         get_node("/root") # access via absolute path
 
 This node contains the main viewport, anything that is a child of a
-`Viewport <https://github.com/okamstudio/godot/wiki/class_viewport>`__
+:ref:`Viewport <class_Viewport>`
 is drawn inside of it by default, so it makes sense that the top of all
 nodes is always a node of this type, otherwise nothing would be seen!
 

tutorials/step_by_step/scenes_and_nodes.rst

@@ -196,7 +196,7 @@ project, no matter which scene is being edited.
 As a side note, for future reference and a little out of context (this
 is the first tutorial after all!), it is also possible to add custom
 configuration options and read them in run-time using the
-`Globals <https://github.com/okamstudio/godot/wiki/class_globals>`__
+:ref:`Globals <class_Globals>`
 singleton.
 
 To Be Continued...

tutorials/step_by_step/scripting.rst

@@ -182,8 +182,7 @@ will change the label's text:
         get_node("Label").set_text("HELLO!")
 
 Finally, the button "pressed" signal will be connected to that callback
-in \_ready(), by using
-`connect <https://github.com/okamstudio/godot/wiki/class_object#connect()>`__.
+in \_ready(), by using :ref:`Object.connect() <class_Object_connect>`.
 
 ::
 

tutorials/step_by_step/scripting_continued.rst

@@ -89,7 +89,7 @@ calling
     var guards = get_tree().get_nodes_in_group("guards")
 
 More will be added about
-`SceneTree <https://github.com/okamstudio/godot/wiki/class_scenemainloop>`__
+:ref:`SceneTree <class_SceneTree>`
 later.
 
 Notifications
@@ -202,7 +202,7 @@ time.
 
 But 'scene' is still not a node containing subnodes. It's packed in a
 special resource called
-`PackedScene <https://github.com/okamstudio/godot/wiki/class_packedscene>`__.
+:ref:`PackedScene <class_PackedScene>`.
 To create the actual node, the function
 :ref:`PackedScene.instance() <class_PackedScene_instance>`
 must be called. This will return the tree of nodes that can be added to

tutorials/step_by_step/splash_screen.rst

@@ -24,21 +24,21 @@ Create a scene with screen resolution 800x450, and set it up like this:
 .. image:: /img/robisplashpreview.png
 
 The nodes 'background" and "logo" are of
-`TextureFrame <https://github.com/okamstudio/godot/wiki/class_textureframe>`__
+:ref:`TextureFrame <class_TextureFrame>`
 type. These have a special property for setting the texture to be
 displayed, just load the corresponding file.
 
 .. image:: /img/texframe.png
 
 The node "start" is a
-`TextureButton <https://github.com/okamstudio/godot/wiki/class_texturebutton>`__,
+:ref:`TextureButton <class_TextureButton>`,
 it takes several images for different states, but only the normal and
 pressed will be supplied in this example:
 
 .. image:: /img/texbutton.png
 
 Finally, the node "copyright" is a
-`Label <https://github.com/okamstudio/godot/wiki/class_label>`__. Labels
+:ref:`Label <class_Label>`. Labels
 can be set a custom font by editing the following property:
 
 .. image:: /img/label.png

tutorials/vector_math.rst

@@ -97,8 +97,8 @@ Vectors in Godot
 
 To make examples easier, it is worth explaining how vectors are
 implemented in GDScript. GDscript has both
-`Vector2 <https://github.com/okamstudio/godot/wiki/class_vector2>`__ and
-`Vector3 <https://github.com/okamstudio/godot/wiki/class_vector3>`__,
+:ref:`Vector2 <class_Vector2>` and
+:ref:`Vector3 <class_Vector3>`,
 for 2D and 3D math respectively. Godot uses Vector classes as both
 position and direction. They also contain x and y (for 2D) and x, y and
 z (for 3D) member variables.
@@ -463,7 +463,7 @@ by N and D. For example:
 .. image:: /img/tutovec12.png
 
 For 3D math, Godot provides a
-`Plane <https://github.com/okamstudio/godot/wiki/class_plane>`__
+:ref:`Plane <class_Plane>`
 built-in type that handles this.
 
 Basically, N and D can represent any plane in space, be it for 2D or 3D
@@ -504,7 +504,7 @@ inverted negative and positive half spaces:
     D = -D
 
 Of course, Godot implements this operator in
-`Plane <https://github.com/okamstudio/godot/wiki/class_plane>`__, so
+:ref:`Plane <class_Plane>`, so
 doing:
 
 ::