Merge pull request #7655 from Calinou/fix-backticks

tutorials/math/matrices_and_transforms.rst

@@ -50,10 +50,10 @@ You should not worry about manipulating rows directly, as we usually
 work with columns. However, you can think of the rows of the matrix
 as showing which vectors contribute to moving in a given direction.
 
-When we refer to a value such as `t.x.y`, that's the Y component of
+When we refer to a value such as ``t.x.y``, that's the Y component of
 the X column vector. In other words, the bottom-left of the matrix.
-Similarly, `t.x.x` is top-left, `t.y.x` is top-right, and `t.y.y`
-is bottom-right, where `t` is the Transform2D.
+Similarly, ``t.x.x`` is top-left, ``t.y.x`` is top-right, and ``t.y.y``
+is bottom-right, where ``t`` is the Transform2D.
 
 Scaling the transformation matrix
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -184,7 +184,7 @@ matrix, you can use ``atan2(t.x.y, t.x.x)``, where t is the Transform2D.
 Basis of the transformation matrix
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-So far we have only been working with the `x` and `y`, vectors, which
+So far we have only been working with the ``x`` and ``y``, vectors, which
 are in charge of representing rotation, scale, and/or shearing
 (advanced, covered at the end). The X and Y vectors are together
 called the *basis* of the transformation matrix. The terms "basis"

tutorials/physics/using_character_body_2d.rst

@@ -299,7 +299,7 @@ bounce off the walls.
 This example uses three scenes. The main scene contains the Player and Walls.
 The Bullet and Wall are separate scenes so that they can be instanced.
 
-The Player is controlled by the `w` and `s` keys for forward and back. Aiming
+The Player is controlled by the ``w`` and ``s`` keys for forward and back. Aiming
 uses the mouse pointer. Here is the code for the Player, using ``move_and_slide()``:
 
 .. tabs::

tutorials/scripting/gdextension/gdextension_cpp_example.rst

@@ -98,7 +98,7 @@ below.
 To generate and compile the bindings, use this command (replacing ``<platform>``
 with ``windows``, ``linux`` or ``macos`` depending on your OS):
 
-To speed up compilation, add `-jN` at the end of the SCons command line where `N`
+To speed up compilation, add ``-jN`` at the end of the SCons command line where ``N``
 is the number of CPU threads you have on your system. The example below uses 4 threads.
 
 .. code-block:: none

tutorials/shaders/shader_reference/shading_language.rst

@@ -1208,7 +1208,7 @@ is used, it can be scalar or vector.
 +-----------------------------------------------------------------------------+---------------------------------------------------------------------+
 | vec3 **refract** (vec3 I, vec3 N, float eta)                                | Refract.                                                            |
 +-----------------------------------------------------------------------------+---------------------------------------------------------------------+
-| vec_type **faceforward** (vec_type N, vec_type I, vec_type Nref)            | If ``dot(Nref, I)`` < 0, return N, otherwise –N.                    |
+| vec_type **faceforward** (vec_type N, vec_type I, vec_type Nref)            | If ``dot(Nref, I)`` < 0, return ``N``, otherwise ``-N``.            |
 +-----------------------------------------------------------------------------+---------------------------------------------------------------------+
 | mat_type **matrixCompMult** (mat_type x, mat_type y)                        | Matrix component multiplication.                                    |
 +-----------------------------------------------------------------------------+---------------------------------------------------------------------+
@@ -1240,8 +1240,8 @@ is used, it can be scalar or vector.
 +-----------------------------------------------------------------------------+---------------------------------------------------------------------+
 | ivec2 **textureSize** (gsampler2D s, int lod)                               | Get the size of a texture.                                          |
 |                                                                             |                                                                     |
-| ivec3 **textureSize** (gsampler2DArray s, int lod)                          | The LOD defines which mipmap level is used. An LOD value of 0 will  |
-|                                                                             | use the full resolution texture.                                    |
+| ivec3 **textureSize** (gsampler2DArray s, int lod)                          | The LOD defines which mipmap level is used. An LOD value of ``0``   |
+|                                                                             | will use the full resolution texture.                               |
 | ivec3 **textureSize** (gsampler3D s, int lod)                               |                                                                     |
 |                                                                             |                                                                     |
 | ivec2 **textureSize** (samplerCube s, int lod)                              |                                                                     |
@@ -1249,8 +1249,8 @@ is used, it can be scalar or vector.
 | ivec2 **textureSize** (samplerCubeArray s, int lod)                         |                                                                     |
 +-----------------------------------------------------------------------------+---------------------------------------------------------------------+
 | vec2 **textureQueryLod** (gsampler2D s, vec2 p)                             | Compute the level-of-detail that would be used to sample from a     |
-|                                                                             | texture. The `x` component of the resulted value is the mipmap      |
-| vec3 **textureQueryLod** (gsampler2DArray s, vec2 p)                        | array that would be accessed. The `y` component is computed         |
+|                                                                             | texture. The ``x`` component of the resulted value is the mipmap    |
+| vec3 **textureQueryLod** (gsampler2DArray s, vec2 p)                        | array that would be accessed. The ``y`` component is computed       |
 |                                                                             | level-of-detail relative to the base level (regardless of the       |
 | vec2 **textureQueryLod** (gsampler3D s, vec3 p)                             | mipmap levels of the texture).                                      |
 |                                                                             |                                                                     |
