lauchmelder/SFML
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Corrected the name of some functions/variable

Browse source
This commit is contained in:
Laurent Gomila 2011-12-25 23:42:43 +01:00
parent c817f882e6
commit aaa21dfaf6
32 changed files with 203 additions and 203 deletions
Download patch file Download diff file Expand all files Collapse all files

28
include/SFML/Audio/SoundBuffer.hpp
View file

@ -127,17 +127,17 @@ public :
/// The assumed format of the audio samples is 16 bits signed integer
/// (sf::Int16).
///
/// \param samples Pointer to the array of samples in memory
/// \param samplesCount Number of samples in the array
/// \param channelsCount Number of channels (1 = mono, 2 = stereo, ...)
/// \param sampleRate Sample rate (number of samples to play per second)
/// \param samples Pointer to the array of samples in memory
/// \param sampleCount Number of samples in the array
/// \param channelCount Number of channels (1 = mono, 2 = stereo, ...)
/// \param sampleRate Sample rate (number of samples to play per second)
///
/// \return True if loading succeeded, false if it failed
///
/// \see LoadFromFile, LoadFromMemory, SaveToFile
///
////////////////////////////////////////////////////////////
bool LoadFromSamples(const Int16* samples, std::size_t samplesCount, unsigned int channelsCount, unsigned int sampleRate);
bool LoadFromSamples(const Int16* samples, std::size_t sampleCount, unsigned int channelCount, unsigned int sampleRate);
////////////////////////////////////////////////////////////
/// \brief Save the sound buffer to an audio file
@ -160,11 +160,11 @@ public :
///
/// The format of the returned samples is 16 bits signed integer
/// (sf::Int16). The total number of samples in this array
/// is given by the GetSamplesCount() function.
/// is given by the GetSampleCount() function.
///
/// \return Read-only pointer to the array of sound samples
///
/// \see GetSamplesCount
/// \see GetSampleCount
///
////////////////////////////////////////////////////////////
const Int16* GetSamples() const;
@ -180,7 +180,7 @@ public :
/// \see GetSamples
///
////////////////////////////////////////////////////////////
std::size_t GetSamplesCount() const;
std::size_t GetSampleCount() const;
////////////////////////////////////////////////////////////
/// \brief Get the sample rate of the sound
@ -191,7 +191,7 @@ public :
///
/// \return Sample rate (number of samples per second)
///
/// \see GetChannelsCount, GetDuration
/// \see GetChannelCount, GetDuration
///
////////////////////////////////////////////////////////////
unsigned int GetSampleRate() const;
@ -207,14 +207,14 @@ public :
/// \see GetSampleRate, GetDuration
///
////////////////////////////////////////////////////////////
unsigned int GetChannelsCount() const;
unsigned int GetChannelCount() const;
////////////////////////////////////////////////////////////
/// \brief Get the total duration of the sound
///
/// \return Sound duration, in milliseconds
///
/// \see GetSampleRate, GetChannelsCount
/// \see GetSampleRate, GetChannelCount
///
////////////////////////////////////////////////////////////
Uint32 GetDuration() const;
@ -246,13 +246,13 @@ private :
////////////////////////////////////////////////////////////
/// \brief Update the internal buffer with the cached audio samples
///
/// \param channelsCount Number of channels
/// \param sampleRate Sample rate (number of samples per second)
/// \param channelCount Number of channels
/// \param sampleRate Sample rate (number of samples per second)
///
/// \return True on success, false if any error happened
///
////////////////////////////////////////////////////////////
bool Update(unsigned int channelsCount, unsigned int sampleRate);
bool Update(unsigned int channelCount, unsigned int sampleRate);
////////////////////////////////////////////////////////////
/// \brief Add a sound to the list of sounds that use this buffer

6
include/SFML/Audio/SoundBufferRecorder.hpp
View file

@ -70,13 +70,13 @@ private :
////////////////////////////////////////////////////////////
/// \brief Process a new chunk of recorded samples
///
/// \param samples Pointer to the new chunk of recorded samples
/// \param samplesCount Number of samples pointed by \a samples
/// \param samples Pointer to the new chunk of recorded samples
/// \param sampleCount Number of samples pointed by \a samples
///
/// \return True to continue the capture, or false to stop it
///
////////////////////////////////////////////////////////////
virtual bool OnProcessSamples(const Int16* samples, std::size_t samplesCount);
virtual bool OnProcessSamples(const Int16* samples, std::size_t sampleCount);
////////////////////////////////////////////////////////////
/// \brief Stop capturing audio data

