TheCloud/libSDL2pp
1
0
Fork 0
mirror of https://github.com/libSDL2pp/libSDL2pp.git synced 2025-08-03 10:55:57 -04:00
Code Issues Packages Projects Releases Wiki Activity

Multiple documentation fixes

Browse Source
This commit is contained in:
Dmitry Marakasov 2015-01-11 06:25:38 +03:00
parent dfd82ae6bf
commit c753c8ceba
16 changed files with 103 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
SDL2pp/AudioDevice.hh
View File

@ -41,6 +41,9 @@ class AudioSpec;
///
/// \headerfile SDL2pp/AudioDevice.hh
///
/// This class provides access to basic %SDL (not SDL_mixer!)
/// audio functionality.
///
////////////////////////////////////////////////////////////
class AudioDevice {
public:
@ -103,8 +106,8 @@ public:
////////////////////////////////////////////////////////////
/// \brief Create no-op lock
///
/// This may be initialized with real lock later with move
/// assignment operator
/// This may be initialized with real lock later via move
/// assignment
///
////////////////////////////////////////////////////////////
LockHandle();
@ -196,7 +199,7 @@ public:
/// \param iscapture Non-zero to open device for recording
/// (SDL2 doesn't support this yet)
/// \param allowed_changes Flag mask specifying which audio
// format properties may change
/// format properties may change
/// \param spec Desired audio output format (may be changed)
/// \param callback Callback which will feed audio to the device
///
@ -248,9 +251,9 @@ public:
AudioDevice& operator=(const AudioDevice&) = delete;
////////////////////////////////////////////////////////////
/// \brief Get container audio device ID
/// \brief Get managed audio device ID
///
/// \returns Contained audio device ID
/// \returns Managed audio device ID
///
////////////////////////////////////////////////////////////
SDL_AudioDeviceID Get() const;

4
SDL2pp/AudioSpec.hh
View File

@ -103,9 +103,9 @@ public:
AudioSpec& operator=(const AudioSpec& other) = delete;
////////////////////////////////////////////////////////////
/// \brief Get pointer to contained SDL_AudioSpec structure
/// \brief Get pointer to managed SDL_AudioSpec structure
///
/// \returns Pointer to SDL_AudioSpec structure
/// \returns Pointer to managed SDL_AudioSpec structure
///
////////////////////////////////////////////////////////////
const SDL_AudioSpec* Get() const;

6
SDL2pp/ContainerRWops.hh
View File

@ -36,9 +36,9 @@ namespace SDL2pp {
///
/// \headerfile SDL2pp/ContainerRWops.hh
///
/// This class extends functionality of RWops concept onto random
/// This class extends functionality of %RWops concept onto random
/// access STL containers such as std::vector. With ContainerRWops,
/// you may read from / write to a container with SDL functions as
/// you may read from / write to a container with %SDL functions as
/// if it were a plain file.
///
/// Note that this template supports both const and mutable containers.
@ -73,7 +73,7 @@ private:
public:
////////////////////////////////////////////////////////////
/// \brief Construct ContainerRWops for specificed container
/// \brief Construct ContainerRWops for specified container
///
/// \param container Container to use
///

2
SDL2pp/Exception.hh
View File

@ -73,7 +73,7 @@ private:
public:
////////////////////////////////////////////////////////////
/// \brief Construct exception, storing result of SDL_GetError
/// \brief Construct exception, storing result of SDL_GetError()
///
/// \param what User-specified explanatory string
///

12
SDL2pp/Font.hh
View File

@ -46,14 +46,14 @@ class RWops;
////////////////////////////////////////////////////////////
class Font {
private:
TTF_Font* font_; ///< Contained TTF_Font structure
TTF_Font* font_; ///< Managed TTF_Font object
public:
////////////////////////////////////////////////////////////
/// \brief Loads font from .ttf or .fon file
///
/// \param file Pointer File name to load font from
/// \param ptsize Point size (based on 72DPI) to load font as. This basically translates to pixel height
/// \param ptsize %Point size (based on 72DPI) to load font as. This basically translates to pixel height
/// \param index Choose a font face from a file containing multiple font faces. The first face is always index 0
///
/// \throws SDL2pp::Exception
@ -68,7 +68,7 @@ public:
/// \brief Loads font with RWops
///
/// \param rwops RWops to load font from
/// \param ptsize Point size (based on 72DPI) to load font as. This basically translates to pixel height
/// \param ptsize %Point size (based on 72DPI) to load font as. This basically translates to pixel height
/// \param index Choose a font face from a file containing multiple font faces. The first face is always index 0
///
/// \throws SDL2pp::Exception
@ -122,9 +122,9 @@ public:
Font& operator=(const Font&) = delete;
////////////////////////////////////////////////////////////
/// \brief Get pointer to contained TTF_Font structure
/// \brief Get pointer to managed TTF_Font structure
///
/// \returns Pointer to contained TTF_Font structure
/// \returns Pointer to managed TTF_Font structure
///
////////////////////////////////////////////////////////////
TTF_Font* Get() const;
@ -235,7 +235,7 @@ public:
////////////////////////////////////////////////////////////
/// \brief Get the current kerning setting of the loaded font
///
/// \returns False if kerning is disabled. True when disabled.
/// \returns False if kerning is disabled. True when enabled.
/// The default for a newly loaded font is true, enabled
///
/// \see https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf.html#SEC27

26
SDL2pp/RWops.hh
View File

@ -112,14 +112,14 @@ public:
///
/// \headerfile SDL2pp/RWops.hh
///
/// RWops is an SDL2 abstraction of file-like I/O. For most functions
/// %RWops is an SDL2 abstraction of file-like I/O. For most functions
/// that take file name as a parameter, SDL2 has an alternative which
/// take RWops, and through RWops it's functionality is extended from
/// take %RWops, and through %RWops its functionality is extended from
/// just files to arbitrary objects that support file-like operations.
///
/// For example, SDL2 provide 4 builtin types of RWops: File (take
/// file name and work with plain file), FP (take stdio's FILE* and
/// work with it), Mem and ConstMem (take memory chunk and work with
/// For example, SDL2 provide 4 builtin types of %RWops: File (takes
/// file name and works with plain file), FP (takes stdio's FILE* and
/// works with it), Mem and ConstMem (take memory chunk and work with
/// it like a file) and allow one to write custom RWops.
///
/// SDL2pp::RWops support all this in extended C++11 way.
@ -139,12 +139,12 @@ public:
///
/// This class is more complicated than just wrapper over SDL_RWops,
/// but it's needed to both retain compatibility with C SDL2 and to
/// make it possible to write pure C++ RWops classes, in a safe way.
/// make it possible to write pure C++ %RWops classes, in a safe way.
///
////////////////////////////////////////////////////////////
class RWops {
protected:
SDL_RWops* rwops_; ///< Contained SDL_RWops structure
SDL_RWops* rwops_; ///< Managed SDL_RWops object
private:
static Sint64 StdSeekFuncWrapper(SDL_RWops* context, Sint64 offset, int whence);
@ -256,9 +256,13 @@ public:
RWops& operator=(const RWops&) = delete;
////////////////////////////////////////////////////////////
/// \brief Create RWops from custom RWops class
/// \brief Create RWops from CustomRWops derived class
///
/// \param custom_rwops Custom RWops functions
/// \param custom_rwops Custom %RWops functions
///
/// \throws SDL2pp::Exception
///
/// \todo make this take arguments for C constructor
///
////////////////////////////////////////////////////////////
template<class C>
@ -288,9 +292,9 @@ public:
~RWops();
////////////////////////////////////////////////////////////
/// \brief Get pointer to contained SDL_RWops structure
/// \brief Get pointer to managed SDL_RWops structure
///
/// \returns Pointer to contained SDL_RWops structure
/// \returns Pointer to managed SDL_RWops structure
///
////////////////////////////////////////////////////////////
SDL_RWops* Get() const;

8
SDL2pp/Rect.hh
View File

@ -109,7 +109,7 @@ public:
static Rect FromCenter(const Point& center, const Point& size);
////////////////////////////////////////////////////////////
/// \brief Construct the rect from given center coordinates, width and height
/// \brief Construct the rect from given corners coordinates
///
/// \param x1 X coordinate of the top left rectangle corner
/// \param y1 Y coordinate of the top left rectangle corner
@ -120,7 +120,7 @@ public:
static Rect FromCorners(int x1, int y1, int x2, int y2);
////////////////////////////////////////////////////////////
/// \brief Construct the rect from given center coordinates and size
/// \brief Construct the rect from given centers coordinates
///
/// \param p1 Coordinates of the top left rectangle corner
/// \param p2 Coordinates of the bottom right rectangle corner
@ -317,7 +317,7 @@ public:
///
/// \param rect Rect to check
///
/// \returns True if the rects intersect
/// \returns True if rectangles intersect
///
////////////////////////////////////////////////////////////
bool Intersects(const Rect& rect) const;
@ -327,7 +327,7 @@ public:
///
/// \param rect Rect to union with
///
/// \returns Rect representing intersection area or NullOpt if there was no intersection
/// \returns Rect representing union of two rectangles
///
////////////////////////////////////////////////////////////
Rect GetUnion(const Rect& rect) const;

66
SDL2pp/Renderer.hh
View File

@ -48,7 +48,7 @@ class Point;
////////////////////////////////////////////////////////////
class Renderer {
private:
SDL_Renderer* renderer_; ///< Contained SDL_Renderer structure
SDL_Renderer* renderer_; ///< Managed SDL_Renderer object
public:
////////////////////////////////////////////////////////////
@ -68,7 +68,7 @@ public:
/// the requested flags
/// \param flags 0 or more SDL_RendererFlags OR'ed together
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_CreateRenderer
///
@ -118,9 +118,9 @@ public:
Renderer& operator=(const Renderer& other) = delete;
////////////////////////////////////////////////////////////
/// \brief Get pointer to contained SDL_Renderer structure
/// \brief Get pointer to managed SDL_Renderer structure
///
/// \returns Pointer to contained SDL_Renderer structure
/// \returns Pointer to managed SDL_Renderer structure
///
////////////////////////////////////////////////////////////
SDL_Renderer* Get() const;
@ -129,14 +129,14 @@ public:
/// \brief Update the screen with any rendering performed
/// since the previous call
///
/// SDL's rendering functions operate on a backbuffer; that
/// %SDL's rendering functions operate on a backbuffer; that
/// is, calling a rendering function such as SDL_RenderDrawLine()
/// does not directly put a line on the screen, but rather
/// updates the backbuffer. As such, you compose your entire
/// scene and present the composed backbuffer to the screen as
/// a complete picture.
///
/// Therefore, when using SDL's rendering API, one does all
/// Therefore, when using %SDL's rendering API, one does all
/// drawing intended for the frame, and then calls this function
/// once per frame to present the final drawing to the user.
///
@ -148,7 +148,7 @@ public:
////////////////////////////////////////////////////////////
/// \brief Clear the current rendering target with the drawing color
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderClear
///
@ -161,7 +161,7 @@ public:
/// \param info SDL_RendererInfo structure to be filled with
/// information about the current renderer
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_GetRendererInfo
///
@ -177,7 +177,7 @@ public:
/// \param dstrect Destination rectangle, NullOpt for the entire
/// rendering target
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderCopy
///
@ -200,7 +200,7 @@ public:
/// \param flip SDL_RendererFlip value stating which flipping
/// actions should be performed on the texture
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RendererFlip
/// \see http://wiki.libsdl.org/SDL_RenderCopyEx
@ -216,7 +216,7 @@ public:
/// \param b Blue value used to draw on the rendering target
/// \param a Alpha value used to draw on the rendering target
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_SetRenderDrawColor
///
@ -226,7 +226,7 @@ public:
////////////////////////////////////////////////////////////
/// \brief Set current render target to default
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_SetRenderTarget
///
@ -239,7 +239,7 @@ public:
/// \param texture Target texture, SDL2pp::Texture created with
/// SDL_TEXTUREACCESS_TARGET
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_SetRenderTarget
///
@ -251,7 +251,7 @@ public:
///
/// \param blendMode SDL_BlendMode to use for blending
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_BlendMode
/// \see http://wiki.libsdl.org/SDL_SetRenderDrawBlendMode
@ -265,7 +265,7 @@ public:
/// \param x X coordinate of the point
/// \param y Y coordinate of the point
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderDrawPoint
///
@ -277,7 +277,7 @@ public:
///
/// \param p Coordinates of the point
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderDrawPoint
///
@ -290,7 +290,7 @@ public:
/// \param points Array of coordinates of points to draw
/// \param count Number of points to draw
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderDrawPoints
///
@ -305,7 +305,7 @@ public:
/// \param x2 X coordinate of the end point
/// \param y2 Y coordinate of the end point
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderDrawLine
///
@ -318,7 +318,7 @@ public:
/// \param p1 Coordinates of the start point
/// \param p2 Coordinates of the end point
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderDrawLine
///
@ -331,7 +331,7 @@ public:
/// \param points Array of coordinates of points along the polyline
/// \param count Number of points to draw count-1 polyline segments
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderDrawLines
///
@ -346,7 +346,7 @@ public:
/// \param x2 X coordinate of the end corner
/// \param y2 Y coordinate of the end corner
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderDrawRect
///
@ -359,7 +359,7 @@ public:
/// \param p1 Coordinates of the start corner
/// \param p2 Coordinates of the end corner
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderDrawRect
///
@ -371,7 +371,7 @@ public:
///
/// \param r Rectangle to draw
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderDrawRect
///
@ -384,7 +384,7 @@ public:
/// \param rects Array of rectangles to draw
/// \param count Number of rectangles
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderDrawRects
///
@ -399,7 +399,7 @@ public:
/// \param x2 X coordinate of the end corner
/// \param y2 Y coordinate of the end corner
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderFillRect
///
@ -412,7 +412,7 @@ public:
/// \param p1 Coordinates of the start corner
/// \param p2 Coordinates of the end corner
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderFillRect
///
@ -424,7 +424,7 @@ public:
///
/// \param r Rectangle to draw
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderFillRect
///
@ -437,7 +437,7 @@ public:
/// \param rects Array of rectangles to draw
/// \param count Number of rectangles
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderFillRects
///
@ -456,7 +456,7 @@ public:
/// \param pitch Number of bytes in a row of pixel data, including
/// padding between lines
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderReadPixels
///
@ -469,7 +469,7 @@ public:
/// \param rect New clipping rectangle or NullOpt to disable
/// clipping
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderSetClipRect
///
@ -482,7 +482,7 @@ public:
/// \param w Width of the logical resolution
/// \param h Height of the logical resolution
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderSetLogicalSize
///
@ -495,7 +495,7 @@ public:
/// \param scaleX Horizontal scaling factor
/// \param scaleY Vertical scaling factor
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderSetScale
///
@ -508,7 +508,7 @@ public:
/// \param rect Rectangle representing the drawing area or
/// NullOpt to set the viewport to the entire target
///
/// \throws SDL2pp::Exceptions
/// \throws SDL2pp::Exception
///
/// \see http://wiki.libsdl.org/SDL_RenderSetViewport
///

2
SDL2pp/SDL.hh
View File

@ -27,7 +27,7 @@
namespace SDL2pp {
////////////////////////////////////////////////////////////
/// \brief Object taking care of SDL2 library (de-)initialization
/// \brief Class taking care of SDL2 library initialization and deinitialization
///
/// \ingroup general
///

4
SDL2pp/SDLImage.hh
View File

@ -25,14 +25,14 @@
namespace SDL2pp {
////////////////////////////////////////////////////////////
/// \brief Object taking care of SDL_image library (de-)initialization
/// \brief Object taking care of SDL_image library initialization and deinitialization
///
/// \ingroup image
///
/// \headerfile SDL2pp/SDLImage.hh
///
/// Though it's possible to use SDL_image without initializing it,
/// library provide initialization/deinitialization functions to
/// library provides initialization/deinitialization functions to
/// be able to preload libraries for specific file format support
/// (png, jpeg or tiff) beforehand. In SDL2pp, this is handled by
/// this class.

6
SDL2pp/SDLTTF.hh
View File

@ -25,7 +25,7 @@
namespace SDL2pp {
////////////////////////////////////////////////////////////
/// \brief Object taking care of SDL_ttf library (de-)initialization
/// \brief Object taking care of SDL_ttf library initialization and deinitialization
///
/// \ingroup ttf
///
@ -34,8 +34,8 @@ namespace SDL2pp {
/// To use SDL_ttf functions, SDL_ttf library must be initialized first.
/// This initialization and automatic deinitialization is handled by
/// this class. You may only use SDL_ttf (Font class) functionality
/// while SDLTTF object lives. SDL itself must not be initialized to use
/// TTF
/// as long as SDLTTF object lives. SDL itself must not be initialized
/// to use TTF.
///
/// Usage example:
/// \code

12
SDL2pp/StreamRWops.hh
View File

@ -37,13 +37,13 @@ namespace SDL2pp {
///
/// \headerfile SDL2pp/StreamRWops.hh
///
/// This class extends functionality of RWops concept onto STL
/// streams. With ContainerRWops, you may read from / write to a
/// streams with SDL functions.
/// This class extends functionality of %RWops concept onto STL
/// streams. With ContainerRWops, you may read from / write to
/// STL streams with %SDL functions.
///
/// This template supports both input and output streams, but not
/// at the same time, as separate input and output pointers of
/// streams are not compatible with RWops.
/// streams are not compatible with %RWops.
///
////////////////////////////////////////////////////////////
template <class S>
@ -133,7 +133,7 @@ private:
public:
////////////////////////////////////////////////////////////
/// \brief Construct StreamRWops for specificed stream
/// \brief Construct StreamRWops for specified stream
///
/// \param stream Stream to use
///
@ -206,7 +206,7 @@ public:
}
////////////////////////////////////////////////////////////
/// \brief Close strem
/// \brief Close stream
///
/// \returns 0 on success or a negative error code on failure
///

18
SDL2pp/Surface.hh
View File

@ -50,7 +50,7 @@ class RWops;
////////////////////////////////////////////////////////////
class Surface {
private:
SDL_Surface* surface_; ///< Contained SDL_Texture structure
SDL_Surface* surface_; ///< Managed SDL_Surface object
public:
////////////////////////////////////////////////////////////
@ -60,7 +60,7 @@ public:
///
/// \headerfile SDL2pp/Surface.hh
///
/// For direct pixel access, SDL surface may need to be locked.
/// For direct pixel access, %SDL surface may need to be locked.
/// This class represents the lock and controls its lifetime
/// as the lock is released as soon as LockHandle is destroyed.
///
@ -72,7 +72,7 @@ public:
private:
////////////////////////////////////////////////////////////
/// \brief Create lock for specific SDL2pp::Texture
/// \brief Create lock for specific SDL2pp::Surface
///
/// \throws STL2pp::Exception
///
@ -85,8 +85,8 @@ public:
////////////////////////////////////////////////////////////
/// \brief Create no-op lock
///
/// This may be initialized with real lock later with move
/// assignment operator
/// This may be initialized with real lock later via move
/// assignment
///
////////////////////////////////////////////////////////////
LockHandle();
@ -195,7 +195,7 @@ public:
/// \param pixels Pointer to existing pixel data
/// \param width Width of the surface
/// \param height Height of the surface
/// \param depth depth of the surface in bits
/// \param depth Depth of the surface in bits
/// \param pitch Number of bytes in a row of pixel data, including padding between lines
/// \param Rmask Red mask for the pixels
/// \param Gmask Green mask for the pixels
@ -270,9 +270,9 @@ public:
Surface& operator=(const Surface&) = delete;
////////////////////////////////////////////////////////////
/// \brief Get pointer to contained SDL_Surface structure
/// \brief Get pointer to managed SDL_Surface structure
///
/// \returns Pointer to contained SDL_Surface structure
/// \returns Pointer to managed SDL_Surface structure
///
////////////////////////////////////////////////////////////
SDL_Surface* Get() const;
@ -406,7 +406,7 @@ public:
////////////////////////////////////////////////////////////
/// \brief Set the clipping rectangle for a surface
///
/// \param rect SDL22::Rect representing the clipping rectangle, or NullOpt to disable clipping
/// \param rect Rect representing the clipping rectangle, or NullOpt to disable clipping
///
/// \throws SDL2pp::Exception
///

12
SDL2pp/Texture.hh
View File

@ -50,7 +50,7 @@ class Surface;
////////////////////////////////////////////////////////////
class Texture {
private:
SDL_Texture* texture_; ///< Contained SDL_Texture structure
SDL_Texture* texture_; ///< Managed SDL_Texture object
public:
////////////////////////////////////////////////////////////
@ -115,8 +115,8 @@ public:
////////////////////////////////////////////////////////////
/// \brief Create no-op lock
///
/// This may be initialized with real lock later with move
/// assignment operator
/// This may be initialized with real lock later via move
/// assignment
///
////////////////////////////////////////////////////////////
LockHandle();
@ -198,7 +198,7 @@ public:
/// \param renderer Rendering context to create texture for
/// \param format One of the enumerated values in SDL_PixelFormatEnum
/// \param access One of the enumerated values in SDL_TextureAccess
/// \param w With of the texture in pixels
/// \param w Width of the texture in pixels
/// \param h Height of the texture in pixels
///
/// \throws SDL2pp::Exception
@ -288,9 +288,9 @@ public:
Texture& operator=(const Texture& other) = delete;
////////////////////////////////////////////////////////////
/// \brief Get pointer to contained SDL_Texture structure
/// \brief Get pointer to managed SDL_Texture structure
///
/// \returns Pointer to contained SDL_Texture structure
/// \returns Pointer to managed SDL_Texture structure
///
////////////////////////////////////////////////////////////
SDL_Texture* Get() const;

2
SDL2pp/Wav.hh
View File

@ -38,7 +38,7 @@ class RWops;
/// \headerfile SDL2pp/Wav.hh
///
/// SDL2pp::Wav is a wrapper around basic SDL2 audio fragment
/// handling functionality, basically SDL_LoadWAV and related
/// handling functionality, basically SDL_LoadWAV() and related
/// functions.
///
/// The class holds raw audio data which is loaded from a disk

6
SDL2pp/Window.hh
View File

@ -61,7 +61,7 @@ namespace SDL2pp {
////////////////////////////////////////////////////////////
class Window {
private:
SDL_Window* window_; ///< Contained SDL2_Window structure
SDL_Window* window_; ///< Managed SDL2_Window object
public:
////////////////////////////////////////////////////////////
@ -132,9 +132,9 @@ public:
Window& operator=(const Window& other) = delete;
////////////////////////////////////////////////////////////
/// \brief Get pointer to contained SDL_Window structure
/// \brief Get pointer to managed SDL_Window structure
///
/// \returns Pointer to SDL_Window structure
/// \returns Pointer to managed SDL_Window structure
///
////////////////////////////////////////////////////////////
SDL_Window* Get() const;