@@ -1258,7 +1258,7 @@ is used, it can be scalar or vector.
 +-----------------------------------------------------------------------------+---------------------------------------------------------------------+
 | int **textureQueryLevels** (gsampler2D s)                                   | Get the number of accessible mipmap levels of a texture.            |
 |                                                                             |                                                                     |
-| int **textureQueryLevels** (gsampler2DArray s)                              | If the texture is unassigned to a sampler, `0` is returned.         |
+| int **textureQueryLevels** (gsampler2DArray s)                              | If the texture is unassigned to a sampler, ``0`` is returned.       |
 |                                                                             |                                                                     |
 | int **textureQueryLevels** (gsampler3D s)                                   |                                                                     |
 |                                                                             |                                                                     |
@@ -1282,7 +1282,7 @@ is used, it can be scalar or vector.
 +-----------------------------------------------------------------------------+---------------------------------------------------------------------+
 | gvec4_type **textureLod** (gsampler2D s, vec2 p, float lod)                 | Perform a texture read at custom mipmap.                            |
 |                                                                             |                                                                     |
-| gvec4_type **textureLod** (gsampler2DArray s, vec3 p, float lod)            | The LOD defines which mipmap level is used. An LOD value of 0.0     |
+| gvec4_type **textureLod** (gsampler2DArray s, vec3 p, float lod)            | The LOD defines which mipmap level is used. An LOD value of ``0.0`` |
 |                                                                             | will use the full resolution texture.                               |
 | gvec4_type **textureLod** (gsampler3D s, vec3 p, float lod)                 |                                                                     |
 |                                                                             |                                                                     |
@@ -1292,7 +1292,7 @@ is used, it can be scalar or vector.
 +-----------------------------------------------------------------------------+---------------------------------------------------------------------+
 | gvec4_type **textureProjLod** (gsampler2D s, vec3 p, float lod)             | Performs a texture read with projection/LOD.                        |
 |                                                                             |                                                                     |
-| gvec4_type **textureProjLod** (gsampler2D s, vec4 p, float lod)             | The LOD defines which mipmap level is used. An LOD value of 0.0     |
+| gvec4_type **textureProjLod** (gsampler2D s, vec4 p, float lod)             | The LOD defines which mipmap level is used. An LOD value of ``0.0`` |
 |                                                                             | will use the full resolution texture.                               |
 | gvec4_type **textureProjLod** (gsampler3D s, vec4 p, float lod)             |                                                                     |
 +-----------------------------------------------------------------------------+---------------------------------------------------------------------+
@@ -1318,8 +1318,8 @@ is used, it can be scalar or vector.
 +-----------------------------------------------------------------------------+---------------------------------------------------------------------+
 | gvec4_type **texelFetch** (gsampler2D s, ivec2 p, int lod)                  | Fetches a single texel using integer coordinates.                   |
 |                                                                             |                                                                     |
-| gvec4_type **texelFetch** (gsampler2DArray s, ivec3 p, int lod)             | The LOD defines which mipmap level is used. An LOD value of 0 will  |
-|                                                                             | use the full resolution texture.                                    |
+| gvec4_type **texelFetch** (gsampler2DArray s, ivec3 p, int lod)             | The LOD defines which mipmap level is used. An LOD value of ``0``   |
+|                                                                             | will use the full resolution texture.                               |
 | gvec4_type **texelFetch** (gsampler3D s, ivec3 p, int lod)                  |                                                                     |
 +-----------------------------------------------------------------------------+---------------------------------------------------------------------+
 | gvec4_type **textureGather** (gsampler2D s, vec2 p [, int comps])           | Gathers four texels from a texture.                                 |

tutorials/ui/bbcode_in_richtextlabel.rst

@@ -836,7 +836,7 @@ object, which holds a few variables to control how the associated glyph is rende
   effect. You can use :ref:`get() <class_Dictionary_method_get>` with an optional default value
   to retrieve each parameter, if specified by the user. For example ``[custom_fx spread=0.5
   color=#FFFF00]test[/custom_fx]`` would have a float ``spread`` and Color ``color``
-  parameters in its ` `env`` Dictionary. See below for more usage examples.
+  parameters in its ``env`` Dictionary. See below for more usage examples.
 
 The last thing to note about this function is that it is necessary to return a boolean
 ``true`` value to verify that the effect processed correctly. This way, if there's a problem

tutorials/ui/gui_using_fonts.rst

@@ -860,7 +860,7 @@ how the default font should be rendered:
   :ref:`subpixel positioning <doc_using_fonts_subpixel_positioning>`
   method for the default project font.
 - **Default Font Multichannel Signed Distance Field:** If ``true``, makes the
-  default project font use `MSDF font rendering <doc_using_fonts_msdf>` instead
+  default project font use :ref:`MSDF font rendering <doc_using_fonts_msdf>` instead
   of traditional rasterization.
 - **Default Font Generate Mipmaps:** If ``true``, enables
   :ref:`mipmap <doc_using_fonts_mipmaps>` generation and