8
include/SFML/Audio/SoundRecorder.hpp
View file

@ -131,13 +131,13 @@ private :
/// whatever it wants with it (storing it, playing it, sending
/// it over the network, etc.).
///
/// \param samples Pointer to the new chunk of recorded samples
/// \param samplesCount Number of samples pointed by \a samples
/// \param samples Pointer to the new chunk of recorded samples
/// \param sampleCount Number of samples pointed by \a samples
///
/// \return True to continue the capture, or false to stop it
///
////////////////////////////////////////////////////////////
virtual bool OnProcessSamples(const Int16* samples, std::size_t samplesCount) = 0;
virtual bool OnProcessSamples(const Int16* samples, std::size_t sampleCount) = 0;
////////////////////////////////////////////////////////////
/// \brief Stop capturing audio data
@ -238,7 +238,7 @@ private :
/// return true;
/// }
///
/// virtual bool OnProcessSamples(const Int16* samples, std::size_t samplesCount)
/// virtual bool OnProcessSamples(const Int16* samples, std::size_t sampleCount)
/// {
/// // Do something with the new chunk of samples (store them, send them, ...)
/// ...

34
include/SFML/Audio/SoundStream.hpp
View file

@ -104,7 +104,7 @@ public :
/// \return Number of channels
///
////////////////////////////////////////////////////////////
unsigned int GetChannelsCount() const;
unsigned int GetChannelCount() const;
////////////////////////////////////////////////////////////
/// \brief Get the stream sample rate of the stream
@ -193,11 +193,11 @@ protected :
/// It can be called multiple times if the settings of the
/// audio stream change, but only when the stream is stopped.
///
/// \param channelsCount Number of channels of the stream
/// \param sampleRate Sample rate, in samples per second
/// \param channelCount Number of channels of the stream
/// \param sampleRate Sample rate, in samples per second
///
////////////////////////////////////////////////////////////
void Initialize(unsigned int channelsCount, unsigned int sampleRate);
void Initialize(unsigned int channelCount, unsigned int sampleRate);
private :
@ -245,7 +245,7 @@ private :
/// consumed; it fills it again and inserts it back into the
/// playing queue.
///
/// \param buffer Number of the buffer to fill (in [0, BuffersCount])
/// \param buffer Number of the buffer to fill (in [0, BufferCount])
///
/// \return True if the stream source has requested to stop, false otherwise
///
@ -273,21 +273,21 @@ private :
enum
{
BuffersCount = 3 ///< Number of audio buffers used by the streaming loop
BufferCount = 3 ///< Number of audio buffers used by the streaming loop
};
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
Thread myThread; ///< Thread running the background tasks
bool myIsStreaming; ///< Streaming state (true = playing, false = stopped)
unsigned int myBuffers[BuffersCount]; ///< Sound buffers used to store temporary audio data
unsigned int myChannelsCount; ///< Number of channels (1 = mono, 2 = stereo, ...)
unsigned int mySampleRate; ///< Frequency (samples / second)
Uint32 myFormat; ///< Format of the internal sound buffers
bool myLoop; ///< Loop flag (true to loop, false to play once)
Uint64 mySamplesProcessed; ///< Number of buffers processed since beginning of the stream
bool myEndBuffers[BuffersCount]; ///< Each buffer is marked as "end buffer" or not, for proper duration calculation
Thread myThread; ///< Thread running the background tasks
bool myIsStreaming; ///< Streaming state (true = playing, false = stopped)
unsigned int myBuffers[BufferCount]; ///< Sound buffers used to store temporary audio data
unsigned int myChannelCount; ///< Number of channels (1 = mono, 2 = stereo, ...)
unsigned int mySampleRate; ///< Frequency (samples / second)
Uint32 myFormat; ///< Format of the internal sound buffers
bool myLoop; ///< Loop flag (true to loop, false to play once)
Uint64 mySamplesProcessed; ///< Number of buffers processed since beginning of the stream
bool myEndBuffers[BufferCount]; ///< Each buffer is marked as "end buffer" or not, for proper duration calculation
};
} // namespace sf
@ -338,11 +338,11 @@ private :
/// {
/// // Open the source and get audio settings
/// ...
/// unsigned int channelsCount = ...;
/// unsigned int channelCount = ...;
/// unsigned int sampleRate = ...;
///
/// // Initialize the stream -- important!
/// Initialize(channelsCount, sampleRate);
/// Initialize(channelCount, sampleRate);
/// }
///
/// private :

