mirrors/SFML
1
0
Fork 0
mirror of https://github.com/SFML/SFML.git synced 2024-11-24 20:31:05 +08:00
Code Issues Packages Projects Releases Wiki Activity

Do not combine \a with backticks in doxygen comments

Browse Source 
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.
This commit is contained in:
kimci86 2024-11-08 23:32:20 +01:00 committed by Chris Thrasher
parent 799ca304ce
commit dff83039aa
35 changed files with 205 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/SFML/Audio/Listener.hpp
View File

@ -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).
///

6
include/SFML/Audio/Music.hpp
View File

@ -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

2
include/SFML/Audio/PlaybackDevice.hpp
View File

@ -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

6
include/SFML/Audio/SoundRecorder.hpp
View File

@ -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
///

2
include/SFML/Graphics/BlendMode.hpp
View File

@ -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

2
include/SFML/Graphics/CircleShape.hpp
View File

@ -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]
///

6
include/SFML/Graphics/ConvexShape.hpp
View File

@ -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]
///

12
include/SFML/Graphics/Font.hpp
View File

@ -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;

18
include/SFML/Graphics/Image.hpp
View File

@ -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.
/// If \a `pixels` is `nullptr`, an empty image is created.
/// and have the given `size`. If not, this is an undefined behavior.
/// 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.
/// If \a `pixels` is `nullptr`, an empty image is created.
/// and have the given `size`. If not, this is an undefined behavior.
/// 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 \a `applyAlpha` is set to `true`, alpha blending is
/// If `sourceRect` is empty, the whole image is copied.
/// 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
/// not within the boundaries of the \a `source` parameter, or
/// (i.e. zero-sized width or height), or if `sourceRect` is
/// 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.

2
include/SFML/Graphics/RectangleShape.hpp
View File

@ -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]
///

4
include/SFML/Graphics/RenderTexture.hpp
View File

@ -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.

6
include/SFML/Graphics/RenderWindow.hpp
View File

@ -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`,
/// then \a `mode` must be a valid video mode.
/// depth defined in `mode`. If `state` is `State::Fullscreen`,
/// then `mode` must be a valid video mode.
///
/// The last parameter is an optional structure specifying
/// advanced OpenGL context settings such as anti-aliasing,

2
include/SFML/Graphics/Shader.hpp
View File

@ -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

8
include/SFML/Graphics/Shape.hpp
View File

@ -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.
/// If \a `resetRect` is `true`, the `TextureRect` property of
/// `texture` can be a null pointer to disable texturing.
/// 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]
///

4
include/SFML/Graphics/Sprite.hpp
View File

@ -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.
///

8
include/SFML/Graphics/Text.hpp
View File

@ -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

44
include/SFML/Graphics/Texture.hpp
View File

@ -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

2
include/SFML/Graphics/Transform.hpp
View File

@ -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:

8
include/SFML/Graphics/VertexArray.hpp
View File

@ -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)

16
include/SFML/Graphics/VertexBuffer.hpp
View File

@ -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

4
include/SFML/Network/Ftp.hpp
View File

@ -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

2
include/SFML/Network/Http.hpp
View File

@ -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.
///

6
include/SFML/Network/IpAddress.hpp
View File

@ -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);

2
include/SFML/Network/UdpSocket.hpp
View File

@ -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.
///

16
include/SFML/System/Angle.hpp
View File

@ -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);

46
include/SFML/System/String.hpp
View File

@ -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
/// starting from \a `position`.
/// This function removes a sequence of `count` characters
/// 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`
/// into the string, starting from \a `position`.
/// This function inserts the characters of `str`
/// 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`
/// in the string, starting from \a `start`.
/// This function searches for the characters of `str`
/// 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`
/// and spans \a `length` characters with the string \a `replaceWith`.
/// This function replaces the substring that starts at index `position`
/// 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
/// with the string \a `replaceWith`.
/// This function replaces all occurrences of `searchFor` in this string
/// 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`
/// and spans \a `length` characters.
/// This function returns the substring that starts at index `position`
/// 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);

34
include/SFML/System/Time.hpp
View File

@ -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);

12
include/SFML/System/Utf.hpp
View File

@ -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

46
include/SFML/System/Vector2.hpp
View File

@ -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`,
/// and assigns the result to \a `left`.
/// This operator performs a member-wise multiplication by `right`,
/// 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`,
/// and assigns the result to \a `left`.
/// This operator performs a member-wise division by `right`,
/// 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>

36
include/SFML/System/Vector3.hpp
View File

@ -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`,
/// and assigns the result to \a `left`.
/// This operator performs a member-wise multiplication by `right`,
/// 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`,
/// and assigns the result to \a `left`.
/// This operator performs a member-wise division by `right`,
/// 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>

8
include/SFML/Window/Cursor.hpp
View File

@ -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`.
///

8
include/SFML/Window/VideoMode.hpp
View File

@ -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);

2
include/SFML/Window/Vulkan.hpp
View File

@ -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.
///

16
include/SFML/Window/Window.hpp
View File

@ -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`,
/// then \a `mode` must be a valid video mode.
/// depth defined in `mode`. If `state` is `State::Fullscreen`,
/// 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

12
include/SFML/Window/WindowBase.hpp
View File

@ -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.