Do not combine \a with backticks in doxygen comments

Using \a command displays the next word in italics ignoring the markdown
format so \a `something` display `something` in italics including
backticks.
Removing \a so that backticks are properly interpreted.

include/SFML/Audio/Listener.hpp

@@ -61,7 +61,7 @@ struct Cone
 ////////////////////////////////////////////////////////////
 /// \brief Change the global volume of all the sounds and musics
 ///
-/// \a `volume` is a number between 0 and 100; it is combined
+/// `volume` is a number between 0 and 100; it is combined
 /// with the individual volume of each sound / music.
 /// The default value for the volume is 100 (maximum).
 ///

include/SFML/Audio/Music.hpp

@@ -127,7 +127,7 @@ public:
     /// of supported formats.
     ///
     /// \warning Since the music is not loaded at once but rather
-    /// streamed continuously, the \a `stream` must remain accessible
+    /// streamed continuously, the `stream` must remain accessible
     /// until the `sf::Music` object loads a new music or is destroyed.
     ///
     /// \param stream Source stream to read from
@@ -187,7 +187,7 @@ public:
     /// of supported formats.
     ///
     /// \warning Since the music is not loaded at once but rather streamed
-    /// continuously, the \a `data` buffer must remain accessible until
+    /// continuously, the `data` buffer must remain accessible until
     /// the `sf::Music` object loads a new music or is destroyed. That is,
     /// you can't deallocate the buffer right after calling this function.
     ///
@@ -210,7 +210,7 @@ public:
     /// of supported formats.
     ///
     /// \warning Since the music is not loaded at once but rather
-    /// streamed continuously, the \a `stream` must remain accessible
+    /// streamed continuously, the `stream` must remain accessible
     /// until the `sf::Music` object loads a new music or is destroyed.
     ///
     /// \param stream Source stream to read from

include/SFML/Audio/PlaybackDevice.hpp

@@ -83,7 +83,7 @@ namespace sf::PlaybackDevice
 /// \brief Set the audio playback device
 ///
 /// This function sets the audio playback device to the device
-/// with the given \a `name`. It can be called on the fly (i.e:
+/// with the given `name`. It can be called on the fly (i.e:
 /// while sounds are playing).
 ///
 /// If there are sounds playing when the audio playback

include/SFML/Audio/SoundRecorder.hpp

@@ -57,7 +57,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Start the capture
     ///
-    /// The \a `sampleRate` parameter defines the number of audio samples
+    /// The `sampleRate` parameter defines the number of audio samples
     /// captured per second. The higher, the better the quality
     /// (for example, 44100 samples/sec is CD quality).
     /// This function uses its own thread so that it doesn't block
@@ -125,7 +125,7 @@ public:
     /// \brief Set the audio capture device
     ///
     /// This function sets the audio capture device to the device
-    /// with the given \a `name`. It can be called on the fly (i.e:
+    /// with the given `name`. It can be called on the fly (i.e:
     /// while recording). If you do so while recording and
     /// opening the device fails, it stops the recording.
     ///
@@ -229,7 +229,7 @@ protected:
     /// it over the network, etc.).
     ///
     /// \param samples     Pointer to the new chunk of recorded samples
-    /// \param sampleCount Number of samples pointed by \a `samples`
+    /// \param sampleCount Number of samples pointed by `samples`
     ///
     /// \return `true` to continue the capture, or `false` to stop it
     ///

include/SFML/Graphics/BlendMode.hpp

@@ -191,7 +191,7 @@ SFML_GRAPHICS_API extern const BlendMode BlendNone;     //!< Overwrite dest with
 ///
 /// The blend factors and equations correspond to their OpenGL equivalents.
 /// In general, the color of the resulting pixel is calculated according
-/// to the following formula (\a `src` is the color of the source pixel, \a `dst`
+/// to the following formula (`src` is the color of the source pixel, `dst`
 /// the color of the destination pixel, the other variables correspond to the
 /// public members, with the equations being + or - operators):
 /// \code

include/SFML/Graphics/CircleShape.hpp

@@ -100,7 +100,7 @@ public:
     /// The returned point is in local coordinates, that is,
     /// the shape's transforms (position, rotation, scale) are
     /// not taken into account.
-    /// The result is undefined if \a `index` is out of the valid range.
+    /// The result is undefined if `index` is out of the valid range.
     ///
     /// \param index Index of the point to get, in range [0 .. getPointCount() - 1]
     ///

include/SFML/Graphics/ConvexShape.hpp

@@ -56,7 +56,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Set the number of points of the polygon
     ///
-    /// For the shape to be rendered as expected, \a `count` must
+    /// For the shape to be rendered as expected, `count` must
     /// be greater or equal to 3.
     ///
     /// \param count New number of points of the polygon
@@ -86,7 +86,7 @@ public:
     /// when not drawn (e.g. during shape initialization).
     ///
     /// Point count must be specified beforehand. The behavior is
-    /// undefined if \a `index` is greater than or equal to getPointCount.
+    /// undefined if `index` is greater than or equal to getPointCount.
     ///
     /// \param index Index of the point to change, in range [0 .. getPointCount() - 1]
     /// \param point New position of the point
@@ -102,7 +102,7 @@ public:
     /// The returned point is in local coordinates, that is,
     /// the shape's transforms (position, rotation, scale) are
     /// not taken into account.
-    /// The result is undefined if \a `index` is out of the valid range.
+    /// The result is undefined if `index` is out of the valid range.
     ///
     /// \param index Index of the point to get, in range [0 .. getPointCount() - 1]
     ///

include/SFML/Graphics/Font.hpp

@@ -109,7 +109,7 @@ public:
     /// OpenType, SFNT, X11 PCF, Windows FNT, BDF, PFR and Type 42.
     ///
     /// \warning SFML cannot preload all the font data in this
-    /// function, so the buffer pointed by \a `data` has to remain
+    /// function, so the buffer pointed by `data` has to remain
     /// valid until the `sf::Font` object opens a new font or
     /// is destroyed.
     ///
@@ -129,7 +129,7 @@ public:
     /// The supported font formats are: TrueType, Type 1, CFF,
     /// OpenType, SFNT, X11 PCF, Windows FNT, BDF, PFR and Type 42.
     /// Warning: SFML cannot preload all the font data in this
-    /// function, so the contents of \a `stream` have to remain
+    /// function, so the contents of `stream` have to remain
     /// valid as long as the font is used.
     ///
     /// \warning SFML cannot preload all the font data in this
@@ -174,7 +174,7 @@ public:
     /// OpenType, SFNT, X11 PCF, Windows FNT, BDF, PFR and Type 42.
     ///
     /// \warning SFML cannot preload all the font data in this
-    /// function, so the buffer pointed by \a `data` has to remain
+    /// function, so the buffer pointed by `data` has to remain
     /// valid until the `sf::Font` object opens a new font or
     /// is destroyed.
     ///
@@ -234,7 +234,7 @@ public:
     /// \param bold             Retrieve the bold version or the regular one?
     /// \param outlineThickness Thickness of outline (when != 0 the glyph will not be filled)
     ///