18
include/SFML/Graphics/CircleShape.hpp
View file

@ -44,11 +44,11 @@ public :
////////////////////////////////////////////////////////////
/// \brief Default constructor
///
/// \param radius Radius of the circle
/// \param pointsCount Number of points composing the circle
/// \param radius Radius of the circle
/// \param pointCount Number of points composing the circle
///
////////////////////////////////////////////////////////////
explicit CircleShape(float radius = 0, unsigned int pointsCount = 30);
explicit CircleShape(float radius = 0, unsigned int pointCount = 30);
////////////////////////////////////////////////////////////
/// \brief Set the radius of the circle
@ -75,20 +75,20 @@ public :
///
/// \param count New number of points of the circle
///
/// \see GetPointsCount
/// \see GetPointCount
///
////////////////////////////////////////////////////////////
void SetPointsCount(unsigned int count);
void SetPointCount(unsigned int count);
////////////////////////////////////////////////////////////
/// \brief Get the number of points of the shape
///
/// \return Number of points of the shape
///
/// \see SetPointsCount
/// \see SetPointCount
///
////////////////////////////////////////////////////////////
virtual unsigned int GetPointsCount() const;
virtual unsigned int GetPointCount() const;
////////////////////////////////////////////////////////////
/// \brief Get a point of the shape
@ -105,8 +105,8 @@ private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
float myRadius; ///< Radius of the circle
unsigned int myPointsCount; ///< Number of points composing the circle
float myRadius; ///< Radius of the circle
unsigned int myPointCount; ///< Number of points composing the circle
};
} // namespace sf

14
include/SFML/Graphics/ConvexShape.hpp
View file

@ -45,30 +45,30 @@ public :
////////////////////////////////////////////////////////////
/// \brief Default constructor
///
/// \param pointsCount Number of points of the polygon
/// \param pointCount Number of points of the polygon
///
////////////////////////////////////////////////////////////
explicit ConvexShape(unsigned int pointsCount = 0);
explicit ConvexShape(unsigned int pointCount = 0);
////////////////////////////////////////////////////////////
/// \brief Set the number of points of the polygon
///
/// \param count New number of points of the polygon
///
/// \see GetPointsCount
/// \see GetPointCount
///
////////////////////////////////////////////////////////////
void SetPointsCount(unsigned int count);
void SetPointCount(unsigned int count);
////////////////////////////////////////////////////////////
/// \brief Get the number of points of the polygon
///
/// \return Number of points of the polygon
///
/// \see SetPointsCount
/// \see SetPointCount
///
////////////////////////////////////////////////////////////
virtual unsigned int GetPointsCount() const;
virtual unsigned int GetPointCount() const;
////////////////////////////////////////////////////////////
/// \brief Set the position of a point
@ -126,7 +126,7 @@ private :
/// Usage example:
/// \code
/// sf::ConvexShape polygon;
/// polygon.SetPointsCount(3);
/// polygon.SetPointCount(3);
/// polygon.SetPoint(0, sf::Vector2f(0, 0));
/// polygon.SetPoint(1, sf::Vector2f(0, 10));
/// polygon.SetPoint(2, sf::Vector2f(25, 5));

2
include/SFML/Graphics/Image.hpp
View file

@ -67,7 +67,7 @@ public :
////////////////////////////////////////////////////////////
/// \brief Create the image from an arry of pixels
///
/// The \a pixels array is assumed to contain 32-bits RGBA pixels,
/// The \a pixel array is assumed to contain 32-bits RGBA pixels,
/// and have the given \a width and \a height. If not, this is
/// an undefined behaviour.
/// If \a pixels is null, an empty image is created.

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

@ -75,7 +75,7 @@ public :
/// \return Number of points of the shape
///
////////////////////////////////////////////////////////////
virtual unsigned int GetPointsCount() const;
virtual unsigned int GetPointCount() const;
////////////////////////////////////////////////////////////
/// \brief Get a point of the shape

10
include/SFML/Graphics/RenderTarget.hpp
View file