-    /// \return The glyph corresponding to \a `codePoint` and \a `characterSize`
+    /// \return The glyph corresponding to `codePoint` and `characterSize`
     ///
     ////////////////////////////////////////////////////////////
     [[nodiscard]] const Glyph& getGlyph(std::uint32_t codePoint,
@@ -274,7 +274,7 @@ public:
     /// \param characterSize Reference character size
     /// \param bold          Retrieve the bold version or the regular one?
     ///
-    /// \return Kerning value for \a `first` and \a `second`, in pixels
+    /// \return Kerning value for `first` and `second`, in pixels
     ///
     ////////////////////////////////////////////////////////////
     [[nodiscard]] float getKerning(std::uint32_t first, std::uint32_t second, unsigned int characterSize, bool bold = false) const;
@@ -420,7 +420,7 @@ private:
     /// \param bold             Retrieve the bold version or the regular one?
     /// \param outlineThickness Thickness of outline (when != 0 the glyph will not be filled)
     ///
-    /// \return The glyph corresponding to \a `codePoint` and \a `characterSize`
+    /// \return The glyph corresponding to `codePoint` and `characterSize`
     ///
     ////////////////////////////////////////////////////////////
     Glyph loadGlyph(std::uint32_t codePoint, unsigned int characterSize, bool bold, float outlineThickness) const;

include/SFML/Graphics/Image.hpp

@@ -77,8 +77,8 @@ public:
     /// \brief Construct the image from an array of pixels
     ///
     /// The pixel array is assumed to contain 32-bits RGBA pixels,
-    /// and have the given \a `size`. If not, this is an undefined behavior.
+    /// and have the given `size`. If not, this is an undefined behavior.
-    /// If \a `pixels` is `nullptr`, an empty image is created.
+    /// If `pixels` is `nullptr`, an empty image is created.
     ///
     /// \param size   Width and height of the image
     /// \param pixels Array of pixels to copy to the image
@@ -148,8 +148,8 @@ public:
     /// \brief Resize the image from an array of pixels
     ///
     /// The pixel array is assumed to contain 32-bits RGBA pixels,
-    /// and have the given \a `size`. If not, this is an undefined behavior.
+    /// and have the given `size`. If not, this is an undefined behavior.
-    /// If \a `pixels` is `nullptr`, an empty image is created.
+    /// If `pixels` is `nullptr`, an empty image is created.
     ///
     /// \param size   Width and height of the image
     /// \param pixels Array of pixels to copy to the image
@@ -256,7 +256,7 @@ public:
     /// \brief Create a transparency mask from a specified color-key
     ///
     /// This function sets the alpha value of every pixel matching
-    /// the given color to \a `alpha` (0 by default), so that they
+    /// the given color to `alpha` (0 by default), so that they
     /// become transparent.
     ///
     /// \param color Color to make transparent
@@ -273,8 +273,8 @@ public:
     /// static image from several others, but if you need this
     /// kind of feature in real-time you'd better use `sf::RenderTexture`.
     ///
-    /// If \a `sourceRect` is empty, the whole image is copied.
+    /// If `sourceRect` is empty, the whole image is copied.
-    /// If \a `applyAlpha` is set to `true`, alpha blending is
+    /// If `applyAlpha` is set to `true`, alpha blending is
     /// applied from the source pixels to the destination pixels
     /// using the \b over operator. If it is `false`, the source
     /// pixels are copied unchanged with their alpha value.
@@ -283,8 +283,8 @@ public:
     /// details on the \b over operator.
     ///
     /// Note that this function can fail if either image is invalid
-    /// (i.e. zero-sized width or height), or if \a `sourceRect` is
+    /// (i.e. zero-sized width or height), or if `sourceRect` is
-    /// not within the boundaries of the \a `source` parameter, or
+    /// not within the boundaries of the `source` parameter, or
     /// if the destination area is out of the boundaries of this image.
     ///
     /// On failure, the destination image is left unchanged.

include/SFML/Graphics/RectangleShape.hpp

@@ -88,7 +88,7 @@ public:
     /// The returned point is in local coordinates, that is,
     /// the shape's transforms (position, rotation, scale) are
     /// not taken into account.
-    /// The result is undefined if \a `index` is out of the valid range.
+    /// The result is undefined if `index` is out of the valid range.
     ///
     /// \param index Index of the point to get, in range [0 .. 3]
     ///

include/SFML/Graphics/RenderTexture.hpp

@@ -66,7 +66,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Construct a render-texture
     ///
-    /// The last parameter, \a `settings`, is useful if you want to enable
+    /// The last parameter, `settings`, is useful if you want to enable
     /// multi-sampling or use the render-texture for OpenGL rendering that
     /// requires a depth or stencil buffer. Otherwise it is unnecessary, and
     /// you should leave this parameter at its default value.
@@ -115,7 +115,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Resize the render-texture
     ///
-    /// The last parameter, \a `settings`, is useful if you want to enable
+    /// The last parameter, `settings`, is useful if you want to enable
     /// multi-sampling or use the render-texture for OpenGL rendering that
     /// requires a depth or stencil buffer. Otherwise it is unnecessary, and
     /// you should leave this parameter at its default value.

include/SFML/Graphics/RenderWindow.hpp

@@ -67,7 +67,7 @@ public:
     /// \brief Construct a new window
     ///
     /// This constructor creates the window with the size and pixel
-    /// depth defined in \a `mode`. An optional style can be passed to
+    /// depth defined in `mode`. An optional style can be passed to
     /// customize the look and behavior of the window (borders,
     /// title bar, resizable, closable, ...).
     ///
@@ -93,8 +93,8 @@ public:
     /// \brief Construct a new window
     ///
     /// This constructor creates the window with the size and pixel
-    /// depth defined in \a `mode`. If \a `state` is `State::Fullscreen`,
+    /// depth defined in `mode`. If `state` is `State::Fullscreen`,
-    /// then \a `mode` must be a valid video mode.
+    /// then `mode` must be a valid video mode.
     ///
     /// The last parameter is an optional structure specifying
     /// advanced OpenGL context settings such as anti-aliasing,

include/SFML/Graphics/Shader.hpp

@@ -673,7 +673,7 @@ public:
     /// ...
     /// shader.setUniform("the_texture", texture);
     /// \endcode
-    /// It is important to note that \a `texture` must remain alive as long
+    /// It is important to note that `texture` must remain alive as long
     /// as the shader uses it, no copy is made internally.
     ///
     /// To use the texture of the object being drawn, which cannot be

include/SFML/Graphics/Shape.hpp

@@ -57,14 +57,14 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Change the source texture of the shape
     ///
-    /// The \a `texture` argument refers to a texture that must
+    /// The `texture` argument refers to a texture that must
     /// exist as long as the shape uses it. Indeed, the shape
     /// doesn't store its own copy of the texture, but rather keeps
     /// a pointer to the one that you passed to this function.
     /// If the source texture is destroyed and the shape tries to
     /// use it, the behavior is undefined.
-    /// \a `texture` can be a null pointer to disable texturing.
+    /// `texture` can be a null pointer to disable texturing.
-    /// If \a `resetRect` is `true`, the `TextureRect` property of
+    /// If `resetRect` is `true`, the `TextureRect` property of
     /// the shape is automatically adjusted to the size of the new
     /// texture. If it is `false`, the texture rect is left unchanged.
     ///
@@ -204,7 +204,7 @@ public:
     /// The returned point is in local coordinates, that is,
     /// the shape's transforms (position, rotation, scale) are
     /// not taken into account.
-    /// The result is undefined if \a `index` is out of the valid range.
+    /// The result is undefined if `index` is out of the valid range.
     ///
     /// \param index Index of the point to get, in range [0 .. getPointCount() - 1]
     ///

include/SFML/Graphics/Sprite.hpp

@@ -86,13 +86,13 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Change the source texture of the sprite
     ///
-    /// The \a `texture` argument refers to a texture that must
+    /// The `texture` argument refers to a texture that must
     /// exist as long as the sprite uses it. Indeed, the sprite
     /// doesn't store its own copy of the texture, but rather keeps
     /// a pointer to the one that you passed to this function.
     /// If the source texture is destroyed and the sprite tries to
     /// use it, the behavior is undefined.
-    /// If \a `resetRect` is `true`, the `TextureRect` property of
+    /// If `resetRect` is `true`, the `TextureRect` property of
     /// the sprite is automatically adjusted to the size of the new
     /// texture. If it is `false`, the texture rect is left unchanged.
     ///

include/SFML/Graphics/Text.hpp

@@ -95,7 +95,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Set the text's string
     ///
-    /// The \a `string` argument is a `sf::String`, which can
+    /// The `string` argument is a `sf::String`, which can
     /// automatically be constructed from standard string types.
     /// So, the following calls are all valid:
     /// \code
@@ -116,7 +116,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Set the text's font
     ///
-    /// The \a `font` argument refers to a font that must
+    /// The `font` argument refers to a font that must
     /// exist as long as the text uses it. Indeed, the text
     /// doesn't store its own copy of the font, but rather keeps
     /// a pointer to the one that you passed to this function.
@@ -346,13 +346,13 @@ public:
     [[nodiscard]] float getOutlineThickness() const;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Return the position of the \a `index`-th character
+    /// \brief Return the position of the `index`-th character
     ///
     /// This function computes the visual position of a character
     /// from its index in the string. The returned position is
     /// in global coordinates (translation, rotation, scale and
     /// origin are applied).
-    /// If \a `index` is out of range, the position of the end of
+    /// If `index` is out of range, the position of the end of
     /// the string is returned.
     ///
     /// \param index Index of the character

include/SFML/Graphics/Texture.hpp

@@ -116,10 +116,10 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Construct the texture from a sub-rectangle of a file on disk
     ///
-    /// The \a `area` argument can be used to load only a sub-rectangle
+    /// The `area` argument can be used to load only a sub-rectangle
     /// of the whole image. If you want the entire image then leave
     /// the default value (which is an empty `IntRect`).
-    /// If the \a `area` rectangle crosses the bounds of the image, it
+    /// If the `area` rectangle crosses the bounds of the image, it
     /// is adjusted to fit the image size.
     ///
     /// The maximum size for a texture depends on the graphics
@@ -156,10 +156,10 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Construct the texture from a sub-rectangle of a file in memory
     ///
-    /// The \a `area` argument can be used to load only a sub-rectangle
+    /// The `area` argument can be used to load only a sub-rectangle
     /// of the whole image. If you want the entire image then leave
     /// the default value (which is an empty `IntRect`).
-    /// If the \a `area` rectangle crosses the bounds of the image, it
+    /// If the `area` rectangle crosses the bounds of the image, it
     /// is adjusted to fit the image size.
     ///
     /// The maximum size for a texture depends on the graphics
@@ -196,10 +196,10 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Construct the texture from a sub-rectangle of a custom stream
     ///
-    /// The \a `area` argument can be used to load only a sub-rectangle
+    /// The `area` argument can be used to load only a sub-rectangle
     /// of the whole image. If you want the entire image then leave
     /// the default value (which is an empty `IntRect`).
-    /// If the \a `area` rectangle crosses the bounds of the image, it
+    /// If the `area` rectangle crosses the bounds of the image, it
     /// is adjusted to fit the image size.
     ///
     /// The maximum size for a texture depends on the graphics
@@ -235,9 +235,9 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Construct the texture from a sub-rectangle of an image
     ///
-    /// The \a `area` argument is used to load only a sub-rectangle
+    /// The `area` argument is used to load only a sub-rectangle
     /// of the whole image.
-    /// If the \a `area` rectangle crosses the bounds of the image, it
+    /// If the `area` rectangle crosses the bounds of the image, it
     /// is adjusted to fit the image size.
     ///
     /// The maximum size for a texture depends on the graphics
@@ -281,10 +281,10 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Load the texture from a file on disk
     ///
-    /// The \a `area` argument can be used to load only a sub-rectangle
+    /// The `area` argument can be used to load only a sub-rectangle
     /// of the whole image. If you want the entire image then leave
     /// the default value (which is an empty `IntRect`).
-    /// If the \a `area` rectangle crosses the bounds of the image, it
+    /// If the `area` rectangle crosses the bounds of the image, it
     /// is adjusted to fit the image size.
     ///
     /// The maximum size for a texture depends on the graphics
@@ -306,10 +306,10 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Load the texture from a file in memory
     ///
-    /// The \a `area` argument can be used to load only a sub-rectangle
+    /// The `area` argument can be used to load only a sub-rectangle
     /// of the whole image. If you want the entire image then leave
     /// the default value (which is an empty `IntRect`).
-    /// If the \a `area` rectangle crosses the bounds of the image, it
+    /// If the `area` rectangle crosses the bounds of the image, it
     /// is adjusted to fit the image size.
     ///
     /// The maximum size for a texture depends on the graphics
@@ -332,10 +332,10 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Load the texture from a custom stream
     ///
-    /// The \a `area` argument can be used to load only a sub-rectangle
+    /// The `area` argument can be used to load only a sub-rectangle
     /// of the whole image. If you want the entire image then leave
     /// the default value (which is an empty `IntRect`).
-    /// If the \a `area` rectangle crosses the bounds of the image, it
+    /// If the `area` rectangle crosses the bounds of the image, it
     /// is adjusted to fit the image size.
     ///
     /// The maximum size for a texture depends on the graphics
@@ -357,10 +357,10 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Load the texture from an image
     ///
-    /// The \a `area` argument can be used to load only a sub-rectangle
+    /// The `area` argument can be used to load only a sub-rectangle
     /// of the whole image. If you want the entire image then leave
     /// the default value (which is an empty `IntRect`).
-    /// If the \a `area` rectangle crosses the bounds of the image, it
+    /// If the `area` rectangle crosses the bounds of the image, it
     /// is adjusted to fit the image size.
     ///
     /// The maximum size for a texture depends on the graphics
@@ -406,13 +406,13 @@ public:
     /// \brief Update the whole texture from an array of pixels
     ///
     /// The pixel array is assumed to have the same size as
-    /// the \a `area` rectangle, and to contain 32-bits RGBA pixels.
+    /// the `area` rectangle, and to contain 32-bits RGBA pixels.
     ///
     /// No additional check is performed on the size of the pixel
     /// array. Passing invalid arguments will lead to an undefined
     /// behavior.
     ///
-    /// This function does nothing if \a `pixels` is `nullptr`
+    /// This function does nothing if `pixels` is `nullptr`
     /// or if the texture was not previously created.
     ///
     /// \param pixels Array of pixels to copy to the texture
@@ -423,18 +423,18 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Update a part of the texture from an array of pixels
     ///
-    /// The size of the pixel array must match the \a `size` argument,
+    /// The size of the pixel array must match the `size` argument,
     /// and it must contain 32-bits RGBA pixels.
     ///
     /// No additional check is performed on the size of the pixel
     /// array or the bounds of the area to update. Passing invalid
     /// arguments will lead to an undefined behavior.
     ///
-    /// This function does nothing if \a `pixels` is null or if the
+    /// This function does nothing if `pixels` is null or if the
     /// texture was not previously created.
     ///
     /// \param pixels Array of pixels to copy to the texture
-    /// \param size   Width and height of the pixel region contained in \a `pixels`
+    /// \param size   Width and height of the pixel region contained in `pixels`
     /// \param dest   Coordinates of the destination position
     ///
     ////////////////////////////////////////////////////////////
@@ -684,7 +684,7 @@ public:
     /// // draw OpenGL stuff that use no texture...
     /// \endcode
     ///
-    /// The \a `coordinateType` argument controls how texture
+    /// The `coordinateType` argument controls how texture
     /// coordinates will be interpreted. If Normalized (the default), they
     /// must be in range [0 .. 1], which is the default way of handling
     /// texture coordinates with OpenGL. If Pixels, they must be given

include/SFML/Graphics/Transform.hpp

@@ -135,7 +135,7 @@ public:
     /// \brief Combine the current transform with another one
     ///
     /// The result is a transform that is equivalent to applying
-    /// \a `transform` followed by `*this`. Mathematically, it is
+    /// `transform` followed by `*this`. Mathematically, it is
     /// equivalent to a matrix multiplication `(*this) * transform`.
     ///
     /// These two statements are equivalent:

include/SFML/Graphics/VertexArray.hpp

@@ -79,7 +79,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Get a read-write access to a vertex by its index
     ///
-    /// This function doesn't check \a `index`, it must be in range
+    /// This function doesn't check `index`, it must be in range
     /// [0, `getVertexCount()` - 1]. The behavior is undefined
     /// otherwise.
     ///
@@ -95,7 +95,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Get a read-only access to a vertex by its index
     ///
-    /// This function doesn't check \a `index`, it must be in range
+    /// This function doesn't check `index`, it must be in range
     /// [0, `getVertexCount()` - 1]. The behavior is undefined
     /// otherwise.
     ///
@@ -122,10 +122,10 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Resize the vertex array
     ///
-    /// If \a `vertexCount` is greater than the current size, the previous
+    /// If `vertexCount` is greater than the current size, the previous
     /// vertices are kept and new (default-constructed) vertices are
     /// added.
-    /// If \a `vertexCount` is less than the current size, existing vertices
+    /// If `vertexCount` is less than the current size, existing vertices
     /// are removed from the array.
     ///
     /// \param vertexCount New size of the array (number of vertices)

include/SFML/Graphics/VertexBuffer.hpp

@@ -125,11 +125,11 @@ public:
     /// \brief Create the vertex buffer
     ///
     /// Creates the vertex buffer and allocates enough graphics
-    /// memory to hold \a `vertexCount` vertices. Any previously
+    /// memory to hold `vertexCount` vertices. Any previously
     /// allocated memory is freed in the process.
     ///
     /// In order to deallocate previously allocated memory pass 0
-    /// as \a `vertexCount`. Don't forget to recreate with a non-zero
+    /// as `vertexCount`. Don't forget to recreate with a non-zero
     /// value when graphics memory should be allocated again.
     ///
     /// \param vertexCount Number of vertices worth of memory to allocate
@@ -157,7 +157,7 @@ public:
     /// array. Passing invalid arguments will lead to undefined
     /// behavior.
     ///
-    /// This function does nothing if \a `vertices` is null or if the
+    /// This function does nothing if `vertices` is null or if the
     /// buffer was not previously created.
     ///
     /// \param vertices Array of vertices to copy to the buffer
@@ -170,21 +170,21 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Update a part of the buffer from an array of vertices
     ///
-    /// \a `offset` is specified as the number of vertices to skip
+    /// `offset` is specified as the number of vertices to skip
     /// from the beginning of the buffer.
     ///
-    /// If \a `offset` is 0 and \a `vertexCount` is equal to the size of
+    /// If `offset` is 0 and `vertexCount` is equal to the size of
     /// the currently created buffer, its whole contents are replaced.
     ///
-    /// If \a `offset` is 0 and \a `vertexCount` is greater than the
+    /// If `offset` is 0 and `vertexCount` is greater than the
     /// size of the currently created buffer, a new buffer is created
     /// containing the vertex data.
     ///
-    /// If \a `offset` is 0 and \a `vertexCount` is less than the size of
+    /// If `offset` is 0 and `vertexCount` is less than the size of
     /// the currently created buffer, only the corresponding region
     /// is updated.
     ///
-    /// If \a `offset` is not 0 and \a `offset` + \a `vertexCount` is greater
+    /// If `offset` is not 0 and `offset` + `vertexCount` is greater
     /// than the size of the currently created buffer, the update fails.
     ///
     /// No additional check is performed on the size of the vertex

include/SFML/Network/Ftp.hpp

@@ -356,7 +356,7 @@ public:
     ///
     /// This function retrieves the sub-directories and files
     /// contained in the given directory. It is not recursive.
-    /// The \a `directory` parameter is relative to the current
+    /// The `directory` parameter is relative to the current
     /// working directory.
     ///
     /// \param directory Directory to list
@@ -514,7 +514,7 @@ public:
     /// functions in the `sf::Ftp` class, this method can be used
     /// to send any FTP command to the server. If the command
     /// requires one or more parameters, they can be specified
-    /// in \a `parameter`. If the server returns information, you
+    /// in `parameter`. If the server returns information, you
     /// can extract it from the response using `Response::getMessage()`.
     ///
     /// \param command   Command to send

include/SFML/Network/Http.hpp

@@ -236,7 +236,7 @@ public:
         ////////////////////////////////////////////////////////////
         /// \brief Get the value of a field
         ///
-        /// If the field \a `field` is not found in the response header,
+        /// If the field `field` is not found in the response header,
         /// the empty string is returned. This function uses
         /// case-insensitive comparisons.
         ///

include/SFML/Network/IpAddress.hpp

@@ -207,7 +207,7 @@ private:
 /// \param left  Left operand (a IP address)
 /// \param right Right operand (a IP address)
 ///
-/// \return `true` if \a `left` is lesser than \a `right`
+/// \return `true` if `left` is lesser than `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] SFML_NETWORK_API bool operator<(IpAddress left, IpAddress right);
@@ -218,7 +218,7 @@ private:
 /// \param left  Left operand (a IP address)
 /// \param right Right operand (a IP address)
 ///
-/// \return `true` if \a `left` is greater than \a `right`
+/// \return `true` if `left` is greater than `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] SFML_NETWORK_API bool operator>(IpAddress left, IpAddress right);
@@ -240,7 +240,7 @@ private:
 /// \param left  Left operand (a IP address)
 /// \param right Right operand (a IP address)
 ///
-/// \return `true` if \a `left` is greater or equal than \a `right`
+/// \return `true` if `left` is greater or equal than `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] SFML_NETWORK_API bool operator>=(IpAddress left, IpAddress right);

include/SFML/Network/UdpSocket.hpp

@@ -116,7 +116,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Send raw data to a remote peer
     ///
-    /// Make sure that \a `size` is not greater than
+    /// Make sure that `size` is not greater than
     /// `UdpSocket::MaxDatagramSize`, otherwise this function will
     /// fail and no data will be sent.
     ///

include/SFML/System/Angle.hpp

@@ -325,7 +325,7 @@ constexpr Angle& operator-=(Angle& left, Angle right);
 /// \param left  Left operand (an angle)
 /// \param right Right operand (a number)
 ///
-/// \return \a `left` multiplied by \a `right`
+/// \return `left` multiplied by `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] constexpr Angle operator*(Angle left, float right);
@@ -337,7 +337,7 @@ constexpr Angle& operator-=(Angle& left, Angle right);
 /// \param left  Left operand (a number)
 /// \param right Right operand (an angle)
 ///
-/// \return \a `left` multiplied by \a `right`
+/// \return `left` multiplied by `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] constexpr Angle operator*(float left, Angle right);
@@ -349,7 +349,7 @@ constexpr Angle& operator-=(Angle& left, Angle right);
 /// \param left  Left operand (an angle)
 /// \param right Right operand (a number)
 ///
-/// \return \a `left` multiplied by \a `right`
+/// \return `left` multiplied by `right`
 ///
 ////////////////////////////////////////////////////////////
 constexpr Angle& operator*=(Angle& left, float right);
@@ -361,7 +361,7 @@ constexpr Angle& operator*=(Angle& left, float right);
 /// \param left  Left operand (an angle)
 /// \param right Right operand (a number)
 ///
-/// \return \a `left` divided by \a `right`
+/// \return `left` divided by `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] constexpr Angle operator/(Angle left, float right);
@@ -373,7 +373,7 @@ constexpr Angle& operator*=(Angle& left, float right);
 /// \param left  Left operand (an angle)
 /// \param right Right operand (a number)
 ///
-/// \return \a `left` divided by \a `right`
+/// \return `left` divided by `right`
 ///
 ////////////////////////////////////////////////////////////
 constexpr Angle& operator/=(Angle& left, float right);
@@ -385,7 +385,7 @@ constexpr Angle& operator/=(Angle& left, float right);
 /// \param left  Left operand (an angle)
 /// \param right Right operand (an angle)
 ///
-/// \return \a `left` divided by \a `right`
+/// \return `left` divided by `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] constexpr float operator/(Angle left, Angle right);
@@ -405,7 +405,7 @@ constexpr Angle& operator/=(Angle& left, float right);
 /// \param left  Left operand (an angle)
 /// \param right Right operand (an angle)
 ///
-/// \return \a `left` modulo \a `right`
+/// \return `left` modulo `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] constexpr Angle operator%(Angle left, Angle right);
@@ -417,7 +417,7 @@ constexpr Angle& operator/=(Angle& left, float right);
 /// \param left  Left operand (an angle)
 /// \param right Right operand (an angle)
 ///
-/// \return \a `left` modulo \a `right`
+/// \return `left` modulo `right`
 ///
 ////////////////////////////////////////////////////////////
 constexpr Angle& operator%=(Angle& left, Angle right);

include/SFML/System/String.hpp

@@ -284,7 +284,7 @@ public:
     /// \brief Convert the Unicode string to an ANSI string
     ///
     /// The UTF-32 string is converted to an ANSI string in
-    /// the encoding defined by \a `locale`.
+    /// the encoding defined by `locale`.
     /// Characters that do not fit in the target encoding are
     /// discarded from the returned string.
     ///
@@ -357,11 +357,11 @@ public:
     /// \brief Overload of `operator[]` to access a character by its position
     ///
     /// This function provides read-only access to characters.
-    /// Note: the behavior is undefined if \a `index` is out of range.
+    /// Note: the behavior is undefined if `index` is out of range.
     ///
     /// \param index Index of the character to get
     ///
-    /// \return Character at position \a `index`
+    /// \return Character at position `index`
     ///
     ////////////////////////////////////////////////////////////
     [[nodiscard]] char32_t operator[](std::size_t index) const;
@@ -370,11 +370,11 @@ public:
     /// \brief Overload of `operator[]` to access a character by its position
     ///
     /// This function provides read and write access to characters.
-    /// Note: the behavior is undefined if \a `index` is out of range.
+    /// Note: the behavior is undefined if `index` is out of range.
     ///
     /// \param index Index of the character to get
     ///
-    /// \return Reference to the character at position \a `index`
+    /// \return Reference to the character at position `index`
     ///
     ////////////////////////////////////////////////////////////
     [[nodiscard]] char32_t& operator[](std::size_t index);
@@ -412,8 +412,8 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Erase one or more characters from the string
     ///
-    /// This function removes a sequence of \a `count` characters
+    /// This function removes a sequence of `count` characters
-    /// starting from \a `position`.
+    /// starting from `position`.
     ///
     /// \param position Position of the first character to erase
     /// \param count    Number of characters to erase
@@ -424,8 +424,8 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Insert one or more characters into the string
     ///
-    /// This function inserts the characters of \a `str`
+    /// This function inserts the characters of `str`
-    /// into the string, starting from \a `position`.
+    /// into the string, starting from `position`.
     ///
     /// \param position Position of insertion
     /// \param str      Characters to insert
@@ -436,13 +436,13 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Find a sequence of one or more characters in the string
     ///
-    /// This function searches for the characters of \a `str`
+    /// This function searches for the characters of `str`
-    /// in the string, starting from \a `start`.
+    /// in the string, starting from `start`.
     ///
     /// \param str   Characters to find
     /// \param start Where to begin searching
     ///
-    /// \return Position of \a `str` in the string, or `String::InvalidPos` if not found
+    /// \return Position of `str` in the string, or `String::InvalidPos` if not found
     ///
     ////////////////////////////////////////////////////////////
     [[nodiscard]] std::size_t find(const String& str, std::size_t start = 0) const;
@@ -450,8 +450,8 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Replace a substring with another string
     ///
-    /// This function replaces the substring that starts at index \a `position`
+    /// This function replaces the substring that starts at index `position`
-    /// and spans \a `length` characters with the string \a `replaceWith`.
+    /// and spans `length` characters with the string `replaceWith`.
     ///
     /// \param position    Index of the first character to be replaced
     /// \param length      Number of characters to replace. You can pass InvalidPos to
@@ -464,11 +464,11 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Replace all occurrences of a substring with a replacement string
     ///
-    /// This function replaces all occurrences of \a `searchFor` in this string
+    /// This function replaces all occurrences of `searchFor` in this string
-    /// with the string \a `replaceWith`.
+    /// with the string `replaceWith`.
     ///
     /// \param searchFor   The value being searched for
-    /// \param replaceWith The value that replaces found \a `searchFor` values
+    /// \param replaceWith The value that replaces found `searchFor` values
     ///
     ////////////////////////////////////////////////////////////
     void replace(const String& searchFor, const String& replaceWith);
@@ -476,8 +476,8 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Return a part of the string
     ///
-    /// This function returns the substring that starts at index \a `position`
+    /// This function returns the substring that starts at index `position`
-    /// and spans \a `length` characters.
+    /// and spans `length` characters.
     ///
     /// \param position Index of the first character
     /// \param length   Number of characters to include in the substring (if
@@ -592,7 +592,7 @@ private:
 /// \param left  Left operand (a string)
 /// \param right Right operand (a string)
 ///
-/// \return `true` if \a `left` is lexicographically before \a `right`
+/// \return `true` if `left` is lexicographically before `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] SFML_SYSTEM_API bool operator<(const String& left, const String& right);
@@ -604,7 +604,7 @@ private:
 /// \param left  Left operand (a string)
 /// \param right Right operand (a string)
 ///
-/// \return `true` if \a `left` is lexicographically after \a `right`
+/// \return `true` if `left` is lexicographically after `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] SFML_SYSTEM_API bool operator>(const String& left, const String& right);
@@ -616,7 +616,7 @@ private:
 /// \param left  Left operand (a string)
 /// \param right Right operand (a string)
 ///
-/// \return `true` if \a `left` is lexicographically before or equivalent to \a `right`
+/// \return `true` if `left` is lexicographically before or equivalent to `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] SFML_SYSTEM_API bool operator<=(const String& left, const String& right);
@@ -628,7 +628,7 @@ private:
 /// \param left  Left operand (a string)
 /// \param right Right operand (a string)
 ///
-/// \return `true` if \a `left` is lexicographically after or equivalent to \a `right`
+/// \return `true` if `left` is lexicographically after or equivalent to `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] SFML_SYSTEM_API bool operator>=(const String& left, const String& right);

include/SFML/System/Time.hpp

@@ -186,7 +186,7 @@ private:
 /// \param left  Left operand (a time)
 /// \param right Right operand (a time)
 ///
-/// \return `true` if \a `left` is lesser than \a `right`
+/// \return `true` if `left` is lesser than `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] constexpr bool operator<(Time left, Time right);
@@ -198,7 +198,7 @@ private:
 /// \param left  Left operand (a time)
 /// \param right Right operand (a time)
 ///
-/// \return `true` if \a `left` is greater than \a `right`
+/// \return `true` if `left` is greater than `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] constexpr bool operator>(Time left, Time right);
@@ -210,7 +210,7 @@ private:
 /// \param left  Left operand (a time)
 /// \param right Right operand (a time)
 ///
-/// \return `true` if \a `left` is lesser or equal than \a `right`
+/// \return `true` if `left` is lesser or equal than `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] constexpr bool operator<=(Time left, Time right);
@@ -222,7 +222,7 @@ private:
 /// \param left  Left operand (a time)
 /// \param right Right operand (a time)
 ///
-/// \return `true` if \a `left` is greater or equal than \a `right`
+/// \return `true` if `left` is greater or equal than `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] constexpr bool operator>=(Time left, Time right);
@@ -293,7 +293,7 @@ constexpr Time& operator-=(Time& left, Time right);
 /// \param left  Left operand (a time)
 /// \param right Right operand (a number)
 ///
-/// \return \a `left` multiplied by \a `right`
+/// \return `left` multiplied by `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] constexpr Time operator*(Time left, float right);
@@ -305,7 +305,7 @@ constexpr Time& operator-=(Time& left, Time right);
 /// \param left  Left operand (a time)
 /// \param right Right operand (a number)
 ///
-/// \return \a `left` multiplied by \a `right`
+/// \return `left` multiplied by `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] constexpr Time operator*(Time left, std::int64_t right);
@@ -317,7 +317,7 @@ constexpr Time& operator-=(Time& left, Time right);
 /// \param left  Left operand (a number)
 /// \param right Right operand (a time)
 ///
-/// \return \a `left` multiplied by \a `right`
+/// \return `left` multiplied by `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] constexpr Time operator*(float left, Time right);
@@ -329,7 +329,7 @@ constexpr Time& operator-=(Time& left, Time right);
 /// \param left  Left operand (a number)
 /// \param right Right operand (a time)
 ///
-/// \return \a `left` multiplied by \a `right`
+/// \return `left` multiplied by `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] constexpr Time operator*(std::int64_t left, Time right);
@@ -341,7 +341,7 @@ constexpr Time& operator-=(Time& left, Time right);
 /// \param left  Left operand (a time)
 /// \param right Right operand (a number)
 ///
-/// \return \a `left` multiplied by \a `right`
+/// \return `left` multiplied by `right`
 ///
 ////////////////////////////////////////////////////////////
 constexpr Time& operator*=(Time& left, float right);
@@ -353,7 +353,7 @@ constexpr Time& operator*=(Time& left, float right);
 /// \param left  Left operand (a time)
 /// \param right Right operand (a number)
 ///
-/// \return \a `left` multiplied by \a `right`
+/// \return `left` multiplied by `right`
 ///
 ////////////////////////////////////////////////////////////
 constexpr Time& operator*=(Time& left, std::int64_t right);
@@ -365,7 +365,7 @@ constexpr Time& operator*=(Time& left, std::int64_t right);
 /// \param left  Left operand (a time)
 /// \param right Right operand (a number)
 ///
-/// \return \a `left` divided by \a `right`
+/// \return `left` divided by `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] constexpr Time operator/(Time left, float right);
@@ -377,7 +377,7 @@ constexpr Time& operator*=(Time& left, std::int64_t right);
 /// \param left  Left operand (a time)
 /// \param right Right operand (a number)
 ///
-/// \return \a `left` divided by \a `right`
+/// \return `left` divided by `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] constexpr Time operator/(Time left, std::int64_t right);
@@ -389,7 +389,7 @@ constexpr Time& operator*=(Time& left, std::int64_t right);
 /// \param left  Left operand (a time)
 /// \param right Right operand (a number)
 ///
-/// \return \a `left` divided by \a `right`
+/// \return `left` divided by `right`
 ///
 ////////////////////////////////////////////////////////////
 constexpr Time& operator/=(Time& left, float right);
@@ -401,7 +401,7 @@ constexpr Time& operator/=(Time& left, float right);
 /// \param left  Left operand (a time)
 /// \param right Right operand (a number)
 ///
-/// \return \a `left` divided by \a `right`
+/// \return `left` divided by `right`
 ///
 ////////////////////////////////////////////////////////////
 constexpr Time& operator/=(Time& left, std::int64_t right);
@@ -413,7 +413,7 @@ constexpr Time& operator/=(Time& left, std::int64_t right);
 /// \param left  Left operand (a time)
 /// \param right Right operand (a time)
 ///
-/// \return \a `left` divided by \a `right`
+/// \return `left` divided by `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] constexpr float operator/(Time left, Time right);
@@ -425,7 +425,7 @@ constexpr Time& operator/=(Time& left, std::int64_t right);
 /// \param left  Left operand (a time)
 /// \param right Right operand (a time)
 ///
-/// \return \a `left` modulo \a `right`
+/// \return `left` modulo `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] constexpr Time operator%(Time left, Time right);
@@ -437,7 +437,7 @@ constexpr Time& operator/=(Time& left, std::int64_t right);
 /// \param left  Left operand (a time)
 /// \param right Right operand (a time)
 ///
-/// \return \a `left` modulo \a `right`
+/// \return `left` modulo `right`
 ///
 ////////////////////////////////////////////////////////////
 constexpr Time& operator%=(Time& left, Time right);

include/SFML/System/Utf.hpp

@@ -123,7 +123,7 @@ public:
     /// \brief Convert an ANSI characters range to UTF-8
     ///
     /// The current global locale will be used by default, unless you
-    /// pass a custom one in the \a `locale` parameter.
+    /// pass a custom one in the `locale` parameter.
     ///
     /// \param begin  Iterator pointing to the beginning of the input sequence
     /// \param end    Iterator pointing to the end of the input sequence
@@ -166,7 +166,7 @@ public:
     /// \brief Convert an UTF-8 characters range to ANSI characters
     ///
     /// The current global locale will be used by default, unless you
-    /// pass a custom one in the \a `locale` parameter.
+    /// pass a custom one in the `locale` parameter.
     ///
     /// \param begin       Iterator pointing to the beginning of the input sequence
     /// \param end         Iterator pointing to the end of the input sequence
@@ -329,7 +329,7 @@ public:
     /// \brief Convert an ANSI characters range to UTF-16
     ///
     /// The current global locale will be used by default, unless you
-    /// pass a custom one in the \a `locale` parameter.
+    /// pass a custom one in the `locale` parameter.
     ///
     /// \param begin  Iterator pointing to the beginning of the input sequence
     /// \param end    Iterator pointing to the end of the input sequence
@@ -372,7 +372,7 @@ public:
     /// \brief Convert an UTF-16 characters range to ANSI characters
     ///
     /// The current global locale will be used by default, unless you
-    /// pass a custom one in the \a `locale` parameter.
+    /// pass a custom one in the `locale` parameter.
     ///
     /// \param begin       Iterator pointing to the beginning of the input sequence
     /// \param end         Iterator pointing to the end of the input sequence
@@ -536,7 +536,7 @@ public:
     /// \brief Convert an ANSI characters range to UTF-32
     ///
     /// The current global locale will be used by default, unless you
-    /// pass a custom one in the \a `locale` parameter.
+    /// pass a custom one in the `locale` parameter.
     ///
     /// \param begin  Iterator pointing to the beginning of the input sequence
     /// \param end    Iterator pointing to the end of the input sequence
@@ -579,7 +579,7 @@ public:
     /// \brief Convert an UTF-32 characters range to ANSI characters
     ///
     /// The current global locale will be used by default, unless you
-    /// pass a custom one in the \a `locale` parameter.
+    /// pass a custom one in the `locale` parameter.
     ///
     /// \param begin       Iterator pointing to the beginning of the input sequence
     /// \param end         Iterator pointing to the end of the input sequence

include/SFML/System/Vector2.hpp

@@ -105,12 +105,12 @@ public:
     [[nodiscard]] SFML_SYSTEM_API Vector2 normalized() const;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Signed angle from `*this` to \a `rhs` <i><b>(floating-point)</b></i>.
+    /// \brief Signed angle from `*this` to `rhs` <i><b>(floating-point)</b></i>.
     ///
     /// \return The smallest angle which rotates `*this` in positive
-    /// or negative direction, until it has the same direction as \a `rhs`.
+    /// or negative direction, until it has the same direction as `rhs`.
     /// The result has a sign and lies in the range [-180, 180) degrees.
-    /// \pre Neither `*this` nor \a `rhs` is a zero vector.
+    /// \pre Neither `*this` nor `rhs` is a zero vector.
     ///
     ////////////////////////////////////////////////////////////
     [[nodiscard]] SFML_SYSTEM_API Angle angleTo(Vector2 rhs) const;
@@ -132,16 +132,16 @@ public:
     /// Returns a vector with same length but different direction.
     ///
     /// In SFML's default coordinate system with +X right and +Y down,
-    /// this amounts to a clockwise rotation by \a `phi`.
+    /// this amounts to a clockwise rotation by `phi`.
     ///
     ////////////////////////////////////////////////////////////
     [[nodiscard]] SFML_SYSTEM_API Vector2 rotatedBy(Angle phi) const;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Projection of this vector onto \a `axis` <i><b>(floating-point)</b></i>.
+    /// \brief Projection of this vector onto `axis` <i><b>(floating-point)</b></i>.
     ///
     /// \param axis Vector being projected onto. Need not be normalized.
-    /// \pre \a `axis` must not have length zero.
+    /// \pre `axis` must not have length zero.
     ///
     ////////////////////////////////////////////////////////////
     [[nodiscard]] SFML_SYSTEM_API Vector2 projectedOnto(Vector2 axis) const;
@@ -174,7 +174,7 @@ public:
     [[nodiscard]] constexpr T cross(Vector2 rhs) const;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Component-wise multiplication of `*this` and \a `rhs`.
+    /// \brief Component-wise multiplication of `*this` and `rhs`.
     ///
     /// Computes `(lhs.x*rhs.x, lhs.y*rhs.y)`.
     ///
@@ -185,13 +185,13 @@ public:
     [[nodiscard]] constexpr Vector2 componentWiseMul(Vector2 rhs) const;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Component-wise division of `*this` and \a `rhs`.
+    /// \brief Component-wise division of `*this` and `rhs`.
     ///
     /// Computes `(lhs.x/rhs.x, lhs.y/rhs.y)`.
     ///
     /// Scaling is the most common use case for component-wise multiplication/division.
     ///
-    /// \pre Neither component of \a `rhs` is zero.
+    /// \pre Neither component of `rhs` is zero.
     ///
     ////////////////////////////////////////////////////////////
     [[nodiscard]] constexpr Vector2 componentWiseDiv(Vector2 rhs) const;
@@ -226,12 +226,12 @@ template <typename T>
 /// \brief Overload of binary `operator+=`
 ///
 /// This operator performs a member-wise addition of both vectors,
-/// and assigns the result to \a `left`.
+/// and assigns the result to `left`.
 ///
 /// \param left  Left operand (a vector)
 /// \param right Right operand (a vector)
 ///
-/// \return Reference to \a `left`
+/// \return Reference to `left`
 ///
 ////////////////////////////////////////////////////////////
 template <typename T>
@@ -242,7 +242,7 @@ constexpr Vector2<T>& operator+=(Vector2<T>& left, Vector2<T> right);
 /// \brief Overload of binary `operator-=`
 ///
 /// This operator performs a member-wise subtraction of both vectors,
-/// and assigns the result to \a `left`.
+/// and assigns the result to `left`.
 ///
 /// \param left  Left operand (a vector)
 /// \param right Right operand (a vector)
@@ -286,7 +286,7 @@ template <typename T>
 /// \param left  Left operand (a vector)
 /// \param right Right operand (a scalar value)
 ///
-/// \return Member-wise multiplication by \a `right`
+/// \return Member-wise multiplication by `right`
 ///
 ////////////////////////////////////////////////////////////
 template <typename T>
@@ -299,7 +299,7 @@ template <typename T>
 /// \param left  Left operand (a scalar value)
 /// \param right Right operand (a vector)
 ///
-/// \return Member-wise multiplication by \a `left`
+/// \return Member-wise multiplication by `left`
 ///
 ////////////////////////////////////////////////////////////
 template <typename T>
@@ -309,13 +309,13 @@ template <typename T>
 /// \relates Vector2
 /// \brief Overload of binary `operator*=`
 ///
-/// This operator performs a member-wise multiplication by \a `right`,
+/// This operator performs a member-wise multiplication by `right`,
-/// and assigns the result to \a `left`.
+/// and assigns the result to `left`.
 ///
 /// \param left  Left operand (a vector)
 /// \param right Right operand (a scalar value)
 ///
-/// \return Reference to \a `left`
+/// \return Reference to `left`
 ///
 ////////////////////////////////////////////////////////////
 template <typename T>
@@ -328,7 +328,7 @@ constexpr Vector2<T>& operator*=(Vector2<T>& left, T right);
 /// \param left  Left operand (a vector)
 /// \param right Right operand (a scalar value)
 ///
-/// \return Member-wise division by \a `right`
+/// \return Member-wise division by `right`
 ///
 ////////////////////////////////////////////////////////////
 template <typename T>
@@ -338,13 +338,13 @@ template <typename T>
 /// \relates Vector2
 /// \brief Overload of binary `operator/=`
 ///
-/// This operator performs a member-wise division by \a `right`,
+/// This operator performs a member-wise division by `right`,
-/// and assigns the result to \a `left`.
+/// and assigns the result to `left`.
 ///
 /// \param left  Left operand (a vector)
 /// \param right Right operand (a scalar value)
 ///
-/// \return Reference to \a `left`
+/// \return Reference to `left`
 ///
 ////////////////////////////////////////////////////////////
 template <typename T>
@@ -359,7 +359,7 @@ constexpr Vector2<T>& operator/=(Vector2<T>& left, T right);
 /// \param left  Left operand (a vector)
 /// \param right Right operand (a vector)
 ///
-/// \return `true` if \a `left` is equal to \a `right`
+/// \return `true` if `left` is equal to `right`
 ///
 ////////////////////////////////////////////////////////////
 template <typename T>
@@ -374,7 +374,7 @@ template <typename T>
 /// \param left  Left operand (a vector)
 /// \param right Right operand (a vector)
 ///
-/// \return `true` if \a `left` is not equal to \a `right`
+/// \return `true` if `left` is not equal to `right`
 ///
 ////////////////////////////////////////////////////////////
 template <typename T>

include/SFML/System/Vector3.hpp

@@ -100,7 +100,7 @@ public:
     [[nodiscard]] constexpr Vector3 cross(const Vector3& rhs) const;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Component-wise multiplication of `*this` and \a `rhs`.
+    /// \brief Component-wise multiplication of `*this` and `rhs`.
     ///
     /// Computes `(lhs.x*rhs.x, lhs.y*rhs.y, lhs.z*rhs.z)`.
     ///
@@ -111,13 +111,13 @@ public:
     [[nodiscard]] constexpr Vector3 componentWiseMul(const Vector3& rhs) const;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Component-wise division of `*this` and \a `rhs`.
+    /// \brief Component-wise division of `*this` and `rhs`.
     ///
     /// Computes `(lhs.x/rhs.x, lhs.y/rhs.y, lhs.z/rhs.z)`.
     ///
     /// Scaling is the most common use case for component-wise multiplication/division.
     ///
-    /// \pre Neither component of \a `rhs` is zero.
+    /// \pre Neither component of `rhs` is zero.
     ///
     ////////////////////////////////////////////////////////////
     [[nodiscard]] constexpr Vector3 componentWiseDiv(const Vector3& rhs) const;
@@ -147,12 +147,12 @@ template <typename T>
 /// \brief Overload of binary `operator+=`
 ///
 /// This operator performs a member-wise addition of both vectors,
-/// and assigns the result to \a `left`.
+/// and assigns the result to `left`.
 ///
 /// \param left  Left operand (a vector)
 /// \param right Right operand (a vector)
 ///
-/// \return Reference to \a `left`
+/// \return Reference to `left`
 ///
 ////////////////////////////////////////////////////////////
 template <typename T>
@@ -163,12 +163,12 @@ constexpr Vector3<T>& operator+=(Vector3<T>& left, const Vector3<T>& right);
 /// \brief Overload of binary `operator-=`
 ///
 /// This operator performs a member-wise subtraction of both vectors,
-/// and assigns the result to \a `left`.
+/// and assigns the result to `left`.
 ///
 /// \param left  Left operand (a vector)
 /// \param right Right operand (a vector)
 ///
-/// \return Reference to \a `left`
+/// \return Reference to `left`
 ///
 ////////////////////////////////////////////////////////////
 template <typename T>
@@ -207,7 +207,7 @@ template <typename T>
 /// \param left  Left operand (a vector)
 /// \param right Right operand (a scalar value)
 ///
-/// \return Member-wise multiplication by \a `right`
+/// \return Member-wise multiplication by `right`
 ///
 ////////////////////////////////////////////////////////////
 template <typename T>
@@ -220,7 +220,7 @@ template <typename T>
 /// \param left  Left operand (a scalar value)
 /// \param right Right operand (a vector)
 ///
-/// \return Member-wise multiplication by \a `left`
+/// \return Member-wise multiplication by `left`
 ///
 ////////////////////////////////////////////////////////////
 template <typename T>
@@ -230,13 +230,13 @@ template <typename T>
 /// \relates Vector3
 /// \brief Overload of binary `operator*=`
 ///
-/// This operator performs a member-wise multiplication by \a `right`,
+/// This operator performs a member-wise multiplication by `right`,
-/// and assigns the result to \a `left`.
+/// and assigns the result to `left`.
 ///
 /// \param left  Left operand (a vector)
 /// \param right Right operand (a scalar value)
 ///
-/// \return Reference to \a `left`
+/// \return Reference to `left`
 ///
 ////////////////////////////////////////////////////////////
 template <typename T>
@@ -249,7 +249,7 @@ constexpr Vector3<T>& operator*=(Vector3<T>& left, T right);
 /// \param left  Left operand (a vector)
 /// \param right Right operand (a scalar value)
 ///
-/// \return Member-wise division by \a `right`
+/// \return Member-wise division by `right`
 ///
 ////////////////////////////////////////////////////////////
 template <typename T>
@@ -259,13 +259,13 @@ template <typename T>
 /// \relates Vector3
 /// \brief Overload of binary `operator/=`
 ///
-/// This operator performs a member-wise division by \a `right`,
+/// This operator performs a member-wise division by `right`,
-/// and assigns the result to \a `left`.
+/// and assigns the result to `left`.
 ///
 /// \param left  Left operand (a vector)
 /// \param right Right operand (a scalar value)
 ///
-/// \return Reference to \a `left`
+/// \return Reference to `left`
 ///
 ////////////////////////////////////////////////////////////
 template <typename T>
@@ -280,7 +280,7 @@ constexpr Vector3<T>& operator/=(Vector3<T>& left, T right);
 /// \param left  Left operand (a vector)
 /// \param right Right operand (a vector)
 ///
-/// \return `true` if \a `left` is equal to \a `right`
+/// \return `true` if `left` is equal to `right`
 ///
 ////////////////////////////////////////////////////////////
 template <typename T>
@@ -295,7 +295,7 @@ template <typename T>
 /// \param left  Left operand (a vector)
 /// \param right Right operand (a vector)
 ///
-/// \return `true` if \a `left` is not equal to \a `right`
+/// \return `true` if `left` is not equal to `right`
 ///
 ////////////////////////////////////////////////////////////
 template <typename T>

include/SFML/Window/Cursor.hpp

@@ -147,10 +147,10 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Construct a cursor with the provided image
     ///
-    /// \a `pixels` must be an array of \a `size` pixels in
+    /// `pixels` must be an array of `size` pixels in
     /// 32-bit RGBA format. If not, this will cause undefined behavior.
     ///
-    /// If \a `pixels` is `nullptr` or either of \a `size`'s
+    /// If `pixels` is `nullptr` or either of `size`'s
     /// properties are 0, the current cursor is left unchanged
     /// and the function will return `false`.
     ///
@@ -196,10 +196,10 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Create a cursor with the provided image
     ///
-    /// \a `pixels` must be an array of \a `size` pixels
+    /// `pixels` must be an array of `size` pixels
     /// in 32-bit RGBA format. If not, this will cause undefined behavior.
     ///
-    /// If \a `pixels` is `nullptr` or either of \a `size`'s
+    /// If `pixels` is `nullptr` or either of `size`'s
     /// properties are 0, the current cursor is left unchanged
     /// and the function will return `false`.
     ///

include/SFML/Window/VideoMode.hpp

@@ -134,7 +134,7 @@ public:
 /// \param left  Left operand (a video mode)
 /// \param right Right operand (a video mode)
 ///
-/// \return `true` if \a `left` is lesser than \a `right`
+/// \return `true` if `left` is lesser than `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] SFML_WINDOW_API bool operator<(const VideoMode& left, const VideoMode& right);
@@ -146,7 +146,7 @@ public:
 /// \param left  Left operand (a video mode)
 /// \param right Right operand (a video mode)
 ///
-/// \return `true` if \a `left` is greater than \a `right`
+/// \return `true` if `left` is greater than `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] SFML_WINDOW_API bool operator>(const VideoMode& left, const VideoMode& right);
@@ -158,7 +158,7 @@ public:
 /// \param left  Left operand (a video mode)
 /// \param right Right operand (a video mode)
 ///
-/// \return `true` if \a `left` is lesser or equal than \a `right`
+/// \return `true` if `left` is lesser or equal than `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] SFML_WINDOW_API bool operator<=(const VideoMode& left, const VideoMode& right);
@@ -170,7 +170,7 @@ public:
 /// \param left  Left operand (a video mode)
 /// \param right Right operand (a video mode)
 ///
-/// \return `true` if \a `left` is greater or equal than \a `right`
+/// \return `true` if `left` is greater or equal than `right`
 ///
 ////////////////////////////////////////////////////////////
 [[nodiscard]] SFML_WINDOW_API bool operator>=(const VideoMode& left, const VideoMode& right);

include/SFML/Window/Vulkan.hpp

@@ -69,7 +69,7 @@ namespace Vulkan
 /// the Vulkan features. If it returns `false`, then
 /// any attempt to use Vulkan will fail.
 ///
-/// If only compute is required, set \a `requireGraphics`
+/// If only compute is required, set `requireGraphics`
 /// to `false` to skip checking for the extensions necessary
 /// for graphics rendering.
 ///

include/SFML/Window/Window.hpp

@@ -68,10 +68,10 @@ public:
     /// \brief Construct a new window
     ///
     /// This constructor creates the window with the size and pixel
-    /// depth defined in \a `mode`. An optional style can be passed to
+    /// depth defined in `mode`. An optional style can be passed to
     /// customize the look and behavior of the window (borders,
     /// title bar, resizable, closable, ...). An optional state can
-    /// be provided. If \a `state` is `State::Fullscreen`, then \a `mode`
+    /// be provided. If `state` is `State::Fullscreen`, then `mode`
     /// must be a valid video mode.
     ///
     /// The last parameter is an optional structure specifying
@@ -95,8 +95,8 @@ public:
     /// \brief Construct a new window
     ///
     /// This constructor creates the window with the size and pixel
-    /// depth defined in \a `mode`. If \a `state` is `State::Fullscreen`,
+    /// depth defined in `mode`. If `state` is `State::Fullscreen`,
-    /// then \a `mode` must be a valid video mode.
+    /// then `mode` must be a valid video mode.
     ///
     /// The last parameter is an optional structure specifying
     /// advanced OpenGL context settings such as anti-aliasing,
@@ -162,7 +162,7 @@ public:
     /// \brief Create (or recreate) the window
     ///
     /// If the window was already created, it closes it first.
-    /// If \a `state` is `State::Fullscreen`, then \a `mode` must be
+    /// If `state` is `State::Fullscreen`, then `mode` must be
     /// a valid video mode.
     ///
     /// \param mode     Video mode to use (defines the width, height and depth of the rendering area of the window)
@@ -177,7 +177,7 @@ public:
     /// \brief Create (or recreate) the window
     ///
     /// If the window was already created, it closes it first.
-    /// If \a `state` is `State::Fullscreen`, then \a `mode` must be
+    /// If `state` is `State::Fullscreen`, then `mode` must be
     /// a valid video mode.
     ///
     /// The last parameter is a structure specifying advanced OpenGL
@@ -196,7 +196,7 @@ public:
     /// \brief Create (or recreate) the window
     ///
     /// If the window was already created, it closes it first.
-    /// If \a `state` is `State::Fullscreen`, then \a `mode` must be
+    /// If `state` is `State::Fullscreen`, then `mode` must be
     /// a valid video mode.
     ///
     /// \param mode     Video mode to use (defines the width, height and depth of the rendering area of the window)
@@ -210,7 +210,7 @@ public:
     /// \brief Create (or recreate) the window
     ///
     /// If the window was already created, it closes it first.
-    /// If \a `state` is `State::Fullscreen`, then \a `mode` must be
+    /// If `state` is `State::Fullscreen`, then `mode` must be
     /// a valid video mode.
     ///
     /// The last parameter is a structure specifying advanced OpenGL

include/SFML/Window/WindowBase.hpp

@@ -75,10 +75,10 @@ public:
     /// \brief Construct a new window
     ///
     /// This constructor creates the window with the size and pixel
-    /// depth defined in \a `mode`. An optional style can be passed to
+    /// depth defined in `mode`. An optional style can be passed to
     /// customize the look and behavior of the window (borders,
     /// title bar, resizable, closable, ...). An optional state can
-    /// be provided. If \a `state` is `State::Fullscreen`, then \a `mode`
+    /// be provided. If `state` is `State::Fullscreen`, then `mode`
     /// must be a valid video mode.
     ///
     /// \param mode  Video mode to use (defines the width, height and depth of the rendering area of the window)
@@ -93,7 +93,7 @@ public:
     /// \brief Construct a new window
     ///
     /// This constructor creates the window with the size and pixel
-    /// depth defined in \a `mode`.
+    /// depth defined in `mode`.
     ///
     /// \param mode  Video mode to use (defines the width, height and depth of the rendering area of the window)
     /// \param title Title of the window
@@ -146,7 +146,7 @@ public:
     /// \brief Create (or recreate) the window
     ///
     /// If the window was already created, it closes it first.
-    /// If \a `state` is `State::Fullscreen`, then \a `mode` must be
+    /// If `state` is `State::Fullscreen`, then `mode` must be
     /// a valid video mode.
     ///
     /// \param mode  Video mode to use (defines the width, height and depth of the rendering area of the window)
@@ -161,7 +161,7 @@ public:
     /// \brief Create (or recreate) the window
     ///
     /// If the window was already created, it closes it first.
-    /// If \a `state` is `State::Fullscreen`, then \a `mode` must be
+    /// If `state` is `State::Fullscreen`, then `mode` must be
     /// a valid video mode.
     ///
     /// \param mode  Video mode to use (defines the width, height and depth of the rendering area of the window)
@@ -409,7 +409,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Change the window's icon
     ///
-    /// \a `pixels` must be an array of \a `size` pixels
+    /// `pixels` must be an array of `size` pixels
     /// in 32-bits RGBA format.
     ///
     /// The OS default icon is used by default.