@ -189,13 +189,13 @@ public :
////////////////////////////////////////////////////////////
/// \brief Draw primitives defined by an array of vertices
///
/// \param vertices Pointer to the vertices
/// \param verticesCount Number of vertices in the array
/// \param type Type of primitives to draw
/// \param states Render states to use for drawing
/// \param vertices Pointer to the vertices
/// \param vertexCount Number of vertices in the array
/// \param type Type of primitives to draw
/// \param states Render states to use for drawing
///
////////////////////////////////////////////////////////////
void Draw(const Vertex* vertices, unsigned int verticesCount,
void Draw(const Vertex* vertices, unsigned int vertexCount,
PrimitiveType type, const RenderStates& states = RenderStates::Default);
////////////////////////////////////////////////////////////

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

@ -190,12 +190,12 @@ public :
/// \return Number of points of the shape
///
////////////////////////////////////////////////////////////
virtual unsigned int GetPointsCount() const = 0;
virtual unsigned int GetPointCount() const = 0;
////////////////////////////////////////////////////////////
/// \brief Get a point of the shape
///
/// \param index Index of the point to get, in range [0 .. GetPointsCount() - 1]
/// \param index Index of the point to get, in range [0 .. GetPointCount() - 1]
///
/// \return Index-th point of the shape
///
@ -243,7 +243,7 @@ protected :
///
/// This function must be called by the derived class everytime
/// the shape's points change (ie. the result of either
/// GetPointsCount or GetPoint is different).
/// GetPointCount or GetPoint is different).
///
////////////////////////////////////////////////////////////
void Update();
@ -330,7 +330,7 @@ private :
///
/// You can write your own derived shape class, there are only
/// two virtual functions to override:
/// \li GetOutlinePointsCount must return the number of points of the shape
/// \li GetOutlinePointCount must return the number of points of the shape
/// \li GetOutlinePoint must return the points of the shape
///
/// \see sf::LineShape, sf::RectangleShape, sf::CircleShape, sf::ConvexShape, sf::Transformable

4
include/SFML/Graphics/Texture.hpp
View file

@ -250,7 +250,7 @@ public :
////////////////////////////////////////////////////////////
/// \brief Update the whole texture from an array of pixels
///
/// The \a pixels array is assumed to have the same size as
/// The \a pixel array is assumed to have the same size as
/// the \a area rectangle, and to contain 32-bits RGBA pixels.
///
/// No additional check is performed on the size of the pixel
@ -268,7 +268,7 @@ public :
////////////////////////////////////////////////////////////
/// \brief Update a part of the texture from an array of pixels
///
/// The size of the \a pixels array must match the \a width and
/// The size of the \a pixel array must match the \a width and
/// \a height arguments, and it must contain 32-bits RGBA pixels.
///
/// No additional check is performed on the size of the pixel

20
include/SFML/Graphics/VertexArray.hpp
View file

@ -56,11 +56,11 @@ public :
////////////////////////////////////////////////////////////
/// \brief Construct the vertex array with a type and an initial number of vertices
///
/// \param type Type of primitives
/// \param verticesCount Initial number of vertices in the array
/// \param type Type of primitives
/// \param vertexCount Initial number of vertices in the array
///
////////////////////////////////////////////////////////////
VertexArray(PrimitiveType type, unsigned int verticesCount = 0);
VertexArray(PrimitiveType type, unsigned int vertexCount = 0);
////////////////////////////////////////////////////////////
/// \brief Return the vertices count
@ -68,19 +68,19 @@ public :
/// \return Number of vertices in the array
///
////////////////////////////////////////////////////////////
unsigned int GetVerticesCount() const;
unsigned int GetVertexCount() const;
////////////////////////////////////////////////////////////
/// \brief Get a read-write access to a vertex by its index
///
/// This function doesn't check \a index, it must be in range
/// [0, GetVerticesCount() - 1].
/// [0, GetVertexCount() - 1].
///
/// \param index Index of the vertex to get
///
/// \return Reference to the index-th vertex
///
/// \see GetVerticesCount
/// \see GetVertexCount
///
////////////////////////////////////////////////////////////
Vertex& operator [](unsigned int index);
@ -89,13 +89,13 @@ 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
/// [0, GetVerticesCount() - 1].
/// [0, GetVertexCount() - 1].
///
/// \param index Index of the vertex to get
///
/// \return Const reference to the index-th vertex
///
/// \see GetVerticesCount
/// \see GetVertexCount
///
////////////////////////////////////////////////////////////
const Vertex& operator [](unsigned int index) const;
@ -120,10 +120,10 @@ public :
/// If \a count is less than the current size, existing vertices
/// are removed from the array.
///
/// \param verticesCount New size of the array (number of vertices)
/// \param vertexCount New size of the array (number of vertices)
///
////////////////////////////////////////////////////////////
void Resize(unsigned int verticesCount);
void Resize(unsigned int vertexCount);
////////////////////////////////////////////////////////////
/// \brief Add a vertex to the array