Edgaru089/SFML
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Changed internal naming convention (local variables now start with a lower case character)

Browse Source 
Removed the AudioResource class

git-svn-id: https://sfml.svn.sourceforge.net/svnroot/sfml/branches/sfml2@1166 4e206d99-4929-0410-ac5d-dfc041789085
This commit is contained in:
LaurentGom 2009-07-11 22:17:24 +00:00
parent 7cc00085d8
commit 45b150648d
245 changed files with 7865 additions and 8065 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CSFML/build/VC2008/csfml-audio.vcproj
View File

@ -215,6 +215,10 @@
RelativePath="..\..\include\SFML\Audio\Music.h"
>
</File>
<File
RelativePath="..\..\src\SFML\Audio\MusicStruct.h"
>
</File>
<File
RelativePath="..\..\src\SFML\Audio\Sound.cpp"
>

4
CSFML/build/VC2008/csfml-graphics.vcproj
View File

@ -268,6 +268,10 @@
RelativePath="..\..\src\SFML\Graphics\RenderImage.cpp"
>
</File>
<File
RelativePath="..\..\include\SFML\Graphics\RenderImage.h"
>
</File>
<File
RelativePath="..\..\src\SFML\Graphics\RenderImageStruct.h"
>

12
CSFML/build/VC2008/csfml-main.vcproj
View File

@ -147,16 +147,10 @@
<References>
</References>
<Files>
<Filter
Name="Sources Files"
Filter="cpp;c;cc;cxx;def;odl;idl;hp"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
<File
RelativePath="..\..\src\SFML\Main\SFML_Main.cpp"
>
<File
RelativePath="..\..\src\SFML\Main\SFML_Main.cpp"
>
</File>
</Filter>
</File>
</Files>
<Globals>
</Globals>

36
CSFML/include/SFML/Audio/Listener.h
View File

@ -34,10 +34,10 @@
////////////////////////////////////////////////////////////
/// Change the global volume of all the sounds
///
/// \param Volume : New global volume, in the range [0, 100]
/// \param volume : New global volume, in the range [0, 100]
///
////////////////////////////////////////////////////////////
CSFML_API void sfListener_SetGlobalVolume(float Volume);
CSFML_API void sfListener_SetGlobalVolume(float volume);
////////////////////////////////////////////////////////////
/// Get the current value of the global volume of all the sounds
@ -50,44 +50,44 @@ CSFML_API float sfListener_GetGlobalVolume();
////////////////////////////////////////////////////////////
/// Change the position of the listener
///
/// \param PosX : X position of the listener in the world
/// \param PosY : Y position of the listener in the world
/// \param PosZ : Z position of the listener in the world
/// \param x : X position of the listener in the world
/// \param y : Y position of the listener in the world
/// \param z : Z position of the listener in the world
///
////////////////////////////////////////////////////////////
CSFML_API void sfListener_SetPosition(float PosX, float PosY, float PosZ);
CSFML_API void sfListener_SetPosition(float x, float y, float z);
////////////////////////////////////////////////////////////
/// Get the current position of the listener
///
/// \param PosX : X position of the listener in the world
/// \param PosY : Y position of the listener in the world
/// \param PosZ : Z position of the listener in the world
/// \param x : X position of the listener in the world
/// \param y : Y position of the listener in the world
/// \param z : Z position of the listener in the world
///
////////////////////////////////////////////////////////////
CSFML_API void sfListener_GetPosition(float* PosX, float* PosY, float* PosZ);
CSFML_API void sfListener_GetPosition(float* x, float* y, float* z);
////////////////////////////////////////////////////////////
/// Change the orientation of the listener (the point
/// he must look at)
///
/// \param TargetX : X position of the point the listener must look at
/// \param TargetY : X position of the point the listener must look at
/// \param TargetZ : X position of the point the listener must look at
/// \param x : X position of the point the listener must look at
/// \param y : X position of the point the listener must look at
/// \param z : X position of the point the listener must look at
///
////////////////////////////////////////////////////////////
CSFML_API void sfListener_SetTarget(float TargetX, float TargetY, float TargetZ);
CSFML_API void sfListener_SetTarget(float x, float y, float z);
////////////////////////////////////////////////////////////
/// Get the current orientation of the listener (the point
/// he's looking at)
///
/// \param TargetX : X position of the point the listener is looking at
/// \param TargetY : X position of the point the listener is looking at
/// \param TargetZ : X position of the point the listener is looking at
/// \param x : X position of the point the listener is looking at
/// \param y : X position of the point the listener is looking at
/// \param z : X position of the point the listener is looking at
///
////////////////////////////////////////////////////////////
CSFML_API void sfListener_GetTarget(float* TargetX, float* TargetY, float* TargetZ);
CSFML_API void sfListener_GetTarget(float* x, float* y, float* z);
#endif // SFML_LISTENER_H

132
CSFML/include/SFML/Audio/Music.h
View File

@ -36,257 +36,257 @@
////////////////////////////////////////////////////////////
/// Create a new music and load it from a file
///
/// \param Filename : Path of the music file to open
/// \param filename : Path of the music file to open
///
/// \return A new sfMusic object (NULL if failed)
///
////////////////////////////////////////////////////////////
CSFML_API sfMusic* sfMusic_CreateFromFile(const char* Filename);
CSFML_API sfMusic* sfMusic_CreateFromFile(const char* filename);
////////////////////////////////////////////////////////////
/// Create a new music and load it from a file in memory
///
/// \param Data : Pointer to the file data in memory
/// \param SizeInBytes : Size of the data to load, in bytes
/// \param data : Pointer to the file data in memory
/// \param sizeInBytes : Size of the data to load, in bytes
///
/// \return A new sfMusic object (NULL if failed)
///
////////////////////////////////////////////////////////////
CSFML_API sfMusic* sfMusic_CreateFromMemory(const char* Data, size_t SizeInBytes);
CSFML_API sfMusic* sfMusic_CreateFromMemory(const char* data, size_t sizeInBytes);
////////////////////////////////////////////////////////////
/// Destroy an existing music
///
/// \param Music : Music to delete
/// \param music : Music to delete
///
////////////////////////////////////////////////////////////
CSFML_API void sfMusic_Destroy(sfMusic* Music);
CSFML_API void sfMusic_Destroy(sfMusic* music);
////////////////////////////////////////////////////////////
/// Set a music loop state
///
/// \param Music : Music to set the loop state
/// \param Loop : sfTrue to play in loop, sfFalse to play once
/// \param music : Music to set the loop state
/// \param loop : sfTrue to play in loop, sfFalse to play once
///
////////////////////////////////////////////////////////////
CSFML_API void sfMusic_SetLoop(sfMusic* Music, sfBool Loop);
CSFML_API void sfMusic_SetLoop(sfMusic* music, sfBool loop);
////////////////////////////////////////////////////////////
/// Tell whether or not a music is looping
///
/// \param Music : Music to get the loop state from
/// \param music : Music to get the loop state from
///
/// \return sfTrue if the music is looping, sfFalse otherwise
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfMusic_GetLoop(sfMusic* Music);
CSFML_API sfBool sfMusic_GetLoop(sfMusic* music);
////////////////////////////////////////////////////////////
/// Get a music duration
///
/// \param Music : Music to get the duration from
/// \param music : Music to get the duration from
///
/// \return Music duration, in seconds
///
////////////////////////////////////////////////////////////
CSFML_API float sfMusic_GetDuration(sfMusic* Music);
CSFML_API float sfMusic_GetDuration(sfMusic* music);
////////////////////////////////////////////////////////////
/// Start playing a music
///
/// \param Music : Music to play
/// \param music : Music to play
///
////////////////////////////////////////////////////////////
CSFML_API void sfMusic_Play(sfMusic* Music);
CSFML_API void sfMusic_Play(sfMusic* music);
////////////////////////////////////////////////////////////
/// Pause a music
///
/// \param Music : Music to pause
/// \param music : Music to pause
///
////////////////////////////////////////////////////////////
CSFML_API void sfMusic_Pause(sfMusic* Music);
CSFML_API void sfMusic_Pause(sfMusic* music);
////////////////////////////////////////////////////////////
/// Stop playing a music
///
/// \param Music : Music to stop
/// \param music : Music to stop
///
////////////////////////////////////////////////////////////
CSFML_API void sfMusic_Stop(sfMusic* Music);
CSFML_API void sfMusic_Stop(sfMusic* music);
////////////////////////////////////////////////////////////
/// Return the number of channels of a music (1 = mono, 2 = stereo)
///
/// \param Music : Music to get the channels count from
/// \param music : Music to get the channels count from
///
/// \return Number of channels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfMusic_GetChannelsCount(sfMusic* Music);
CSFML_API unsigned int sfMusic_GetChannelsCount(sfMusic* music);
////////////////////////////////////////////////////////////
/// Get the stream sample rate of a music
///
/// \param Music : Music to get the sample rate from
/// \param music : Music to get the sample rate from
///
/// \return Stream frequency (number of samples per second)
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfMusic_GetSampleRate(sfMusic* Music);
CSFML_API unsigned int sfMusic_GetSampleRate(sfMusic* music);
////////////////////////////////////////////////////////////
/// Get the status of a music (stopped, paused, playing)
///
/// \param Music : Music to get the status from
/// \param music : Music to get the status from
///
/// \return Current status of the sound
///
////////////////////////////////////////////////////////////
CSFML_API sfSoundStatus sfMusic_GetStatus(sfMusic* Music);
CSFML_API sfSoundStatus sfMusic_GetStatus(sfMusic* music);
////////////////////////////////////////////////////////////
/// Get the current playing position of a music
///
/// \param Music : Music to get the position from
/// \param music : Music to get the position from
///
/// \return Current playing position, expressed in seconds
///
////////////////////////////////////////////////////////////
CSFML_API float sfMusic_GetPlayingOffset(sfMusic* Music);
CSFML_API float sfMusic_GetPlayingOffset(sfMusic* music);
////////////////////////////////////////////////////////////
/// Set the pitch of a music
///
/// \param Music : Music to modify
/// \param Pitch : New pitch
/// \param music : Music to modify
/// \param pitch : New pitch
///
////////////////////////////////////////////////////////////
CSFML_API void sfMusic_SetPitch(sfMusic* Music, float Pitch);
CSFML_API void sfMusic_SetPitch(sfMusic* music, float pitch);
////////////////////////////////////////////////////////////
/// Set the volume of a music
///
/// \param Music : Music to modify
/// \param Volume : Volume (in range [0, 100])
/// \param music : Music to modify
/// \param volume : Volume (in range [0, 100])
///
////////////////////////////////////////////////////////////
CSFML_API void sfMusic_SetVolume(sfMusic* Music, float Volume);
CSFML_API void sfMusic_SetVolume(sfMusic* music, float volume);
////////////////////////////////////////////////////////////
/// Set the position of a music
///
/// \param Music : Music to modify
/// \param X : X position of the sound in the world
/// \param Y : Y position of the sound in the world
/// \param Z : Z position of the sound in the world
/// \param music : Music to modify
/// \param x : X position of the sound in the world
/// \param y : Y position of the sound in the world
/// \param z : Z position of the sound in the world
///
////////////////////////////////////////////////////////////
CSFML_API void sfMusic_SetPosition(sfMusic* Music, float X, float Y, float Z);
CSFML_API void sfMusic_SetPosition(sfMusic* music, float x, float y, float z);
////////////////////////////////////////////////////////////
/// Make the music's position relative to the listener's
/// position, or absolute.
/// The default value is false (absolute)
///
/// \param Music : Music to modify
/// \param Relative : True to set the position relative, false to set it absolute
/// \param music : Music to modify
/// \param relative : True to set the position relative, false to set it absolute
///
////////////////////////////////////////////////////////////
CSFML_API void sfMusic_SetRelativeToListener(sfMusic* Music, sfBool Relative);
CSFML_API void sfMusic_SetRelativeToListener(sfMusic* music, sfBool relative);
////////////////////////////////////////////////////////////
/// Set the minimum distance - closer than this distance,
/// the listener will hear the music at its maximum volume.
/// The default minimum distance is 1.0
///
/// \param Music : Music to modify
/// \param MinDistance : New minimum distance for the music
/// \param music : Music to modify
/// \param distance : New minimum distance for the music
///
////////////////////////////////////////////////////////////
CSFML_API void sfMusic_SetMinDistance(sfMusic* Music, float MinDistance);
CSFML_API void sfMusic_SetMinDistance(sfMusic* music, float distance);
////////////////////////////////////////////////////////////
/// Set the attenuation factor - the higher the attenuation, the
/// more the sound will be attenuated with distance from listener.
/// The default attenuation factor 1.0
///
/// \param Music : Music to modify
/// \param Attenuation : New attenuation factor for the sound
/// \param music : Music to modify
/// \param attenuation : New attenuation factor for the sound
///
////////////////////////////////////////////////////////////
CSFML_API void sfMusic_SetAttenuation(sfMusic* Music, float Attenuation);
CSFML_API void sfMusic_SetAttenuation(sfMusic* music, float attenuation);
////////////////////////////////////////////////////////////
/// Set the current playing position of a music
///
/// \param Music : Music to modify
/// \param TimeOffset : New playing position, expressed in seconds
/// \param music : Music to modify
/// \param timeOffset : New playing position, expressed in seconds
///
////////////////////////////////////////////////////////////
CSFML_API void sfMusic_SetPlayingOffset(sfMusic* Music, float TimeOffset);
CSFML_API void sfMusic_SetPlayingOffset(sfMusic* music, float timeOffset);
////////////////////////////////////////////////////////////
/// Get the pitch of a music
///
/// \param Music : Music to get the pitch from
/// \param music : Music to get the pitch from
///
/// \return Pitch value
///
////////////////////////////////////////////////////////////
CSFML_API float sfMusic_GetPitch(sfMusic* Music);
CSFML_API float sfMusic_GetPitch(sfMusic* music);
////////////////////////////////////////////////////////////
/// Get the volume of a music
///
/// \param Music : Music to get the volume from
/// \param music : Music to get the volume from
///
/// \return Volume value (in range [1, 100])
///
////////////////////////////////////////////////////////////
CSFML_API float sfMusic_GetVolume(sfMusic* Music);
CSFML_API float sfMusic_GetVolume(sfMusic* music);
////////////////////////////////////////////////////////////
/// Get the position of a music
///
/// \param Music : Music to get the position from
/// \param X : X position of the sound in the world
/// \param Y : Y position of the sound in the world
/// \param Z : Z position of the sound in the world
/// \param music : Music to get the position from
/// \param x : X position of the sound in the world
/// \param y : Y position of the sound in the world
/// \param z : Z position of the sound in the world
///
////////////////////////////////////////////////////////////
CSFML_API void sfMusic_GetPosition(sfMusic* Music, float* X, float* Y, float* Z);
CSFML_API void sfMusic_GetPosition(sfMusic* music, float* x, float* y, float* z);
////////////////////////////////////////////////////////////
/// Tell if the music's position is relative to the listener's
/// position, or if it's absolute
///
/// \param Music : Music to check
/// \param music : Music to check
///
/// \return sfTrue if the position is relative, sfFalse if it's absolute
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfMusic_IsRelativeToListener(sfMusic* Music);
CSFML_API sfBool sfMusic_IsRelativeToListener(sfMusic* music);
////////////////////////////////////////////////////////////
/// Get the minimum distance of a music
///
/// \param Music : Music to get the minimum distance from
/// \param music : Music to get the minimum distance from
///
/// \return Minimum distance for the music
///
////////////////////////////////////////////////////////////
CSFML_API float sfMusic_GetMinDistance(sfMusic* Music);
CSFML_API float sfMusic_GetMinDistance(sfMusic* music);
////////////////////////////////////////////////////////////
/// Get the attenuation factor of a music
///
/// \param Music : Music to get the attenuation factor from
/// \param music : Music to get the attenuation factor from
///
/// \return Attenuation factor for the a music
///
////////////////////////////////////////////////////////////
CSFML_API float sfMusic_GetAttenuation(sfMusic* Music);
CSFML_API float sfMusic_GetAttenuation(sfMusic* music);
#endif // SFML_MUSIC_H

120
CSFML/include/SFML/Audio/Sound.h
View File

@ -44,225 +44,225 @@ CSFML_API sfSound* sfSound_Create();
////////////////////////////////////////////////////////////
/// Destroy an existing sound
///
/// \param Sound : Sound to delete
/// \param sound : Sound to delete
///
////////////////////////////////////////////////////////////
CSFML_API void sfSound_Destroy(sfSound* Sound);
CSFML_API void sfSound_Destroy(sfSound* sound);
////////////////////////////////////////////////////////////
/// Start playing a sound
///
/// \param Sound : Sound to play
/// \param sound : Sound to play
///
////////////////////////////////////////////////////////////
CSFML_API void sfSound_Play(sfSound* Sound);
CSFML_API void sfSound_Play(sfSound* sound);
////////////////////////////////////////////////////////////
/// Pause a sound
///
/// \param Sound : Sound to pause
/// \param sound : Sound to pause
///
////////////////////////////////////////////////////////////
CSFML_API void sfSound_Pause(sfSound* Sound);
CSFML_API void sfSound_Pause(sfSound* sound);
////////////////////////////////////////////////////////////
/// Stop playing a sound
///
/// \param Sound : Sound to stop
/// \param sound : Sound to stop
///
////////////////////////////////////////////////////////////
CSFML_API void sfSound_Stop(sfSound* Sound);
CSFML_API void sfSound_Stop(sfSound* sound);
////////////////////////////////////////////////////////////
/// Bind a sound buffer to a sound
///
/// \param Sound : Sound to set the loop state
/// \param Buffer : Buffer to bind
/// \param sound : Sound to set the loop state
/// \param buffer : Buffer to bind
///
////////////////////////////////////////////////////////////
CSFML_API void sfSound_SetBuffer(sfSound* Sound, sfSoundBuffer* Buffer);
CSFML_API void sfSound_SetBuffer(sfSound* sound, sfSoundBuffer* buffer);
////////////////////////////////////////////////////////////
/// Get the sound buffer bound to a sound
///
/// \param Sound : Sound to get the buffer from
/// \param sound : Sound to get the buffer from
///
/// \return Pointer to the sound's buffer
///
////////////////////////////////////////////////////////////
CSFML_API sfSoundBuffer* sfSound_GetBuffer(sfSound* Sound);
CSFML_API sfSoundBuffer* sfSound_GetBuffer(sfSound* sound);
////////////////////////////////////////////////////////////
/// Set a sound loop state
///
/// \param Sound : Sound to set the loop state
/// \param Loop : sfTrue to play in loop, sfFalse to play once
/// \param sound : Sound to set the loop state
/// \param loop : sfTrue to play in loop, sfFalse to play once
///
////////////////////////////////////////////////////////////
CSFML_API void sfSound_SetLoop(sfSound* Sound, sfBool Loop);
CSFML_API void sfSound_SetLoop(sfSound* sound, sfBool loop);
////////////////////////////////////////////////////////////
/// Tell whether or not a sound is looping
///
/// \param Sound : Sound to get the loop state from
/// \param sound : Sound to get the loop state from
///
/// \return sfTrue if the sound is looping, sfFalse otherwise
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfSound_GetLoop(sfSound* Sound);
CSFML_API sfBool sfSound_GetLoop(sfSound* sound);
////////////////////////////////////////////////////////////
/// Get the status of a sound (stopped, paused, playing)
///
/// \param Sound : Sound to get the status from
/// \param sound : Sound to get the status from
///
/// \return Current status of the sound
///
////////////////////////////////////////////////////////////
CSFML_API sfSoundStatus sfSound_GetStatus(sfSound* Sound);
CSFML_API sfSoundStatus sfSound_GetStatus(sfSound* sound);
////////////////////////////////////////////////////////////
/// Set the pitch of a sound
///
/// \param Sound : Sound to modify
/// \param Pitch : New pitch
/// \param sound : Sound to modify
/// \param pitch : New pitch
///
////////////////////////////////////////////////////////////
CSFML_API void sfSound_SetPitch(sfSound* Sound, float Pitch);
CSFML_API void sfSound_SetPitch(sfSound* sound, float pitch);
////////////////////////////////////////////////////////////
/// Set the volume of a sound
///
/// \param Sound : Sound to modify
/// \param Volume : Volume (in range [0, 100])
/// \param sound : Sound to modify
/// \param volume : Volume (in range [0, 100])
///
////////////////////////////////////////////////////////////
CSFML_API void sfSound_SetVolume(sfSound* Sound, float Volume);
CSFML_API void sfSound_SetVolume(sfSound* sound, float volume);
////////////////////////////////////////////////////////////
/// Set the position of a sound
///
/// \param Sound : Sound to modify
/// \param X : X position of the sound in the world
/// \param Y : Y position of the sound in the world
/// \param Z : Z position of the sound in the world
/// \param sound : Sound to modify
/// \param x : X position of the sound in the world
/// \param y : Y position of the sound in the world
/// \param z : Z position of the sound in the world
///
////////////////////////////////////////////////////////////
CSFML_API void sfSound_SetPosition(sfSound* Sound, float X, float Y, float Z);
CSFML_API void sfSound_SetPosition(sfSound* sound, float x, float y, float z);
////////////////////////////////////////////////////////////
/// Make the sound's position relative to the listener's
/// position, or absolute.
/// The default value is false (absolute)
///
/// \param Sound : Sound to modify
/// \param Relative : True to set the position relative, false to set it absolute
/// \param sound : Sound to modify
/// \param relative : True to set the position relative, false to set it absolute
///
////////////////////////////////////////////////////////////
CSFML_API void sfSound_SetRelativeToListener(sfSound* Sound, sfBool Relative);
CSFML_API void sfSound_SetRelativeToListener(sfSound* sound, sfBool relative);
////////////////////////////////////////////////////////////
/// Set the minimum distance - closer than this distance,
/// the listener will hear the sound at its maximum volume.
/// The default minimum distance is 1.0
///
/// \param Sound : Sound to modify
/// \param MinDistance : New minimum distance for the sound
/// \param sound : Sound to modify
/// \param distance : New minimum distance for the sound
///
////////////////////////////////////////////////////////////
CSFML_API void sfSound_SetMinDistance(sfSound* Sound, float MinDistance);
CSFML_API void sfSound_SetMinDistance(sfSound* sound, float distance);
////////////////////////////////////////////////////////////
/// Set the attenuation factor - the higher the attenuation, the
/// more the sound will be attenuated with distance from listener.
/// The default attenuation factor is 1.0
///
/// \param Sound : Sound to modify
/// \param Attenuation : New attenuation factor for the sound
/// \param sound : Sound to modify
/// \param attenuation : New attenuation factor for the sound
///
////////////////////////////////////////////////////////////
CSFML_API void sfSound_SetAttenuation(sfSound* Sound, float Attenuation);
CSFML_API void sfSound_SetAttenuation(sfSound* sound, float attenuation);
////////////////////////////////////////////////////////////
/// Set the current playing position of a sound
///
/// \param Sound : Sound to modify
/// \param TimeOffset : New playing position, expressed in seconds
/// \param sound : Sound to modify
/// \param timeOffset : New playing position, expressed in seconds
///
////////////////////////////////////////////////////////////
CSFML_API void sfSound_SetPlayingOffset(sfSound* Sound, float TimeOffset);
CSFML_API void sfSound_SetPlayingOffset(sfSound* sound, float timeOffset);
////////////////////////////////////////////////////////////
/// Get the pitch of a sound
///
/// \param Sound : Sound to get the pitch from
/// \param sound : Sound to get the pitch from
///
/// \return Pitch value
///
////////////////////////////////////////////////////////////
CSFML_API float sfSound_GetPitch(sfSound* Sound);
CSFML_API float sfSound_GetPitch(sfSound* sound);
////////////////////////////////////////////////////////////
/// Get the volume of a sound
///
/// \param Sound : Sound to get the volume from
/// \param sound : Sound to get the volume from
///
/// \return Volume value (in range [1, 100])
///
////////////////////////////////////////////////////////////
CSFML_API float sfSound_GetVolume(sfSound* Sound);
CSFML_API float sfSound_GetVolume(sfSound* sound);
////////////////////////////////////////////////////////////
/// Get the position of a sound
///
/// \param Sound : Sound to get the position from
/// \param X : X position of the sound in the world
/// \param Y : Y position of the sound in the world
/// \param Z : Z position of the sound in the world
/// \param sound : Sound to get the position from
/// \param x : X position of the sound in the world
/// \param y : Y position of the sound in the world
/// \param z : Z position of the sound in the world
///
////////////////////////////////////////////////////////////
CSFML_API void sfSound_GetPosition(sfSound* Sound, float* X, float* Y, float* Z);
CSFML_API void sfSound_GetPosition(sfSound* sound, float* x, float* y, float* z);
////////////////////////////////////////////////////////////
/// Tell if the sound's position is relative to the listener's
/// position, or if it's absolute
///
/// \param Sound : Sound to check
/// \param sound : Sound to check
///
/// \return sfTrue if the position is relative, sfFalse if it's absolute
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfSound_IsRelativeToListener(sfSound* Sound);
CSFML_API sfBool sfSound_IsRelativeToListener(sfSound* sound);
////////////////////////////////////////////////////////////
/// Get the minimum distance of a sound
///
/// \param Sound : Sound to get the minimum distance from
/// \param sound : Sound to get the minimum distance from
///
/// \return Minimum distance for the sound
///
////////////////////////////////////////////////////////////
CSFML_API float sfSound_GetMinDistance(sfSound* Sound);
CSFML_API float sfSound_GetMinDistance(sfSound* sound);
////////////////////////////////////////////////////////////
/// Get the attenuation factor of a sound
///
/// \param Sound : Sound to get the attenuation factor from
/// \param sound : Sound to get the attenuation factor from
///
/// \return Attenuation factor for the sound
///
////////////////////////////////////////////////////////////
CSFML_API float sfSound_GetAttenuation(sfSound* Sound);
CSFML_API float sfSound_GetAttenuation(sfSound* sound);
////////////////////////////////////////////////////////////
/// Get the current playing position of a sound
///
/// \param Sound : Sound to get the position from
/// \param sound : Sound to get the position from
///
/// \return Current playing position, expressed in seconds
///
////////////////////////////////////////////////////////////
CSFML_API float sfSound_GetPlayingOffset(sfSound* Sound);
CSFML_API float sfSound_GetPlayingOffset(sfSound* sound);
#endif // SFML_SOUND_H

50
CSFML/include/SFML/Audio/SoundBuffer.h
View File

@ -35,107 +35,107 @@
////////////////////////////////////////////////////////////
/// Create a new sound buffer and load it from a file
///
/// \param Filename : Path of the music file to open
/// \param filename : Path of the music file to open
///
/// \return A new sfSoundBuffer object (NULL if failed)
///
////////////////////////////////////////////////////////////
CSFML_API sfSoundBuffer* sfSoundBuffer_CreateFromFile(const char* Filename);
CSFML_API sfSoundBuffer* sfSoundBuffer_CreateFromFile(const char* filename);
////////////////////////////////////////////////////////////
/// Create a new sound buffer and load it from a file in memory
///
/// \param Data : Pointer to the file data in memory
/// \param SizeInBytes : Size of the data to load, in bytes
/// \param data : Pointer to the file data in memory
/// \param sizeInBytes : Size of the data to load, in bytes
///
/// \return A new sfSoundBuffer object (NULL if failed)
///
////////////////////////////////////////////////////////////
CSFML_API sfSoundBuffer* sfSoundBuffer_CreateFromMemory(const char* Data, size_t SizeInBytes);
CSFML_API sfSoundBuffer* sfSoundBuffer_CreateFromMemory(const char* data, size_t sizeInBytes);
////////////////////////////////////////////////////////////
/// Create a new sound buffer and load it from an array of
/// samples in memory - assumed format for samples is
/// 16 bits signed integer
///
/// \param Samples : Pointer to the samples in memory
/// \param SamplesCount : Number of samples pointed by Samples
/// \param ChannelsCount : Number of channels (1 = mono, 2 = stereo, ...)
/// \param SampleRate : Frequency (number of samples to play per second)
/// \param samples : Pointer to the samples in memory
/// \param samplesCount : Number of samples pointed by Samples
/// \param channelsCount : Number of channels (1 = mono, 2 = stereo, ...)
/// \param sampleRate : Frequency (number of samples to play per second)
///
/// \return A new sfSoundBuffer object (NULL if failed)
///
////////////////////////////////////////////////////////////
CSFML_API sfSoundBuffer* sfSoundBuffer_CreateFromSamples(const sfInt16* Samples, size_t SamplesCount, unsigned int ChannelsCount, unsigned int SampleRate);
CSFML_API sfSoundBuffer* sfSoundBuffer_CreateFromSamples(const sfInt16* samples, size_t samplesCount, unsigned int channelsCount, unsigned int sampleRate);
////////////////////////////////////////////////////////////
/// Destroy an existing sound buffer
///
/// \param SoundBuffer : Sound buffer to delete
/// \param soundBuffer : Sound buffer to delete
///
////////////////////////////////////////////////////////////
CSFML_API void sfSoundBuffer_Destroy(sfSoundBuffer* SoundBuffer);
CSFML_API void sfSoundBuffer_Destroy(sfSoundBuffer* soundBuffer);
////////////////////////////////////////////////////////////
/// Save a sound buffer to a file
///
/// \param SoundBuffer : Sound buffer to save
/// \param Filename : Path of the sound file to write
/// \param soundBuffer : Sound buffer to save
/// \param filename : Path of the sound file to write
///
/// \return sfTrue if saving has been successful
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfSoundBuffer_SaveToFile(sfSoundBuffer* SoundBuffer, const char* Filename);
CSFML_API sfBool sfSoundBuffer_SaveToFile(sfSoundBuffer* soundBuffer, const char* filename);
////////////////////////////////////////////////////////////
/// Return the samples contained in a sound buffer
///
/// \param SoundBuffer : Sound buffer to get samples from
/// \param soundBuffer : Sound buffer to get samples from
///
/// \return Pointer to the array of sound samples, in 16 bits signed integer format
///
////////////////////////////////////////////////////////////
CSFML_API const sfInt16* sfSoundBuffer_GetSamples(sfSoundBuffer* SoundBuffer);
CSFML_API const sfInt16* sfSoundBuffer_GetSamples(sfSoundBuffer* soundBuffer);
////////////////////////////////////////////////////////////
/// Return the number of samples contained in a sound buffer
///
/// \param SoundBuffer : Sound buffer to get samples count from
/// \param soundBuffer : Sound buffer to get samples count from
///
/// \return Number of samples
///
////////////////////////////////////////////////////////////
CSFML_API size_t sfSoundBuffer_GetSamplesCount(sfSoundBuffer* SoundBuffer);
CSFML_API size_t sfSoundBuffer_GetSamplesCount(sfSoundBuffer* soundBuffer);
////////////////////////////////////////////////////////////
/// Get the sample rate of a sound buffer
///
/// \param SoundBuffer : Sound buffer to get sample rate from
/// \param soundBuffer : Sound buffer to get sample rate from
///
/// \return Sound frequency (number of samples per second)
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfSoundBuffer_GetSampleRate(sfSoundBuffer* SoundBuffer);
CSFML_API unsigned int sfSoundBuffer_GetSampleRate(sfSoundBuffer* soundBuffer);
////////////////////////////////////////////////////////////
/// Return the number of channels of a sound buffer (1 = mono, 2 = stereo, ...)
///
/// \param SoundBuffer : Sound buffer to get channels count from
/// \param soundBuffer : Sound buffer to get channels count from
///
/// \return Number of channels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfSoundBuffer_GetChannelsCount(sfSoundBuffer* SoundBuffer);
CSFML_API unsigned int sfSoundBuffer_GetChannelsCount(sfSoundBuffer* soundBuffer);
////////////////////////////////////////////////////////////
/// Get the duration of a sound buffer
///
/// \param SoundBuffer : Sound buffer to get duration from
/// \param soundBuffer : Sound buffer to get duration from
///
/// \return Sound duration, in seconds
///
////////////////////////////////////////////////////////////
CSFML_API float sfSoundBuffer_GetDuration(sfSoundBuffer* SoundBuffer);
CSFML_API float sfSoundBuffer_GetDuration(sfSoundBuffer* soundBuffer);
#endif // SFML_SOUNDBUFFER_H

22
CSFML/include/SFML/Audio/SoundBufferRecorder.h
View File

@ -43,49 +43,49 @@ CSFML_API sfSoundBufferRecorder* sfSoundBufferRecorder_Create();
////////////////////////////////////////////////////////////
/// Destroy an existing sound buffer recorder
///
/// \param SoundBufferRecorder : Sound buffer recorder to delete
/// \param soundBufferRecorder : Sound buffer recorder to delete
///
////////////////////////////////////////////////////////////
CSFML_API void sfSoundBufferRecorder_Destroy(sfSoundBufferRecorder* SoundBufferRecorder);
CSFML_API void sfSoundBufferRecorder_Destroy(sfSoundBufferRecorder* soundBufferRecorder);
////////////////////////////////////////////////////////////
/// Start the capture.
/// Warning : only one capture can happen at the same time
///
/// \param SoundBufferRecorder : Sound bufferrecorder to start
/// \param SampleRate : Sound frequency (the more samples, the higher the quality)
/// \param soundBufferRecorder : Sound buffer recorder to start
/// \param sampleRate : Sound frequency (the more samples, the higher the quality)
///
////////////////////////////////////////////////////////////
CSFML_API void sfSoundBufferRecorder_Start(sfSoundBufferRecorder* SoundBufferRecorder, unsigned int SampleRate);
CSFML_API void sfSoundBufferRecorder_Start(sfSoundBufferRecorder* soundBufferRecorder, unsigned int sampleRate);
////////////////////////////////////////////////////////////
/// Stop the capture
///
/// \param SoundBufferRecorder : Sound buffer recorder to stop
/// \param soundBufferRecorder : Sound buffer recorder to stop
///
////////////////////////////////////////////////////////////
CSFML_API void sfSoundBufferRecorder_Stop(sfSoundBufferRecorder* SoundBufferRecorder);
CSFML_API void sfSoundBufferRecorder_Stop(sfSoundBufferRecorder* soundBufferRecorder);
////////////////////////////////////////////////////////////
/// Get the sample rate of a sound buffer recorder
///
/// \param SoundBufferRecorder : Sound buffer recorder to get sample rate from
/// \param soundBufferRecorder : Sound buffer recorder to get sample rate from
///
/// \return Frequency, in samples per second
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfSoundBufferRecorder_GetSampleRate(sfSoundBufferRecorder* SoundBufferRecorder);
CSFML_API unsigned int sfSoundBufferRecorder_GetSampleRate(sfSoundBufferRecorder* soundBufferRecorder);
////////////////////////////////////////////////////////////
/// Get the sound buffer containing the captured audio data
/// of a sound buffer recorder
///
/// \param SoundBufferRecorder : Sound buffer recorder to get the sound buffer from
/// \param soundBufferRecorder : Sound buffer recorder to get the sound buffer from
///
/// \return Pointer to the sound buffer (you don't need to destroy it after use)
///
////////////////////////////////////////////////////////////
CSFML_API sfSoundBuffer* sfSoundBufferRecorder_GetBuffer(sfSoundBufferRecorder* SoundBufferRecorder);
CSFML_API sfSoundBuffer* sfSoundBufferRecorder_GetBuffer(sfSoundBufferRecorder* soundBufferRecorder);
#endif // SFML_SOUNDBUFFERRECORDER_H

34
CSFML/include/SFML/Audio/SoundRecorder.h
View File

@ -41,54 +41,54 @@ typedef void (*sfSoundRecorderStopCallback)(void*);
/// Construct a new sound recorder with callback functions
/// for processing captured samples
///
/// \param OnStart : Callback function which will be called when a new capture starts (can be NULL)
/// \param OnProcess : Callback function which will be called each time there's audio data to process
/// \param OnStop : Callback function which will be called when the current capture stops (can be NULL)
/// \param UserData : Data to pass to the callback function (can be NULL)
/// \param onStart : Callback function which will be called when a new capture starts (can be NULL)
/// \param onProcess : Callback function which will be called each time there's audio data to process
/// \param onStop : Callback function which will be called when the current capture stops (can be NULL)
/// \param userData : Data to pass to the callback function (can be NULL)
///
/// \return A new sfSoundRecorder object (NULL if failed)
///
////////////////////////////////////////////////////////////
CSFML_API sfSoundRecorder* sfSoundRecorder_Create(sfSoundRecorderStartCallback OnStart,
sfSoundRecorderProcessCallback OnProcess,
sfSoundRecorderStopCallback OnStop,
void* UserData);
CSFML_API sfSoundRecorder* sfSoundRecorder_Create(sfSoundRecorderStartCallback onStart,
sfSoundRecorderProcessCallback onProcess,
sfSoundRecorderStopCallback onStop,
void* userData);
////////////////////////////////////////////////////////////
/// Destroy an existing sound recorder
///
/// \param SoundRecorder : Sound recorder to delete
/// \param soundRecorder : Sound recorder to delete
///
////////////////////////////////////////////////////////////
CSFML_API void sfSoundRecorder_Destroy(sfSoundRecorder* SoundRecorder);
CSFML_API void sfSoundRecorder_Destroy(sfSoundRecorder* soundRecorder);
////////////////////////////////////////////////////////////
/// Start the capture.
/// Warning : only one capture can happen at the same time
///
/// \param SoundRecorder : Sound recorder to start
/// \param SampleRate : Sound frequency (the more samples, the higher the quality)
/// \param soundRecorder : Sound recorder to start
/// \param sampleRate : Sound frequency (the more samples, the higher the quality)
///
////////////////////////////////////////////////////////////
CSFML_API void sfSoundRecorder_Start(sfSoundRecorder* SoundRecorder, unsigned int SampleRate);
CSFML_API void sfSoundRecorder_Start(sfSoundRecorder* soundRecorder, unsigned int sampleRate);
////////////////////////////////////////////////////////////
/// Stop the capture
///
/// \param SoundRecorder : Sound recorder to stop
/// \param soundRecorder : Sound recorder to stop
///
////////////////////////////////////////////////////////////
CSFML_API void sfSoundRecorder_Stop(sfSoundRecorder* SoundRecorder);
CSFML_API void sfSoundRecorder_Stop(sfSoundRecorder* soundRecorder);
////////////////////////////////////////////////////////////
/// Get the sample rate of a sound recorder
///
/// \param SoundRecorder : Sound recorder to get sample rate from
/// \param soundRecorder : Sound recorder to get sample rate from
///
/// \return Frequency, in samples per second
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfSoundRecorder_GetSampleRate(sfSoundRecorder* SoundRecorder);
CSFML_API unsigned int sfSoundRecorder_GetSampleRate(sfSoundRecorder* soundRecorder);
////////////////////////////////////////////////////////////
/// Tell if the system supports sound capture.

138
CSFML/include/SFML/Audio/SoundStream.h
View File

@ -50,245 +50,245 @@ typedef void (*sfSoundStreamSeekCallback)(float, void*); ///<
////////////////////////////////////////////////////////////
/// Construct a new sound stream
///
/// \param OnGetData : Function called when the stream needs more data (can't be NULL)
/// \param OnSeek : Function called when the stream seeks (can't be NULL)
/// \param ChannelsCount : Number of channels to use (1 = mono, 2 = stereo)
/// \param SampleRate : Sample rate of the sound (44100 = CD quality)
/// \param UserData : Data to pass to the callback functions
/// \param onGetData : Function called when the stream needs more data (can't be NULL)
/// \param onSeek : Function called when the stream seeks (can't be NULL)
/// \param channelsCount : Number of channels to use (1 = mono, 2 = stereo)
/// \param sampleRate : Sample rate of the sound (44100 = CD quality)
/// \param userData : Data to pass to the callback functions
///
/// \return A new sfSoundStream object (NULL if failed)
///
////////////////////////////////////////////////////////////
CSFML_API sfSoundStream* sfSoundStream_Create(sfSoundStreamGetDataCallback OnGetData,
sfSoundStreamSeekCallback OnSeek,
unsigned int ChannelsCount,
unsigned int SampleRate,
void* UserData);
CSFML_API sfSoundStream* sfSoundStream_Create(sfSoundStreamGetDataCallback onGetData,
sfSoundStreamSeekCallback onSeek,
unsigned int channelsCount,
unsigned int sampleRate,
void* userData);
////////////////////////////////////////////////////////////
/// Destroy an existing sound stream
///
/// \param SoundStream : Sound stream to delete
/// \param soundStream : Sound stream to delete
///
////////////////////////////////////////////////////////////
CSFML_API void sfSoundStream_Destroy(sfSoundStream* SoundStreamStream);
CSFML_API void sfSoundStream_Destroy(sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Start playing a sound stream
///
/// \param SoundStream : Sound stream to play
/// \param soundStream : Sound stream to play
///
////////////////////////////////////////////////////////////
CSFML_API void sfSoundStream_Play(sfSoundStream* SoundStream);
CSFML_API void sfSoundStream_Play(sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Pause a sound stream
///
/// \param SoundStream : Sound stream to pause
/// \param soundStream : Sound stream to pause
///
////////////////////////////////////////////////////////////
CSFML_API void sfSoundStream_Pause(sfSoundStream* SoundStream);
CSFML_API void sfSoundStream_Pause(sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Stop playing a sound stream
///
/// \param SoundStream : Sound stream to stop
/// \param soundStream : Sound stream to stop
///
////////////////////////////////////////////////////////////
CSFML_API void sfSoundStream_Stop(sfSoundStream* SoundStream);
CSFML_API void sfSoundStream_Stop(sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Get the status of a sound stream (stopped, paused, playing)
///
/// \param SoundStream : Sound stream to get the status from
/// \param soundStream : Sound stream to get the status from
///
/// \return Current status of the sound stream
///
////////////////////////////////////////////////////////////
CSFML_API sfSoundStatus sfSoundStream_GetStatus(sfSoundStream* SoundStream);
CSFML_API sfSoundStatus sfSoundStream_GetStatus(sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Return the number of channels of a sound stream
/// (1 = mono, 2 = stereo)
///
/// \param SoundStream : Sound stream to get the channels count from
/// \param soundStream : Sound stream to get the channels count from
///
/// \return Number of channels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfSoundStream_GetChannelsCount(sfSoundStream* SoundStream);
CSFML_API unsigned int sfSoundStream_GetChannelsCount(sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Get the sample rate of a sound stream
///
/// \param SoundStream : Sound stream to get the sample rate from
/// \param soundStream : Sound stream to get the sample rate from
///
/// \return Stream frequency (number of samples per second)
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfSoundStream_GetSampleRate(sfSoundStream* SoundStream);
CSFML_API unsigned int sfSoundStream_GetSampleRate(sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Set the pitch of a sound stream
///
/// \param SoundStream : Sound stream to modify
/// \param Pitch : New pitch
/// \param soundStream : Sound stream to modify
/// \param pitch : New pitch
///
////////////////////////////////////////////////////////////
CSFML_API void sfSoundStream_SetPitch(sfSoundStream* SoundStream, float Pitch);
CSFML_API void sfSoundStream_SetPitch(sfSoundStream* soundStream, float pitch);
////////////////////////////////////////////////////////////
/// Set the volume of a sound stream
///
/// \param SoundStream : Sound stream to modify
/// \param Volume : Volume (in range [0, 100])
/// \param soundStream : Sound stream to modify
/// \param volume : Volume (in range [0, 100])
///
////////////////////////////////////////////////////////////
CSFML_API void sfSoundStream_SetVolume(sfSoundStream* SoundStream, float Volume);
CSFML_API void sfSoundStream_SetVolume(sfSoundStream* soundStream, float volume);
////////////////////////////////////////////////////////////
/// Set the position of a sound stream
///
/// \param SoundStream : Sound stream to modify
/// \param X : X position of the sound stream in the world
/// \param Y : Y position of the sound stream in the world
/// \param Z : Z position of the sound stream in the world
/// \param soundStream : Sound stream to modify
/// \param x : X position of the sound stream in the world
/// \param y : Y position of the sound stream in the world
/// \param z : Z position of the sound stream in the world
///
////////////////////////////////////////////////////////////
CSFML_API void sfSoundStream_SetPosition(sfSoundStream* SoundStream, float X, float Y, float Z);
CSFML_API void sfSoundStream_SetPosition(sfSoundStream* soundStream, float x, float y, float z);
////////////////////////////////////////////////////////////
/// Make the sound stream's position relative to the listener's
/// position, or absolute.
/// The default value is false (absolute)
///
/// \param SoundStream : Sound stream to modify
/// \param Relative : True to set the position relative, false to set it absolute
/// \param soundStream : Sound stream to modify
/// \param relative : True to set the position relative, false to set it absolute
///
////////////////////////////////////////////////////////////
CSFML_API void sfSoundStream_SetRelativeToListener(sfSoundStream* SoundStream, sfBool Relative);
CSFML_API void sfSoundStream_SetRelativeToListener(sfSoundStream* soundStream, sfBool relative);
////////////////////////////////////////////////////////////
/// Set the minimum distance - closer than this distance,
/// the listener will hear the sound stream at its maximum volume.
/// The default minimum distance is 1.0
///
/// \param SoundStream : Sound stream to modify
/// \param MinDistance : New minimum distance for the sound stream
/// \param soundStream : Sound stream to modify
/// \param distance : New minimum distance for the sound stream
///
////////////////////////////////////////////////////////////
CSFML_API void sfSoundStream_SetMinDistance(sfSoundStream* SoundStream, float MinDistance);
CSFML_API void sfSoundStream_SetMinDistance(sfSoundStream* soundStream, float distance);
////////////////////////////////////////////////////////////
/// Set the attenuation factor - the higher the attenuation, the
/// more the sound stream will be attenuated with distance from listener.
/// The default attenuation factor 1.0
///
/// \param SoundStream : Sound stream to modify
/// \param Attenuation : New attenuation factor for the sound stream
/// \param soundStream : Sound stream to modify
/// \param attenuation : New attenuation factor for the sound stream
///
////////////////////////////////////////////////////////////
CSFML_API void sfSoundStream_SetAttenuation(sfSoundStream* SoundStream, float Attenuation);
CSFML_API void sfSoundStream_SetAttenuation(sfSoundStream* soundStream, float attenuation);
////////////////////////////////////////////////////////////
/// Set the current playing position of a stream
///
/// \param SoundStream : Sound stream to modify
/// \param TimeOffset : New playing position, expressed in seconds
/// \param soundStream : Sound stream to modify
/// \param timeOffset : New playing position, expressed in seconds
///
////////////////////////////////////////////////////////////
CSFML_API void sfSoundStream_SetPlayingOffset(sfSoundStream* SoundStream, float TimeOffset);
CSFML_API void sfSoundStream_SetPlayingOffset(sfSoundStream* soundStream, float timeOffset);
////////////////////////////////////////////////////////////
/// Set a stream loop state
///
/// \param SoundStream : Stream to set the loop state
/// \param Loop : sfTrue to play in loop, sfFalse to play once
/// \param soundStream : Stream to set the loop state
/// \param loop : sfTrue to play in loop, sfFalse to play once
///
////////////////////////////////////////////////////////////
CSFML_API void sfSoundStream_SetLoop(sfSoundStream* SoundStream, sfBool Loop);
CSFML_API void sfSoundStream_SetLoop(sfSoundStream* soundStream, sfBool loop);
////////////////////////////////////////////////////////////
/// Get the pitch of a sound stream
///
/// \param SoundStream : Sound stream to get the pitch from
/// \param soundStream : Sound stream to get the pitch from
///
/// \return Pitch value
///
////////////////////////////////////////////////////////////
CSFML_API float sfSoundStream_GetPitch(sfSoundStream* SoundStream);
CSFML_API float sfSoundStream_GetPitch(sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Get the volume of a sound stream
///
/// \param SoundStream : Sound stream to get the volume from
/// \param soundStream : Sound stream to get the volume from
///
/// \return Volume value (in range [1, 100])
///
////////////////////////////////////////////////////////////
CSFML_API float sfSoundStream_GetVolume(sfSoundStream* SoundStream);
CSFML_API float sfSoundStream_GetVolume(sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Get the position of a sound stream
///
/// \param SoundStream : Sound stream to get the position from
/// \param X : X position of the sound stream in the world
/// \param Y : Y position of the sound stream in the world
/// \param Z : Z position of the sound stream in the world
/// \param soundStream : Sound stream to get the position from
/// \param x : X position of the sound stream in the world
/// \param y : Y position of the sound stream in the world
/// \param z : Z position of the sound stream in the world
///
////////////////////////////////////////////////////////////
CSFML_API void sfSoundStream_GetPosition(sfSoundStream* SoundStream, float* X, float* Y, float* Z);
CSFML_API void sfSoundStream_GetPosition(sfSoundStream* soundStream, float* x, float* y, float* z);
////////////////////////////////////////////////////////////
/// Tell if the sound stream's position is relative to the listener's
/// position, or if it's absolute
///
/// \param SoundStream : Sound stream to check
/// \param soundStream : Sound stream to check
///
/// \return sfTrue if the position is relative, sfFalse if it's absolute
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfSoundStream_IsRelativeToListener(sfSoundStream* SoundStream);
CSFML_API sfBool sfSoundStream_IsRelativeToListener(sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Get the minimum distance of a sound stream
///
/// \param SoundStream : Sound stream to get the minimum distance from
/// \param soundStream : Sound stream to get the minimum distance from
///
/// \return Minimum distance for the sound stream
///
////////////////////////////////////////////////////////////
CSFML_API float sfSoundStream_GetMinDistance(sfSoundStream* SoundStream);
CSFML_API float sfSoundStream_GetMinDistance(sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Get the attenuation factor of a sound stream
///
/// \param SoundStream : Sound stream to get the attenuation factor from
/// \param soundStream : Sound stream to get the attenuation factor from
///
/// \return Attenuation factor for the sound stream
///
////////////////////////////////////////////////////////////
CSFML_API float sfSoundStream_GetAttenuation(sfSoundStream* SoundStream);
CSFML_API float sfSoundStream_GetAttenuation(sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Tell whether or not a stream is looping
///
/// \param SoundStream : Soundstream to get the loop state from
/// \param soundStream : Soundstream to get the loop state from
///
/// \return sfTrue if the stream is looping, sfFalse otherwise
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfSoundStream_GetLoop(sfSoundStream* SoundStream);
CSFML_API sfBool sfSoundStream_GetLoop(sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Get the current playing position of a sound stream
///
/// \param SoundStream : Sound stream to get the position from
/// \param soundStream : Sound stream to get the position from
///
/// \return Current playing position, expressed in seconds
///
////////////////////////////////////////////////////////////
CSFML_API float sfSoundStream_GetPlayingOffset(sfSoundStream* SoundStream);
CSFML_API float sfSoundStream_GetPlayingOffset(sfSoundStream* soundStream);
#endif // SFML_SOUNDSTREAM_H

30
CSFML/include/SFML/Graphics/Color.h
View File

@ -59,49 +59,49 @@ CSFML_API sfColor sfCyan;
////////////////////////////////////////////////////////////
/// Construct a color from its 3 RGB components
///
/// \param R : Red component (0 .. 255)
/// \param G : Green component (0 .. 255)
/// \param B : Blue component (0 .. 255)
/// \param red : Red component (0 .. 255)
/// \param green : Green component (0 .. 255)
/// \param blue : Blue component (0 .. 255)
///
/// \return sfColor constructed from the components
///
////////////////////////////////////////////////////////////
CSFML_API sfColor sfColor_FromRGB(sfUint8 R, sfUint8 G, sfUint8 B);
CSFML_API sfColor sfColor_FromRGB(sfUint8 red, sfUint8 green, sfUint8 blue);
////////////////////////////////////////////////////////////
/// Construct a color from its 4 RGBA components
///
/// \param R : Red component (0 .. 255)
/// \param G : Green component (0 .. 255)
/// \param B : Blue component (0 .. 255)
/// \param A : Alpha component (0 .. 255)
/// \param red : Red component (0 .. 255)
/// \param green : Green component (0 .. 255)
/// \param blue : Blue component (0 .. 255)
/// \param alpha : Alpha component (0 .. 255)
///
/// \return sfColor constructed from the components
///
////////////////////////////////////////////////////////////
CSFML_API sfColor sfColor_FromRGBA(sfUint8 R, sfUint8 G, sfUint8 B, sfUint8 A);
CSFML_API sfColor sfColor_FromRGBA(sfUint8 red, sfUint8 green, sfUint8 blue, sfUint8 alpha);
////////////////////////////////////////////////////////////
/// Add two colors
///
/// \param Color1 : First color
/// \param Color2 : Second color
/// \param color1 : First color
/// \param color2 : Second color
///
/// \return Component-wise saturated addition of the two colors
///
////////////////////////////////////////////////////////////
CSFML_API sfColor sfColor_Add(sfColor Color1, sfColor Color2);
CSFML_API sfColor sfColor_Add(sfColor color1, sfColor color2);
////////////////////////////////////////////////////////////
/// Modulate two colors
///
/// \param Color1 : First color
/// \param Color2 : Second color
/// \param color1 : First color
/// \param color2 : Second color
///
/// \return Component-wise multiplication of the two colors
///
////////////////////////////////////////////////////////////
CSFML_API sfColor sfColor_Modulate(sfColor Color1, sfColor Color2);
CSFML_API sfColor sfColor_Modulate(sfColor color1, sfColor color2);
#endif // SFML_COLOR_H

26
CSFML/include/SFML/Graphics/Font.h
View File

@ -43,46 +43,46 @@ CSFML_API sfFont* sfFont_Create();
////////////////////////////////////////////////////////////
/// Create a new font from a file
///
/// \param Filename : Path of the font file to load
/// \param CharSize : Size of characters in bitmap - the bigger, the higher quality
/// \param Charset : Characters set to generate (just pass NULL to get the default charset)
/// \param filename : Path of the font file to load
/// \param charSize : Size of characters in bitmap - the bigger, the higher quality
/// \param charset : Characters set to generate (just pass NULL to get the default charset)
///
/// \return A new sfFont object, or NULL if it failed
///
////////////////////////////////////////////////////////////
CSFML_API sfFont* sfFont_CreateFromFile(const char* Filename, unsigned int CharSize, const sfUint32* Charset);
CSFML_API sfFont* sfFont_CreateFromFile(const char* filename, unsigned int charSize, const sfUint32* charset);
////////////////////////////////////////////////////////////
/// Create a new image font a file in memory
///
/// \param Data : Pointer to the file data in memory
/// \param SizeInBytes : Size of the data to load, in bytes
/// \param CharSize : Size of characters in bitmap - the bigger, the higher quality
/// \param Charset : Characters set to generate (just pass NULL to get the default charset)
/// \param data : Pointer to the file data in memory
/// \param sizeInBytes : Size of the data to load, in bytes
/// \param charSize : Size of characters in bitmap - the bigger, the higher quality
/// \param charset : Characters set to generate (just pass NULL to get the default charset)
///
/// \return A new sfFont object, or NULL if it failed
///
////////////////////////////////////////////////////////////
CSFML_API sfFont* sfFont_CreateFromMemory(const char* Data, size_t SizeInBytes, unsigned int CharSize, const sfUint32* Charset);
CSFML_API sfFont* sfFont_CreateFromMemory(const char* data, size_t sizeInBytes, unsigned int charSize, const sfUint32* charset);
////////////////////////////////////////////////////////////
/// Destroy an existing font
///
/// \param Font : Font to delete
/// \param font : Font to delete
///
////////////////////////////////////////////////////////////
CSFML_API void sfFont_Destroy(sfFont* Font);
CSFML_API void sfFont_Destroy(sfFont* font);
////////////////////////////////////////////////////////////
/// Get the base size of characters in a font;
/// All glyphs dimensions are based on this value
///
/// \param Font : Font object
/// \param font : Font object
///
/// \return Base size of characters
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfFont_GetCharacterSize(sfFont* Font);
CSFML_API unsigned int sfFont_GetCharacterSize(sfFont* font);
////////////////////////////////////////////////////////////
/// Get the built-in default font (Arial)

108
CSFML/include/SFML/Graphics/Image.h
View File

@ -45,186 +45,186 @@ CSFML_API sfImage* sfImage_Create();
////////////////////////////////////////////////////////////
/// Create a new image filled with a color
///
/// \param Width : Image width
/// \param Height : Image height
/// \param Col : Image color
/// \param width : Image width
/// \param height : Image height
/// \param color : Image color
///
/// \return A new sfImage object, or NULL if it failed
///
////////////////////////////////////////////////////////////
CSFML_API sfImage* sfImage_CreateFromColor(unsigned int Width, unsigned int Height, sfColor Color);
CSFML_API sfImage* sfImage_CreateFromColor(unsigned int width, unsigned int height, sfColor color);
////////////////////////////////////////////////////////////
/// Create a new image from an array of pixels in memory
///
/// \param Width : Image width
/// \param Height : Image height
/// \param Data : Pointer to the pixels in memory (assumed format is RGBA)
/// \param width : Image width
/// \param height : Image height
/// \param data : Pointer to the pixels in memory (assumed format is RGBA)
///
/// \return A new sfImage object, or NULL if it failed
///
////////////////////////////////////////////////////////////
CSFML_API sfImage* sfImage_CreateFromPixels(unsigned int Width, unsigned int Height, const sfUint8* Data);
CSFML_API sfImage* sfImage_CreateFromPixels(unsigned int width, unsigned int height, const sfUint8* data);
////////////////////////////////////////////////////////////
/// Create a new image from a file
///
/// \param Filename : Path of the image file to load
/// \param filename : Path of the image file to load
///
/// \return A new sfImage object, or NULL if it failed
///
////////////////////////////////////////////////////////////
CSFML_API sfImage* sfImage_CreateFromFile(const char* Filename);
CSFML_API sfImage* sfImage_CreateFromFile(const char* filename);
////////////////////////////////////////////////////////////
/// Create a new image from a file in memory
///
/// \param Data : Pointer to the file data in memory
/// \param SizeInBytes : Size of the data to load, in bytes
/// \param data : Pointer to the file data in memory
/// \param sizeInBytes : Size of the data to load, in bytes
///
/// \return A new sfImage object, or NULL if it failed
///
////////////////////////////////////////////////////////////
CSFML_API sfImage* sfImage_CreateFromMemory(const char* Data, size_t SizeInBytes);
CSFML_API sfImage* sfImage_CreateFromMemory(const char* data, size_t sizeInBytes);
////////////////////////////////////////////////////////////
/// Destroy an existing image
///
/// \param Image : Image to delete
/// \param image : Image to delete
///
////////////////////////////////////////////////////////////
CSFML_API void sfImage_Destroy(sfImage* Image);
CSFML_API void sfImage_Destroy(sfImage* image);
////////////////////////////////////////////////////////////
/// Save the content of an image to a file
///
/// \param Image : Image to save
/// \param Filename : Path of the file to save (overwritten if already exist)
/// \param image : Image to save
/// \param filename : Path of the file to save (overwritten if already exist)
///
/// \return sfTrue if saving was successful
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfImage_SaveToFile(sfImage* Image, const char* Filename);
CSFML_API sfBool sfImage_SaveToFile(sfImage* image, const char* filename);
////////////////////////////////////////////////////////////
/// Create a transparency mask for an image from a specified colorkey
///
/// \param Image : Image to modify
/// \param ColorKey : Color to become transparent
/// \param Alpha : Alpha value to use for transparent pixels
/// \param image : Image to modify
/// \param colorKey : Color to become transparent
/// \param alpha : Alpha value to use for transparent pixels
///
////////////////////////////////////////////////////////////
CSFML_API void sfImage_CreateMaskFromColor(sfImage* Image, sfColor ColorKey, sfUint8 Alpha);
CSFML_API void sfImage_CreateMaskFromColor(sfImage* image, sfColor colorKey, sfUint8 alpha);
////////////////////////////////////////////////////////////
/// Copy pixels from another image onto this one.
/// This function does a slow pixel copy and should only
/// be used at initialization time
///
/// \param Image : Destination image
/// \param Source : Source image to copy
/// \param DestX : X coordinate of the destination position
/// \param DestY : Y coordinate of the destination position
/// \param SourceRect : Sub-rectangle of the source image to copy
/// \param image : Destination image
/// \param source : Source image to copy
/// \param destX : X coordinate of the destination position
/// \param destY : Y coordinate of the destination position
/// \param sourceRect : Sub-rectangle of the source image to copy
///
////////////////////////////////////////////////////////////
CSFML_API void sfImage_Copy(sfImage* Image, sfImage* Source, unsigned int DestX, unsigned int DestY, sfIntRect SourceRect);
CSFML_API void sfImage_Copy(sfImage* image, sfImage* source, unsigned int destX, unsigned int destY, sfIntRect sourceRect);
////////////////////////////////////////////////////////////
/// Create the image from the current contents of the
/// given window
///
/// \param Image : Destination image
/// \param Window : Window to capture
/// \param SourceRect : Sub-rectangle of the screen to copy (empty by default - entire image)
/// \param image : Destination image
/// \param window : Window to capture
/// \param sourceRect : Sub-rectangle of the screen to copy (empty by default - entire image)
///
/// \return True if creation was successful
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfImage_CopyScreen(sfImage* Image, sfRenderWindow* Window, sfIntRect SourceRect);
CSFML_API sfBool sfImage_CopyScreen(sfImage* image, sfRenderWindow* window, sfIntRect sourceRect);
////////////////////////////////////////////////////////////
/// Change the color of a pixel of an image
/// Don't forget to call Update when you end modifying pixels
///
/// \param Image : Image to modify
/// \param X : X coordinate of pixel in the image
/// \param Y : Y coordinate of pixel in the image
/// \param Col : New color for pixel (X, Y)
/// \param image : Image to modify
/// \param x : X coordinate of pixel in the image
/// \param y : Y coordinate of pixel in the image
/// \param color : New color for pixel (X, Y)
///
////////////////////////////////////////////////////////////
CSFML_API void sfImage_SetPixel(sfImage* Image, unsigned int X, unsigned int Y, sfColor Color);
CSFML_API void sfImage_SetPixel(sfImage* image, unsigned int x, unsigned int y, sfColor color);
////////////////////////////////////////////////////////////
/// Get a pixel from an image
///
/// \param Image : Image to read
/// \param X : X coordinate of pixel in the image
/// \param Y : Y coordinate of pixel in the image
/// \param image : Image to read
/// \param x : X coordinate of pixel in the image
/// \param y : Y coordinate of pixel in the image
///
/// \return Color of pixel (x, y)
///
////////////////////////////////////////////////////////////
CSFML_API sfColor sfImage_GetPixel(sfImage* Image, unsigned int X, unsigned int Y);
CSFML_API sfColor sfImage_GetPixel(sfImage* image, unsigned int x, unsigned int y);
////////////////////////////////////////////////////////////
/// Get a read-only pointer to the array of pixels of an image (8 bits integers RGBA)
/// Array size is sfImage_GetWidth() x sfImage_GetHeight() x 4
/// This pointer becomes invalid if you reload or resize the image
///
/// \param Image : Image to read
/// \param image : Image to read
///
/// \return Pointer to the array of pixels
///
////////////////////////////////////////////////////////////
CSFML_API const sfUint8* sfImage_GetPixelsPtr(sfImage* Image);
CSFML_API const sfUint8* sfImage_GetPixelsPtr(sfImage* image);
////////////////////////////////////////////////////////////
/// Bind the image for rendering
///
/// \param Image : Image to bind
/// \param image : Image to bind
///
////////////////////////////////////////////////////////////
CSFML_API void sfImage_Bind(sfImage* Image);
CSFML_API void sfImage_Bind(sfImage* image);
////////////////////////////////////////////////////////////
/// Enable or disable image smooth filter
///
/// \param Image : Image to modify
/// \param Smooth : sfTrue to enable smoothing filter, false to disable it
/// \param image : Image to modify
/// \param smooth : sfTrue to enable smoothing filter, false to disable it
///
////////////////////////////////////////////////////////////
CSFML_API void sfImage_SetSmooth(sfImage* Image, sfBool Smooth);
CSFML_API void sfImage_SetSmooth(sfImage* image, sfBool smooth);
////////////////////////////////////////////////////////////
/// Return the width of the image
///
/// \param Image : Image to read
/// \param image : Image to read
///
/// \return Width in pixels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfImage_GetWidth(sfImage* Image);
CSFML_API unsigned int sfImage_GetWidth(sfImage* image);
////////////////////////////////////////////////////////////
/// Return the height of the image
///
/// \param Image : Image to read
/// \param image : Image to read
///
/// \return Height in pixels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfImage_GetHeight(sfImage* Image);
CSFML_API unsigned int sfImage_GetHeight(sfImage* image);
////////////////////////////////////////////////////////////
/// Tells whether the smoothing filter is enabled or not on an image
///
/// \param Image : Image to read
/// \param image : Image to read
///
/// \return sfTrue if the smoothing filter is enabled
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfImage_IsSmooth(sfImage* Image);
CSFML_API sfBool sfImage_IsSmooth(sfImage* image);
#endif // SFML_IMAGE_H

50
CSFML/include/SFML/Graphics/PostFX.h
View File

@ -35,7 +35,7 @@
////////////////////////////////////////////////////////////
/// Create a new post-fx from a file
///
/// \param Filename : File to load
/// \param filename : File to load
///
/// \return A new sfPostFX object, or NULL if it failed
///
@ -45,70 +45,70 @@ CSFML_API sfPostFX* sfPostFX_CreateFromFile(const char* Filename);
////////////////////////////////////////////////////////////
/// Create a new post-fx from an effect source code
///
/// \param Effect : Source code of the effect
/// \param effect : Source code of the effect
///
/// \return A new sfPostFX object, or NULL if it failed
///
////////////////////////////////////////////////////////////
CSFML_API sfPostFX* sfPostFX_CreateFromMemory(const char* Effect);
CSFML_API sfPostFX* sfPostFX_CreateFromMemory(const char* effect);
////////////////////////////////////////////////////////////
/// Destroy an existing post-fx
///
/// \param PostFX : PostFX to delete
/// \param postFX : PostFX to delete
///
////////////////////////////////////////////////////////////
CSFML_API void sfPostFX_Destroy(sfPostFX* PostFX);
CSFML_API void sfPostFX_Destroy(sfPostFX* postFX);
////////////////////////////////////////////////////////////
/// Change a parameter of a post-fx (1 float)
///
/// \param PostFX : Post-effect to modify
/// \param Name : Parameter name in the effect
/// \param X : Value to assign
/// \param postFX : Post-effect to modify
/// \param name : Parameter name in the effect
/// \param x : Value to assign
///
////////////////////////////////////////////////////////////
CSFML_API void sfPostFX_SetParameter1(sfPostFX* PostFX, const char* Name, float X);
CSFML_API void sfPostFX_SetParameter1(sfPostFX* postFX, const char* name, float x);
////////////////////////////////////////////////////////////
/// Change a parameter of a post-fx (2 floats)
///
/// \param PostFX : Post-effect to modify
/// \param Name : Parameter name in the effect
/// \param X, Y : Values to assign
/// \param postFX : Post-effect to modify
/// \param name : Parameter name in the effect
/// \param x, y : Values to assign
///
////////////////////////////////////////////////////////////
CSFML_API void sfPostFX_SetParameter2(sfPostFX* PostFX, const char* Name, float X, float Y);
CSFML_API void sfPostFX_SetParameter2(sfPostFX* postFX, const char* name, float x, float y);
////////////////////////////////////////////////////////////
/// Change a parameter of a post-fx (3 floats)
///
/// \param PostFX : Post-effect to modify
/// \param Name : Parameter name in the effect
/// \param X, Y, Z : Values to assign
/// \param postFX : Post-effect to modify
/// \param name : Parameter name in the effect
/// \param x, y, z : Values to assign
///
////////////////////////////////////////////////////////////
CSFML_API void sfPostFX_SetParameter3(sfPostFX* PostFX, const char* Name, float X, float Y, float Z);
CSFML_API void sfPostFX_SetParameter3(sfPostFX* postFX, const char* name, float x, float y, float z);
////////////////////////////////////////////////////////////
/// Change a parameter of a post-fx (4 floats)
///
/// \param PostFX : Post-effect to modify
/// \param Name : Parameter name in the effect
/// \param X, Y, Z, W : Values to assign
/// \param postFX : Post-effect to modify
/// \param name : Parameter name in the effect
/// \param x, y, z, w : Values to assign
///
////////////////////////////////////////////////////////////
CSFML_API void sfPostFX_SetParameter4(sfPostFX* PostFX, const char* Name, float X, float Y, float Z, float W);
CSFML_API void sfPostFX_SetParameter4(sfPostFX* postFX, const char* name, float x, float y, float z, float w);
////////////////////////////////////////////////////////////
/// Set a texture parameter in a post-fx
///
/// \param PostFX : Post-effect to modify
/// \param Name : Texture name in the effect
/// \param Texture : Image to set (pass NULL to use content of current framebuffer)
/// \param postFX : Post-effect to modify
/// \param name : Texture name in the effect
/// \param texture : Image to set (pass NULL to use content of current framebuffer)
///
////////////////////////////////////////////////////////////
CSFML_API void sfPostFX_SetTexture(sfPostFX* PostFX, const char* Name, sfImage* Texture);
CSFML_API void sfPostFX_SetTexture(sfPostFX* postFX, const char* name, sfImage* texture);
////////////////////////////////////////////////////////////
/// Tell whether or not the system supports post-effects

30
CSFML/include/SFML/Graphics/Rect.h
View File

@ -55,39 +55,39 @@ typedef struct
////////////////////////////////////////////////////////////
/// Move a rectangle by the given offset
///
/// \param Rect : Rectangle to move
/// \param OffsetX : Horizontal offset
/// \param OffsetY : Vertical offset
/// \param rect : Rectangle to move
/// \param offsetX : Horizontal offset
/// \param offsetY : Vertical offset
///
////////////////////////////////////////////////////////////
CSFML_API void sfFloatRect_Offset(sfFloatRect* Rect, float OffsetX, float OffsetY);
CSFML_API void sfIntRect_Offset(sfIntRect* Rect, int OffsetX, int OffsetY);
CSFML_API void sfFloatRect_Offset(sfFloatRect* rect, float offsetX, float offsetY);
CSFML_API void sfIntRect_Offset(sfIntRect* rect, int offsetX, int offsetY);
////////////////////////////////////////////////////////////
/// Check if a point is inside a rectangle's area
///
/// \param Rect : Rectangle to test
/// \param X : X coordinate of the point to test
/// \param Y : Y coordinate of the point to test
/// \param rect : Rectangle to test
/// \param x : X coordinate of the point to test
/// \param y : Y coordinate of the point to test
///
/// \return sfTrue if the point is inside
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfFloatRect_Contains(sfFloatRect* Rect, float X, float Y);
CSFML_API sfBool sfIntRect_Contains(sfIntRect* Rect, int X, int Y);
CSFML_API sfBool sfFloatRect_Contains(sfFloatRect* rect, float x, float y);
CSFML_API sfBool sfIntRect_Contains(sfIntRect* rect, int x, int y);
////////////////////////////////////////////////////////////
/// Check intersection between two rectangles
///
/// \param Rect1 : First rectangle to test
/// \param Rect2 : Second rectangle to test
/// \param OverlappingRect : Rectangle to be filled with overlapping rect (can be NULL)
/// \param rect1 : First rectangle to test
/// \param rect2 : Second rectangle to test
/// \param intersection : Rectangle to be filled with overlapping rect (can be NULL)
///
/// \return sfTrue if rectangles overlap
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfFloatRect_Intersects(sfFloatRect* Rect1, sfFloatRect* Rect2, sfFloatRect* OverlappingRect);
CSFML_API sfBool sfIntRect_Intersects(sfIntRect* Rect1, sfIntRect* Rect2, sfIntRect* OverlappingRect);
CSFML_API sfBool sfFloatRect_Intersects(sfFloatRect* rect1, sfFloatRect* rect2, sfFloatRect* intersection);
CSFML_API sfBool sfIntRect_Intersects(sfIntRect* rect1, sfIntRect* rect2, sfIntRect* intersection);
#endif // SFML_RECT_H

68
CSFML/include/SFML/Graphics/RenderImage.h
View File

@ -37,101 +37,101 @@
////////////////////////////////////////////////////////////
/// Construct a new renderimage
///
/// \param Width : Width of the renderimage
/// \param Height : Height of the renderimage
/// \param DepthBuffer : Do you want a depth-buffer attached? (useful only if you're doing 3D OpenGL on the renderimage)
/// \param width : Width of the renderimage
/// \param height : Height of the renderimage
/// \param depthBuffer : Do you want a depth-buffer attached? (useful only if you're doing 3D OpenGL on the renderimage)
///
////////////////////////////////////////////////////////////
CSFML_API sfRenderImage* sfRenderImage_Create(unsigned int Width, unsigned int Height, sfBool DepthBuffer);
CSFML_API sfRenderImage* sfRenderImage_Create(unsigned int width, unsigned int height, sfBool depthBuffer);
////////////////////////////////////////////////////////////
/// Destroy an existing renderimage
///
/// \param RenderImage : renderimage to destroy
/// \param renderImage : renderimage to destroy
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderImage_Destroy(sfRenderImage* RenderImage);
CSFML_API void sfRenderImage_Destroy(sfRenderImage* renderImage);
////////////////////////////////////////////////////////////
/// Get the width of the rendering region of a renderimage
///
/// \param RenderImage : Renderimage object
/// \param renderImage : Renderimage object
///
/// \return Width in pixels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfRenderImage_GetWidth(sfRenderImage* RenderImage);
CSFML_API unsigned int sfRenderImage_GetWidth(sfRenderImage* renderImage);
////////////////////////////////////////////////////////////
/// Get the height of the rendering region of a renderimage
///
/// \param RenderImage : Renderimage object
/// \param renderImage : Renderimage object
///
/// \return Height in pixels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfRenderImage_GetHeight(sfRenderImage* RenderImage);
CSFML_API unsigned int sfRenderImage_GetHeight(sfRenderImage* renderImage);
////////////////////////////////////////////////////////////
/// Activate or deactivate a renderimage as the current target for rendering
///
/// \param RenderImage : Renderimage object
/// \param Active : sfTrue to activate, sfFalse to deactivate
/// \param renderImage : Renderimage object
/// \param active : sfTrue to activate, sfFalse to deactivate
///
/// \return True if operation was successful, false otherwise
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfRenderImage_SetActive(sfRenderImage* RenderImage, sfBool Active);
CSFML_API sfBool sfRenderImage_SetActive(sfRenderImage* renderImage, sfBool active);
////////////////////////////////////////////////////////////
/// Draw something on a renderimage
///
/// \param RenderImage : Renderimage to draw in
/// \param PostFX / Sprite / String / shape : Object to draw
/// \param renderImage : Renderimage to draw in
/// \param postFX / sprite / string / shape : Object to draw
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderImage_DrawPostFX(sfRenderImage* RenderImage, sfPostFX* PostFX);
CSFML_API void sfRenderImage_DrawSprite(sfRenderImage* RenderImage, sfSprite* Sprite);
CSFML_API void sfRenderImage_DrawShape (sfRenderImage* RenderImage, sfShape* Shape);
CSFML_API void sfRenderImage_DrawString(sfRenderImage* RenderImage, sfString* String);
CSFML_API void sfRenderImage_DrawPostFX(sfRenderImage* renderImage, sfPostFX* postFX);
CSFML_API void sfRenderImage_DrawSprite(sfRenderImage* renderImage, sfSprite* sprite);
CSFML_API void sfRenderImage_DrawShape (sfRenderImage* renderImage, sfShape* shape);
CSFML_API void sfRenderImage_DrawString(sfRenderImage* renderImage, sfString* string);
////////////////////////////////////////////////////////////
/// Clear the renderimage with the given color
///
/// \param RenderImage : Renderimage to modify
/// \param Color : Fill color
/// \param renderImage : Renderimage to modify
/// \param color : Fill color
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderImage_Clear(sfRenderImage* RenderImage, sfColor Color);
CSFML_API void sfRenderImage_Clear(sfRenderImage* renderImage, sfColor color);
////////////////////////////////////////////////////////////
/// Change the current active view of a renderimage
///
/// \param RenderImage : Renderimage to modify
/// \param NewView : Pointer to the new view
/// \param renderImage : Renderimage to modify
/// \param view : Pointer to the new view
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderImage_SetView(sfRenderImage* RenderImage, sfView* View);
CSFML_API void sfRenderImage_SetView(sfRenderImage* renderImage, sfView* view);
////////////////////////////////////////////////////////////
/// Get the current active view of a renderimage
///
/// \param RenderImage : Renderimage
/// \param renderImage : Renderimage
///
/// \return Current active view
///
////////////////////////////////////////////////////////////
CSFML_API const sfView* sfRenderImage_GetView(sfRenderImage* RenderImage);
CSFML_API const sfView* sfRenderImage_GetView(sfRenderImage* renderImage);
////////////////////////////////////////////////////////////
/// Get the default view of a renderimage
///
/// \param RenderImage : Renderimage
/// \param renderImage : Renderimage
///
/// \return Default view of the renderimage
///
////////////////////////////////////////////////////////////
CSFML_API sfView* sfRenderImage_GetDefaultView(sfRenderImage* RenderImage);
CSFML_API sfView* sfRenderImage_GetDefaultView(sfRenderImage* renderImage);
////////////////////////////////////////////////////////////
/// Tell SFML to preserve external OpenGL states, at the expense of
@ -141,21 +141,21 @@ CSFML_API sfView* sfRenderImage_GetDefaultView(sfRenderImage* RenderImage);
/// SFML to do internal optimizations and improve performances.
/// This parameter is false by default
///
/// \param RenderImage : Target renderimage
/// \param Preserve : True to preserve OpenGL states, false to let SFML optimize
/// \param renderImage : Target renderimage
/// \param preserve : True to preserve OpenGL states, false to let SFML optimize
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderImage_PreserveOpenGLStates(sfRenderImage* RenderImage, sfBool Preserve);
CSFML_API void sfRenderImage_PreserveOpenGLStates(sfRenderImage* renderImage, sfBool preserve);
////////////////////////////////////////////////////////////
/// Get the target image
///
/// \param RenderImage : Renderimage object
/// \param renderImage : Renderimage object
///
/// \return Pointer to the target image
///
////////////////////////////////////////////////////////////
CSFML_API sfImage* sfRenderImage_GetImage(sfRenderImage* RenderImage);
CSFML_API sfImage* sfRenderImage_GetImage(sfRenderImage* renderImage);
////////////////////////////////////////////////////////////
/// Check whether the system supports render images or not

191
CSFML/include/SFML/Graphics/RenderWindow.h
View File

@ -41,298 +41,297 @@
////////////////////////////////////////////////////////////
/// Construct a new renderwindow
///
/// \param Mode : Video mode to use
/// \param Title : Title of the window
/// \param Style : Window style
/// \param Params : Creation settings
/// \param mode : Video mode to use
/// \param title : Title of the window
/// \param style : Window style
/// \param settings : Creation settings
///
////////////////////////////////////////////////////////////
CSFML_API sfRenderWindow* sfRenderWindow_Create(sfVideoMode Mode, const char* Title, unsigned long Style, sfContextSettings Params);
CSFML_API sfRenderWindow* sfRenderWindow_Create(sfVideoMode mode, const char* title, unsigned long style, sfContextSettings settings);
////////////////////////////////////////////////////////////
/// Construct a renderwindow from an existing control
///
/// \param Handle : Platform-specific handle of the control
/// \param Params : Creation settings
/// \param handle : Platform-specific handle of the control
/// \param settings : Creation settings
///
////////////////////////////////////////////////////////////
CSFML_API sfRenderWindow* sfRenderWindow_CreateFromHandle(sfWindowHandle Handle, sfContextSettings Params);
CSFML_API sfRenderWindow* sfRenderWindow_CreateFromHandle(sfWindowHandle handle, sfContextSettings settings);
////////////////////////////////////////////////////////////
/// Destroy an existing renderwindow
///
/// \param RenderWindow : Renderwindow to destroy
/// \param renderWindow : Renderwindow to destroy
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_Destroy(sfRenderWindow* RenderWindow);
CSFML_API void sfRenderWindow_Destroy(sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Close a renderwindow (but doesn't destroy the internal data)
///
/// \param RenderWindow : Renderwindow to close
/// \param renderWindow : Renderwindow to close
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_Close(sfRenderWindow* RenderWindow);
CSFML_API void sfRenderWindow_Close(sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Tell whether or not a renderwindow is opened
///
/// \param RenderWindow : Renderwindow object
/// \param renderWindow : Renderwindow object
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfRenderWindow_IsOpened(sfRenderWindow* RenderWindow);
CSFML_API sfBool sfRenderWindow_IsOpened(sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Get the width of the rendering region of a window
///
/// \param RenderWindow : Renderwindow object
/// \param renderWindow : Renderwindow object
///
/// \return Width in pixels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfRenderWindow_GetWidth(sfRenderWindow* RenderWindow);
CSFML_API unsigned int sfRenderWindow_GetWidth(sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Get the height of the rendering region of a window
///
/// \param RenderWindow : Renderwindow object
/// \param renderWindow : Renderwindow object
///
/// \return Height in pixels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfRenderWindow_GetHeight(sfRenderWindow* RenderWindow);
CSFML_API unsigned int sfRenderWindow_GetHeight(sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Get the creation settings of a window
///
/// \param RenderWindow : Renderwindow object
/// \param renderWindow : Renderwindow object
///
/// \return Settings used to create the window
///
////////////////////////////////////////////////////////////
CSFML_API sfContextSettings sfRenderWindow_GetSettings(sfRenderWindow* RenderWindow);
CSFML_API sfContextSettings sfRenderWindow_GetSettings(sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Get the event on top of events stack of a window, if any, and pop it
///
/// \param RenderWindow : Renderwindow object
/// \param Event : Event to fill, if any
/// \param renderWindow : Renderwindow object
/// \param event : Event to fill, if any
///
/// \return sfTrue if an event was returned, sfFalse if events stack was empty
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfRenderWindow_GetEvent(sfRenderWindow* RenderWindow, sfEvent* Event);
CSFML_API sfBool sfRenderWindow_GetEvent(sfRenderWindow* renderWindow, sfEvent* event);
////////////////////////////////////////////////////////////
/// Enable / disable vertical synchronization on a window
///
/// \param RenderWindow : Renderwindow object
/// \param Enabled : sfTrue to enable v-sync, sfFalse to deactivate
/// \param renderWindow : Renderwindow object
/// \param enabled : sfTrue to enable v-sync, sfFalse to deactivate
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_UseVerticalSync(sfRenderWindow* RenderWindow, sfBool Enabled);
CSFML_API void sfRenderWindow_UseVerticalSync(sfRenderWindow* renderWindow, sfBool enabled);
////////////////////////////////////////////////////////////
/// Show or hide the mouse cursor on a window
///
/// \param RenderWindow : RenderWindow object
/// \param Show : sfTrue to show, sfFalse to hide
/// \param renderWindow : RenderWindow object
/// \param show : sfTrue to show, sfFalse to hide
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_ShowMouseCursor(sfRenderWindow* RenderWindow, sfBool Show);
CSFML_API void sfRenderWindow_ShowMouseCursor(sfRenderWindow* renderWindow, sfBool show);
////////////////////////////////////////////////////////////
/// Change the position of the mouse cursor on a window
///
/// \param RenderWindow : Renderwindow object
/// \param Left : Left coordinate of the cursor, relative to the window
/// \param Top : Top coordinate of the cursor, relative to the window
/// \param renderWindow : Renderwindow object
/// \param left : Left coordinate of the cursor, relative to the window
/// \param top : Top coordinate of the cursor, relative to the window
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_SetCursorPosition(sfRenderWindow* RenderWindow, unsigned int Left, unsigned int Top);
CSFML_API void sfRenderWindow_SetCursorPosition(sfRenderWindow* renderWindow, unsigned int left, unsigned int top);
////////////////////////////////////////////////////////////
/// Change the position of a window on screen.
/// Only works for top-level windows
///
/// \param RenderWindow : Renderwindow object
/// \param Left : Left position
/// \param Top : Top position
/// \param renderWindow : Renderwindow object
/// \param left : Left position
/// \param top : Top position
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_SetPosition(sfRenderWindow* RenderWindow, int Left, int Top);
CSFML_API void sfRenderWindow_SetPosition(sfRenderWindow* renderWindow, int left, int top);
////////////////////////////////////////////////////////////
/// Change the size of the rendering region of a window
///
/// \param RenderWindow : Renderwindow object
/// \param Width : New Width
/// \param Height : New Height
/// \param renderWindow : Renderwindow object
/// \param width : New Width
/// \param height : New Height
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_SetSize(sfRenderWindow* RenderWindow, unsigned int Width, unsigned int Height);
CSFML_API void sfRenderWindow_SetSize(sfRenderWindow* renderWindow, unsigned int width, unsigned int height);
////////////////////////////////////////////////////////////
/// Show or hide a window
///
/// \param RenderWindow : Renderwindow object
/// \param State : sfTrue to show, sfFalse to hide
/// \param renderWindow : Renderwindow object
/// \param show : sfTrue to show, sfFalse to hide
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_Show(sfRenderWindow* RenderWindow, sfBool State);
CSFML_API void sfRenderWindow_Show(sfRenderWindow* renderWindow, sfBool show);
////////////////////////////////////////////////////////////
/// Enable or disable automatic key-repeat for keydown events.
/// Automatic key-repeat is enabled by default
///
/// \param RenderWindow : Renderwindow object
/// \param Enabled : sfTrue to enable, sfFalse to disable
/// \param renderWindow : Renderwindow object
/// \param enabled : sfTrue to enable, sfFalse to disable
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_EnableKeyRepeat(sfRenderWindow* RenderWindow, sfBool Enabled);
CSFML_API void sfRenderWindow_EnableKeyRepeat(sfRenderWindow* renderWindow, sfBool enabled);
////////////////////////////////////////////////////////////
/// Change the window's icon
///
/// \param RenderWindow : Renderwindow object
/// \param Width : Icon's width, in pixels
/// \param Height : Icon's height, in pixels
/// \param Pixels : Pointer to the pixels in memory, format must be RGBA 32 bits
/// \param renderWindow : Renderwindow object
/// \param width : Icon's width, in pixels
/// \param height : Icon's height, in pixels
/// \param pixels : Pointer to the pixels in memory, format must be RGBA 32 bits
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_SetIcon(sfRenderWindow* RenderWindow, unsigned int Width, unsigned int Height, sfUint8* Pixels);
CSFML_API void sfRenderWindow_SetIcon(sfRenderWindow* renderWindow, unsigned int width, unsigned int height, sfUint8* pixels);
////////////////////////////////////////////////////////////
/// Activate or deactivate a window as the current target for rendering
///
/// \param RenderWindow : Renderwindow object
/// \param Active : sfTrue to activate, sfFalse to deactivate
/// \param renderWindow : Renderwindow object
/// \param active : sfTrue to activate, sfFalse to deactivate
///
/// \return True if operation was successful, false otherwise
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfRenderWindow_SetActive(sfRenderWindow* RenderWindow, sfBool Active);
CSFML_API sfBool sfRenderWindow_SetActive(sfRenderWindow* renderWindow, sfBool active);
////////////////////////////////////////////////////////////
/// Display a window on screen
///
/// \param RenderWindow : Renderwindow object
/// \param renderWindow : Renderwindow object
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_Display(sfRenderWindow* RenderWindow);
CSFML_API void sfRenderWindow_Display(sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Get the input manager of a window
///
/// \param RenderWindow : Renderwindow object
/// \param renderWindow : Renderwindow object
///
/// \return Reference to the input
///
////////////////////////////////////////////////////////////
CSFML_API sfInput* sfRenderWindow_GetInput(sfRenderWindow* RenderWindow);
CSFML_API sfInput* sfRenderWindow_GetInput(sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Limit the framerate to a maximum fixed frequency for a window
///
/// \param RenderWindow : Renderwindow object
///
/// \param Limit : Framerate limit, in frames per seconds (use 0 to disable limit)
/// \param renderWindow : Renderwindow object
/// \param limit : Framerate limit, in frames per seconds (use 0 to disable limit)
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_SetFramerateLimit(sfRenderWindow* RenderWindow, unsigned int Limit);
CSFML_API void sfRenderWindow_SetFramerateLimit(sfRenderWindow* renderWindow, unsigned int limit);
////////////////////////////////////////////////////////////
/// Get time elapsed since last frame of a window
///
/// \param RenderWindow : Renderwindow object
/// \param renderWindow : Renderwindow object
///
/// \return Time elapsed, in seconds
///
////////////////////////////////////////////////////////////
CSFML_API float sfRenderWindow_GetFrameTime(sfRenderWindow* RenderWindow);
CSFML_API float sfRenderWindow_GetFrameTime(sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Change the joystick threshold, ie. the value below which
/// no move event will be generated
///
/// \param RenderWindow : Renderwindow object
/// \param Threshold : New threshold, in range [0, 100]
/// \param renderWindow : Renderwindow object
/// \param threshold : New threshold, in range [0, 100]
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_SetJoystickThreshold(sfRenderWindow* RenderWindow, float Threshold);
CSFML_API void sfRenderWindow_SetJoystickThreshold(sfRenderWindow* renderWindow, float threshold);
////////////////////////////////////////////////////////////
/// Draw something on a renderwindow
///
/// \param RenderWindow : Renderwindow to draw in
/// \param PostFX / Sprite / String / shape : Object to draw
/// \param renderWindow : Renderwindow to draw in
/// \param postFX / sprite / string / shape : Object to draw
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_DrawPostFX(sfRenderWindow* RenderWindow, sfPostFX* PostFX);
CSFML_API void sfRenderWindow_DrawSprite(sfRenderWindow* RenderWindow, sfSprite* Sprite);
CSFML_API void sfRenderWindow_DrawShape (sfRenderWindow* RenderWindow, sfShape* Shape);
CSFML_API void sfRenderWindow_DrawString(sfRenderWindow* RenderWindow, sfString* String);
CSFML_API void sfRenderWindow_DrawPostFX(sfRenderWindow* renderWindow, sfPostFX* postFX);
CSFML_API void sfRenderWindow_DrawSprite(sfRenderWindow* renderWindow, sfSprite* sprite);
CSFML_API void sfRenderWindow_DrawShape (sfRenderWindow* renderWindow, sfShape* shape);
CSFML_API void sfRenderWindow_DrawString(sfRenderWindow* renderWindow, sfString* string);
////////////////////////////////////////////////////////////
/// Save the content of a renderwindow to an image
///
/// \param RenderWindow : Renderwindow to capture
/// \param renderWindow : Renderwindow to capture
///
/// \return Image instance containing the contents of the screen
///
////////////////////////////////////////////////////////////
CSFML_API sfImage* sfRenderWindow_Capture(sfRenderWindow* RenderWindow);
CSFML_API sfImage* sfRenderWindow_Capture(sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Clear the screen with the given color
///
/// \param RenderWindow : Renderwindow to modify
/// \param Color : Fill color
/// \param renderWindow : Renderwindow to modify
/// \param color : Fill color
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_Clear(sfRenderWindow* RenderWindow, sfColor Color);
CSFML_API void sfRenderWindow_Clear(sfRenderWindow* renderWindow, sfColor color);
////////////////////////////////////////////////////////////
/// Change the current active view of a renderwindow
///
/// \param RenderWindow : Renderwindow to modify
/// \param NewView : Pointer to the new view
/// \param renderWindow : Renderwindow to modify
/// \param view : Pointer to the new view
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_SetView(sfRenderWindow* RenderWindow, sfView* View);
CSFML_API void sfRenderWindow_SetView(sfRenderWindow* renderWindow, sfView* view);
////////////////////////////////////////////////////////////
/// Get the current active view of a renderwindow
///
/// \param RenderWindow : Renderwindow
/// \param renderWindow : Renderwindow
///
/// \return Current active view
///
////////////////////////////////////////////////////////////
CSFML_API const sfView* sfRenderWindow_GetView(sfRenderWindow* RenderWindow);
CSFML_API const sfView* sfRenderWindow_GetView(sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Get the default view of a renderwindow
///
/// \param RenderWindow : Renderwindow
/// \param renderWindow : Renderwindow
///
/// \return Default view of the render window
///
////////////////////////////////////////////////////////////
CSFML_API sfView* sfRenderWindow_GetDefaultView(sfRenderWindow* RenderWindow);
CSFML_API sfView* sfRenderWindow_GetDefaultView(sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Convert a point in window coordinates into view coordinates
///
/// \param RenderWindow : Target Renderwindow
/// \param WindowX : X coordinate of the point to convert, relative to the window
/// \param WindowY : Y coordinate of the point to convert, relative to the window
/// \param ViewX : Pointer to fill with the X coordinate of the converted point
/// \param ViewY : Pointer to fill with the Y coordinate of the converted point
/// \param TargetView : Target view to convert the point to (pass NULL to use the current view)
/// \param renderWindow : Target Renderwindow
/// \param windowX : X coordinate of the point to convert, relative to the window
/// \param windowY : Y coordinate of the point to convert, relative to the window
/// \param viewX : Pointer to fill with the X coordinate of the converted point
/// \param viewY : Pointer to fill with the Y coordinate of the converted point
/// \param targetView : Target view to convert the point to (pass NULL to use the current view)
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_ConvertCoords(sfRenderWindow* RenderWindow, unsigned int WindowX, unsigned int WindowY, float* ViewX, float* ViewY, sfView* TargetView);
CSFML_API void sfRenderWindow_ConvertCoords(sfRenderWindow* renderWindow, unsigned int windowX, unsigned int windowY, float* viewX, float* viewY, sfView* targetView);
////////////////////////////////////////////////////////////
/// Tell SFML to preserve external OpenGL states, at the expense of
@ -342,11 +341,11 @@ CSFML_API void sfRenderWindow_ConvertCoords(sfRenderWindow* RenderWindow, unsign
/// SFML to do internal optimizations and improve performances.
/// This parameter is false by default
///
/// \param RenderWindow : Target Renderwindow
/// \param Preserve : True to preserve OpenGL states, false to let SFML optimize
/// \param renderWindow : Target Renderwindow
/// \param preserve : True to preserve OpenGL states, false to let SFML optimize
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_PreserveOpenGLStates(sfRenderWindow* RenderWindow, sfBool Preserve);
CSFML_API void sfRenderWindow_PreserveOpenGLStates(sfRenderWindow* renderWindow, sfBool preserve);
#endif // SFML_RENDERWINDOW_H

271
CSFML/include/SFML/Graphics/Shape.h
View File

@ -45,39 +45,39 @@ CSFML_API sfShape* sfShape_Create();
////////////////////////////////////////////////////////////
/// Create a new shape made of a single line
///
/// \param P1X, P1Y : Position of the first point
/// \param P2X, P2Y : Position second point
/// \param Thickness : Line thickness
/// \param Col : Color used to draw the line
/// \param Outline : Outline width
/// \param OutlineCol : Color used to draw the outline
/// \param p1x, p1y : Position of the first point
/// \param p2x, p2y : Position second point
/// \param thickness : Line thickness
/// \param color : Color used to draw the line
/// \param outline : Outline width
/// \param outlineColor : Color used to draw the outline
///
////////////////////////////////////////////////////////////
CSFML_API sfShape* sfShape_CreateLine(float P1X, float P1Y, float P2X, float P2Y, float Thickness, sfColor Col, float Outline, sfColor OutlineCol);
CSFML_API sfShape* sfShape_CreateLine(float p1x, float p1y, float p2x, float p2y, float thickness, sfColor color, float outline, sfColor outlineColor);
////////////////////////////////////////////////////////////
/// Create a new shape made of a single rectangle
///
/// \param P1X, P1Y : Position of the first point
/// \param P2X, P2Y : Position second point
/// \param Col : Color used to fill the rectangle
/// \param Outline : Outline width
/// \param OutlineCol : Color used to draw the outline
/// \param p1x, p1y : Position of the first point
/// \param p2x, p2y : Position second point
/// \param color : Color used to fill the rectangle
/// \param outline : Outline width
/// \param outlineColor : Color used to draw the outline
///
////////////////////////////////////////////////////////////
CSFML_API sfShape* sfShape_CreateRectangle(float P1X, float P1Y, float P2X, float P2Y, sfColor Col, float Outline, sfColor OutlineCol);
CSFML_API sfShape* sfShape_CreateRectangle(float p1x, float p1y, float p2x, float p2y, sfColor color, float outline, sfColor outlineColor);
////////////////////////////////////////////////////////////
/// Create a new shape made of a single circle
///
/// \param X, Y : Position of the center
/// \param Radius : Radius
/// \param Col : Color used to fill the circle
/// \param Outline : Outline width
/// \param OutlineCol : Color used to draw the outline
/// \param x, y : Position of the center
/// \param radius : Radius
/// \param color : Color used to fill the circle
/// \param outline : Outline width
/// \param outlineColor : Color used to draw the outline
///
////////////////////////////////////////////////////////////
CSFML_API sfShape* sfShape_CreateCircle(float X, float Y, float Radius, sfColor Col, float Outline, sfColor OutlineCol);
CSFML_API sfShape* sfShape_CreateCircle(float x, float y, float radius, sfColor color, float outline, sfColor outlineColor);
////////////////////////////////////////////////////////////
/// Destroy an existing Shape
@ -85,369 +85,370 @@ CSFML_API sfShape* sfShape_CreateCircle(float X, float Y, float Radius, sfColor
/// \param Shape : Shape to delete
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_Destroy(sfShape* Shape);
CSFML_API void sfShape_Destroy(sfShape* shape);
////////////////////////////////////////////////////////////
/// Set the X position of a shape
///
/// \param Shape : Shape to modify
/// \param X : New X coordinate
/// \param shape : Shape to modify
/// \param x : New X coordinate
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_SetX(sfShape* Shape, float X);
CSFML_API void sfShape_SetX(sfShape* shape, float x);
////////////////////////////////////////////////////////////
/// Set the Y position of a shape
///
/// \param Shape : Shape to modify
/// \param Y : New Y coordinate
/// \param shape : Shape to modify
/// \param y : New Y coordinate
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_SetY(sfShape* Shape, float Y);
CSFML_API void sfShape_SetY(sfShape* shape, float y);
////////////////////////////////////////////////////////////
/// Set the position of a shape
///
/// \param Shape : Shape to modify
/// \param X : New X coordinate
/// \param Y : New Y coordinate
/// \param shape : Shape to modify
/// \param x : New X coordinate
/// \param y : New Y coordinate
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_SetPosition(sfShape* Shape, float X, float Y);
CSFML_API void sfShape_SetPosition(sfShape* shape, float x, float y);
////////////////////////////////////////////////////////////
/// Set the horizontal scale of a shape
///
/// \param Shape : Shape to modify
/// \param Scale : New scale (must be strictly positive)
/// \param shape : Shape to modify
/// \param scale : New scale (must be strictly positive)
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_SetScaleX(sfShape* Shape, float Scale);
CSFML_API void sfShape_SetScaleX(sfShape* shape, float scale);
////////////////////////////////////////////////////////////
/// Set the vertical scale of a shape
///
/// \param Shape : Shape to modify
/// \param Scale : New scale (must be strictly positive)
/// \param shape : Shape to modify
/// \param scale : New scale (must be strictly positive)
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_SetScaleY(sfShape* Shape, float Scale);
CSFML_API void sfShape_SetScaleY(sfShape* shape, float scale);
////////////////////////////////////////////////////////////
/// Set the scale of a shape
///
/// \param Shape : Shape to modify
/// \param ScaleX : New horizontal scale (must be strictly positive)
/// \param ScaleY : New vertical scale (must be strictly positive)
/// \param shape : Shape to modify
/// \param scaleX : New horizontal scale (must be strictly positive)
/// \param scaleY : New vertical scale (must be strictly positive)
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_SetScale(sfShape* Shape, float ScaleX, float ScaleY);
CSFML_API void sfShape_SetScale(sfShape* shape, float scaleX, float scaleY);
////////////////////////////////////////////////////////////
/// Set the orientation of a shape
///
/// \param Shape : Shape to modify
/// \param Rotation : Angle of rotation, in degrees
/// \param shape : Shape to modify
/// \param rotation : Angle of rotation, in degrees
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_SetRotation(sfShape* Shape, float Rotation);
CSFML_API void sfShape_SetRotation(sfShape* shape, float rotation);
////////////////////////////////////////////////////////////
/// Set the local origin of a shape, in coordinates relative to
/// its left-top corner
///
/// \param Shape : Shape to modify
/// \param X : X coordinate of the origin
/// \param Y : Y coordinate of the origin
/// \param shape : Shape to modify
/// \param x : X coordinate of the origin
/// \param y : Y coordinate of the origin
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_SetOrigin(sfShape* Shape, float X, float Y);
CSFML_API void sfShape_SetOrigin(sfShape* shape, float x, float y);
////////////////////////////////////////////////////////////
/// Set the color of a shape
///
/// \param Shape : Shape to modify
/// \param Color : New color
/// \param shape : Shape to modify
/// \param color : New color
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_SetColor(sfShape* Shape, sfColor Color);
CSFML_API void sfShape_SetColor(sfShape* shape, sfColor color);
////////////////////////////////////////////////////////////
/// Set the blending mode for a shape
///
/// \param Shape : Shape to modify
/// \param Mode : New blending mode
/// \param shape : Shape to modify
/// \param mode : New blending mode
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_SetBlendMode(sfShape* Shape, sfBlendMode Mode);
CSFML_API void sfShape_SetBlendMode(sfShape* shape, sfBlendMode mode);
////////////////////////////////////////////////////////////
/// Get the X position of a shape
///
/// \param Shape : Shape to read
/// \param shape : Shape to read
///
/// \return Current X position
///
////////////////////////////////////////////////////////////
CSFML_API float sfShape_GetX(sfShape* Shape);
CSFML_API float sfShape_GetX(sfShape* shape);
////////////////////////////////////////////////////////////
/// Get the Y position of a shape
///
/// \param Shape : Shape to read
/// \param shape : Shape to read
///
/// \return Current Y position
///
////////////////////////////////////////////////////////////
CSFML_API float sfShape_GetY(sfShape* Shape);
CSFML_API float sfShape_GetY(sfShape* shape);
////////////////////////////////////////////////////////////
/// Get the horizontal scale of a shape
///
/// \param Shape : Shape to read
/// \param shape : Shape to read
///
/// \return Current X scale factor (always positive)
///
////////////////////////////////////////////////////////////
CSFML_API float sfShape_GetScaleX(sfShape* Shape);
CSFML_API float sfShape_GetScaleX(sfShape* shape);
////////////////////////////////////////////////////////////
/// Get the vertical scale of a shape
///
/// \param Shape : Shape to read
/// \param shape : Shape to read
///
/// \return Current Y scale factor (always positive)
///
////////////////////////////////////////////////////////////
CSFML_API float sfShape_GetScaleY(sfShape* Shape);
CSFML_API float sfShape_GetScaleY(sfShape* shape);
////////////////////////////////////////////////////////////
/// Get the orientation of a shape
///
/// \param Shape : Shape to read
/// \param shape : Shape to read
///
/// \return Current rotation, in degrees
///
////////////////////////////////////////////////////////////
CSFML_API float sfShape_GetRotation(sfShape* Shape);
CSFML_API float sfShape_GetRotation(sfShape* shape);
////////////////////////////////////////////////////////////
/// Get the X position of the origin a shape
///
/// \param Shape : Shape to read
/// \param shape : Shape to read
///
/// \return Current X origin
///
////////////////////////////////////////////////////////////
CSFML_API float sfShape_GetOriginX(sfShape* Shape);
CSFML_API float sfShape_GetOriginX(sfShape* shape);
////////////////////////////////////////////////////////////
/// Get the Y position of the origin a shape
///
/// \param Shape : Shape to read
/// \param shape : Shape to read
///
/// \return Current Y origin
///
////////////////////////////////////////////////////////////
CSFML_API float sfShape_GetOriginY(sfShape* Shape);
CSFML_API float sfShape_GetOriginY(sfShape* shape);
////////////////////////////////////////////////////////////
/// Get the color of a shape
///
/// \param Shape : Shape to read
/// \param shape : Shape to read
///
/// \return Current color
///
////////////////////////////////////////////////////////////
CSFML_API sfColor sfShape_GetColor(sfShape* Shape);
CSFML_API sfColor sfShape_GetColor(sfShape* shape);
////////////////////////////////////////////////////////////
/// Get the current blending mode of a shape
///
/// \param Shape : Shape to read
/// \param shape : Shape to read
///
/// \return Current blending mode
///
////////////////////////////////////////////////////////////
CSFML_API sfBlendMode sfShape_GetBlendMode(sfShape* Shape);
CSFML_API sfBlendMode sfShape_GetBlendMode(sfShape* shape);
////////////////////////////////////////////////////////////
/// Move a shape
///
/// \param Shape : Shape to modify
/// \param OffsetX : Offset on the X axis
/// \param OffsetY : Offset on the Y axis
/// \param shape : Shape to modify
/// \param offsetX : Offset on the X axis
/// \param offsetY : Offset on the Y axis
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_Move(sfShape* Shape, float OffsetX, float OffsetY);
CSFML_API void sfShape_Move(sfShape* shape, float offsetX, float offsetY);
////////////////////////////////////////////////////////////
/// Scale a shape
///
/// \param Shape : Shape to modify
/// \param FactorX : Horizontal scaling factor (must be strictly positive)
/// \param FactorY : Vertical scaling factor (must be strictly positive)
/// \param shape : Shape to modify
/// \param factorX : Horizontal scaling factor (must be strictly positive)
/// \param factorY : Vertical scaling factor (must be strictly positive)
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_Scale(sfShape* Shape, float FactorX, float FactorY);
CSFML_API void sfShape_Scale(sfShape* shape, float factorX, float factorY);
////////////////////////////////////////////////////////////
/// Rotate a shape
///
/// \param Shape : Shape to modify
/// \param Angle : Angle of rotation, in degrees
/// \param shape : Shape to modify
/// \param angle : Angle of rotation, in degrees
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_Rotate(sfShape* Shape, float Angle);
CSFML_API void sfShape_Rotate(sfShape* shape, float angle);
////////////////////////////////////////////////////////////
/// Transform a point from global coordinates into the shape's local coordinates
/// (ie it applies the inverse of object's origin, translation, rotation and scale to the point)
///
/// \param Shape : Shape object
/// \param PointX : X coordinate of the point to transform
/// \param PointY : Y coordinate of the point to transform
/// \param X : Value to fill with the X coordinate of the converted point
/// \param Y : Value to fill with the y coordinate of the converted point
/// \param shape : Shape object
/// \param pointX : X coordinate of the point to transform
/// \param pointY : Y coordinate of the point to transform
/// \param x : Value to fill with the X coordinate of the converted point
/// \param y : Value to fill with the y coordinate of the converted point
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_TransformToLocal(sfShape* Shape, float PointX, float PointY, float* X, float* Y);
CSFML_API void sfShape_TransformToLocal(sfShape* shape, float pointX, float pointY, float* x, float* y);
////////////////////////////////////////////////////////////
/// Transform a point from the shape's local coordinates into global coordinates
/// (ie it applies the object's origin, translation, rotation and scale to the point)
///
/// \param Shape : Shape object
/// \param PointX : X coordinate of the point to transform
/// \param PointY : Y coordinate of the point to transform
/// \param X : Value to fill with the X coordinate of the converted point
/// \param Y : Value to fill with the y coordinate of the converted point
/// \param shape : Shape object
/// \param pointX : X coordinate of the point to transform
/// \param pointY : Y coordinate of the point to transform
/// \param x : Value to fill with the X coordinate of the converted point
/// \param y : Value to fill with the y coordinate of the converted point
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_TransformToGlobal(sfShape* Shape, float PointX, float PointY, float* X, float* Y);
CSFML_API void sfShape_TransformToGlobal(sfShape* shape, float pointX, float pointY, float* x, float* y);
////////////////////////////////////////////////////////////
/// Add a point to a shape
///
/// \param Shape : Shape to modify
/// \param X, Y : Position of the point
/// \param Col : Color of the point
/// \param OutlineCol : Outline color of the point
/// \param shape : Shape to modify
/// \param x, y : Position of the point
/// \param color : Color of the point
/// \param outlineColor : Outline color of the point
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_AddPoint(sfShape* Shape, float X, float Y, sfColor Col, sfColor OutlineCol);
CSFML_API void sfShape_AddPoint(sfShape* shape, float x, float y, sfColor color, sfColor outlineColor);
////////////////////////////////////////////////////////////
/// Enable or disable filling a shape.
/// Fill is enabled by default
///
/// \param Enable : True to enable, false to disable
/// \param shape : Shape to modify
/// \param enable : True to enable, false to disable
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_EnableFill(sfShape* Shape, sfBool Enable);
CSFML_API void sfShape_EnableFill(sfShape* shape, sfBool enable);
////////////////////////////////////////////////////////////
/// Enable or disable drawing a shape outline.
/// Outline is enabled by default
///
/// \param Shape : Shape to modify
/// \param Enable : True to enable, false to disable
/// \param shape : Shape to modify
/// \param enable : True to enable, false to disable
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_EnableOutline(sfShape* Shape, sfBool Enable);
CSFML_API void sfShape_EnableOutline(sfShape* shape, sfBool enable);
////////////////////////////////////////////////////////////
/// Change the width of a shape outline
///
/// \param Shape : Shape to modify
/// \param Width : New width
/// \param shape : Shape to modify
/// \param width : New width
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_SetOutlineWidth(sfShape* Shape, float Width);
CSFML_API void sfShape_SetOutlineWidth(sfShape* shape, float width);
////////////////////////////////////////////////////////////
/// Get the width of a shape outline
///
/// \param Shape : Shape to read
/// \param shape : Shape to read
///
/// \param return Current outline width
///
////////////////////////////////////////////////////////////
CSFML_API float sfShape_GetOutlineWidth(sfShape* Shape);
CSFML_API float sfShape_GetOutlineWidth(sfShape* shape);
////////////////////////////////////////////////////////////
/// Get the number of points composing a shape
///
/// \param Shape : Shape to read
/// \param shape : Shape to read
///
/// \return Total number of points
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfShape_GetNbPoints(sfShape* Shape);
CSFML_API unsigned int sfShape_GetNbPoints(sfShape* shape);
////////////////////////////////////////////////////////////
/// Get a the position of a shape's point
///
/// \param Shape : Shape to read
/// \param Index : Index of the point to get
/// \param X : Variable to fill with the X coordinate of the point
/// \param Y : Variable to fill with the Y coordinate of the point
/// \param shape : Shape to read
/// \param index : Index of the point to get
/// \param x : Variable to fill with the X coordinate of the point
/// \param y : Variable to fill with the Y coordinate of the point
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_GetPointPosition(sfShape* Shape, unsigned int Index, float* X, float* Y);
CSFML_API void sfShape_GetPointPosition(sfShape* shape, unsigned int index, float* x, float* y);
////////////////////////////////////////////////////////////
/// Get a the color of a shape's point
///
/// \param Shape : Shape to read
/// \param Index : Index of the point to get
/// \param shape : Shape to read
/// \param index : Index of the point to get
///
/// \return Color of the point
///
////////////////////////////////////////////////////////////
CSFML_API sfColor sfShape_GetPointColor(sfShape* Shape, unsigned int Index);
CSFML_API sfColor sfShape_GetPointColor(sfShape* shape, unsigned int index);
////////////////////////////////////////////////////////////
/// Get a the outline color of a shape's point
///
/// \param Shape : Shape to read
/// \param Index : Index of the point to get
/// \param shape : Shape to read
/// \param index : Index of the point to get
///
/// \return Outline color of the point
///
////////////////////////////////////////////////////////////
CSFML_API sfColor sfShape_GetPointOutlineColor(sfShape* Shape, unsigned int Index);
CSFML_API sfColor sfShape_GetPointOutlineColor(sfShape* shape, unsigned int index);
////////////////////////////////////////////////////////////
/// Set a the position of a shape's point
///
/// \param Shape : Shape to read
/// \param Index : Index of the point to get
/// \param X : X coordinate of the point
/// \param Y : Y coordinate of the point
/// \param shape : Shape to read
/// \param index : Index of the point to get
/// \param x : X coordinate of the point
/// \param y : Y coordinate of the point
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_SetPointPosition(sfShape* Shape, unsigned int Index, float X, float Y);
CSFML_API void sfShape_SetPointPosition(sfShape* shape, unsigned int index, float x, float y);
////////////////////////////////////////////////////////////
/// Set a the color of a shape's point
///
/// \param Shape : Shape to read
/// \param Index : Index of the point to get
/// \param Color : Color of the point
/// \param shape : Shape to read
/// \param index : Index of the point to get
/// \param color : Color of the point
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_SetPointColor(sfShape* Shape, unsigned int Index, sfColor Color);
CSFML_API void sfShape_SetPointColor(sfShape* shape, unsigned int index, sfColor color);
////////////////////////////////////////////////////////////
/// Set a the outline color of a shape's point
///
/// \param Shape : Shape to read
/// \param Index : Index of the point to get
/// \param Color : Outline color of the point
/// \param shape : Shape to read
/// \param index : Index of the point to get
/// \param color : Outline color of the point
///
////////////////////////////////////////////////////////////
CSFML_API void sfShape_SetPointOutlineColor(sfShape* Shape, unsigned int Index, sfColor Color);
CSFML_API void sfShape_SetPointOutlineColor(sfShape* shape, unsigned int index, sfColor color);
#endif // SFML_Shape_H

206
CSFML/include/SFML/Graphics/Sprite.h
View File

@ -46,347 +46,347 @@ CSFML_API sfSprite* sfSprite_Create();
////////////////////////////////////////////////////////////
/// Destroy an existing sprite
///
/// \param Sprite : Sprite to delete
/// \param sprite : Sprite to delete
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_Destroy(sfSprite* Sprite);
CSFML_API void sfSprite_Destroy(sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Set the X position of a sprite
///
/// \param Sprite : Sprite to modify
/// \param X : New X coordinate
/// \param sprite : Sprite to modify
/// \param x : New X coordinate
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_SetX(sfSprite* Sprite, float X);
CSFML_API void sfSprite_SetX(sfSprite* sprite, float x);
////////////////////////////////////////////////////////////
/// Set the T position of a sprite
///
/// \param Sprite : Sprite to modify
/// \param Y : New Y coordinate
/// \param sprite : Sprite to modify
/// \param y : New Y coordinate
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_SetY(sfSprite* Sprite, float Y);
CSFML_API void sfSprite_SetY(sfSprite* sprite, float y);
////////////////////////////////////////////////////////////
/// Set the position of a sprite
///
/// \param Sprite : Sprite to modify
/// \param X : New X coordinate
/// \param Y : New Y coordinate
/// \param sprite : Sprite to modify
/// \param x : New X coordinate
/// \param y : New Y coordinate
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_SetPosition(sfSprite* Sprite, float X, float Y);
CSFML_API void sfSprite_SetPosition(sfSprite* sprite, float x, float y);
////////////////////////////////////////////////////////////
/// Set the horizontal scale of a sprite
///
/// \param Sprite : Sprite to modify
/// \param Scale : New scale (must be strictly positive)
/// \param sprite : Sprite to modify
/// \param scale : New scale (must be strictly positive)
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_SetScaleX(sfSprite* Sprite, float Scale);
CSFML_API void sfSprite_SetScaleX(sfSprite* sprite, float scale);
////////////////////////////////////////////////////////////
/// Set the vertical scale of a sprite
///
/// \param Sprite : Sprite to modify
/// \param Scale : New scale (must be strictly positive)
/// \param sprite : Sprite to modify
/// \param scale : New scale (must be strictly positive)
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_SetScaleY(sfSprite* Sprite, float Scale);
CSFML_API void sfSprite_SetScaleY(sfSprite* sprite, float scale);
////////////////////////////////////////////////////////////
/// Set the scale of a sprite
///
/// \param Sprite : Sprite to modify
/// \param ScaleX : New horizontal scale (must be strictly positive)
/// \param ScaleY : New vertical scale (must be strictly positive)
/// \param sprite : Sprite to modify
/// \param scaleX : New horizontal scale (must be strictly positive)
/// \param scaleY : New vertical scale (must be strictly positive)
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_SetScale(sfSprite* Sprite, float ScaleX, float ScaleY);
CSFML_API void sfSprite_SetScale(sfSprite* sprite, float scaleX, float scaleY);
////////////////////////////////////////////////////////////
/// Set the orientation of a sprite
///
/// \param Sprite : Sprite to modify
/// \param Rotation : Angle of rotation, in degrees
/// \param sprite : Sprite to modify
/// \param rotation : Angle of rotation, in degrees
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_SetRotation(sfSprite* Sprite, float Rotation);
CSFML_API void sfSprite_SetRotation(sfSprite* sprite, float rotation);
////////////////////////////////////////////////////////////
/// Set the local origin of a sprite, in coordinates relative to
/// its left-top corner
///
/// \param Sprite : Sprite to modify
/// \param X : X coordinate of the origin
/// \param Y : Y coordinate of the origin
/// \param sprite : Sprite to modify
/// \param x : X coordinate of the origin
/// \param y : Y coordinate of the origin
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_SetOrigin(sfSprite* Sprite, float X, float Y);
CSFML_API void sfSprite_SetOrigin(sfSprite* sprite, float x, float y);
////////////////////////////////////////////////////////////
/// Set the color of a sprite
///
/// \param Sprite : Sprite to modify
/// \param Color : New color
/// \param sprite : Sprite to modify
/// \param color : New color
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_SetColor(sfSprite* Sprite, sfColor Color);
CSFML_API void sfSprite_SetColor(sfSprite* sprite, sfColor color);
////////////////////////////////////////////////////////////
/// Set the blending mode for a sprite
///
/// \param Sprite : Sprite to modify
/// \param Mode : New blending mode
/// \param sprite : Sprite to modify
/// \param mode : New blending mode
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_SetBlendMode(sfSprite* Sprite, sfBlendMode Mode);
CSFML_API void sfSprite_SetBlendMode(sfSprite* sprite, sfBlendMode mode);
////////////////////////////////////////////////////////////
/// Get the X position of a sprite
///
/// \param Sprite : Sprite to read
/// \param sprite : Sprite to read
///
/// \return Current X position
///
////////////////////////////////////////////////////////////
CSFML_API float sfSprite_GetX(sfSprite* Sprite);
CSFML_API float sfSprite_GetX(sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get the Y position of a sprite
///
/// \param Sprite : Sprite to read
/// \param sprite : Sprite to read
///
/// \return Current Y position
///
////////////////////////////////////////////////////////////
CSFML_API float sfSprite_GetY(sfSprite* Sprite);
CSFML_API float sfSprite_GetY(sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get the horizontal scale of a sprite
///
/// \param Sprite : Sprite to read
/// \param sprite : Sprite to read
///
/// \return Current X scale factor (always positive)
///
////////////////////////////////////////////////////////////
CSFML_API float sfSprite_GetScaleX(sfSprite* Sprite);
CSFML_API float sfSprite_GetScaleX(sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get the vertical scale of a sprite
///
/// \param Sprite : Sprite to read
/// \param sprite : Sprite to read
///
/// \return Current Y scale factor (always positive)
///
////////////////////////////////////////////////////////////
CSFML_API float sfSprite_GetScaleY(sfSprite* Sprite);
CSFML_API float sfSprite_GetScaleY(sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get the orientation of a sprite
///
/// \param Sprite : Sprite to read
/// \param sprite : Sprite to read
///
/// \return Current rotation, in degrees
///
////////////////////////////////////////////////////////////
CSFML_API float sfSprite_GetRotation(sfSprite* Sprite);
CSFML_API float sfSprite_GetRotation(sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get the X position of the origin a sprite
///
/// \param Sprite : Sprite to read
/// \param sprite : Sprite to read
///
/// \return Current X origin
///
////////////////////////////////////////////////////////////
CSFML_API float sfSprite_GetOriginX(sfSprite* Sprite);
CSFML_API float sfSprite_GetOriginX(sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get the Y position of the origin a sprite
///
/// \param Sprite : Sprite to read
/// \param sprite : Sprite to read
///
/// \return Current Y origin
///
////////////////////////////////////////////////////////////
CSFML_API float sfSprite_GetOriginY(sfSprite* Sprite);
CSFML_API float sfSprite_GetOriginY(sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get the color of a sprite
///
/// \param Sprite : Sprite to read
/// \param sprite : Sprite to read
///
/// \return Current color
///
////////////////////////////////////////////////////////////
CSFML_API sfColor sfSprite_GetColor(sfSprite* Sprite);
CSFML_API sfColor sfSprite_GetColor(sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get the current blending mode of a sprite
///
/// \param Sprite : Sprite to read
/// \param sprite : Sprite to read
///
/// \return Current blending mode
///
////////////////////////////////////////////////////////////
CSFML_API sfBlendMode sfSprite_GetBlendMode(sfSprite* Sprite);
CSFML_API sfBlendMode sfSprite_GetBlendMode(sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Move a sprite
///
/// \param Sprite : Sprite to modify
/// \param OffsetX : Offset on the X axis
/// \param OffsetY : Offset on the Y axis
/// \param sprite : Sprite to modify
/// \param offsetX : Offset on the X axis
/// \param offsetY : Offset on the Y axis
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_Move(sfSprite* Sprite, float OffsetX, float OffsetY);
CSFML_API void sfSprite_Move(sfSprite* sprite, float offsetX, float offsetY);
////////////////////////////////////////////////////////////
/// Scale a sprite
///
/// \param Sprite : Sprite to modify
/// \param FactorX : Horizontal scaling factor (must be strictly positive)
/// \param FactorY : Vertical scaling factor (must be strictly positive)
/// \param sprite : Sprite to modify
/// \param factorX : Horizontal scaling factor (must be strictly positive)
/// \param factorY : Vertical scaling factor (must be strictly positive)
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_Scale(sfSprite* Sprite, float FactorX, float FactorY);
CSFML_API void sfSprite_Scale(sfSprite* sprite, float factorX, float factorY);
////////////////////////////////////////////////////////////
/// Rotate a sprite
///
/// \param Sprite : Sprite to modify
/// \param Angle : Angle of rotation, in degrees
/// \param sprite : Sprite to modify
/// \param angle : Angle of rotation, in degrees
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_Rotate(sfSprite* Sprite, float Angle);
CSFML_API void sfSprite_Rotate(sfSprite* sprite, float angle);
////////////////////////////////////////////////////////////
/// Transform a point from global coordinates into the sprite's local coordinates
/// (ie it applies the inverse of object's origin, translation, rotation and scale to the point)
///
/// \param Sprite : Sprite object
/// \param PointX : X coordinate of the point to transform
/// \param PointY : Y coordinate of the point to transform
/// \param X : Value to fill with the X coordinate of the converted point
/// \param Y : Value to fill with the y coordinate of the converted point
/// \param sprite : Sprite object
/// \param pointX : X coordinate of the point to transform
/// \param pointY : Y coordinate of the point to transform
/// \param x : Value to fill with the X coordinate of the converted point
/// \param y : Value to fill with the y coordinate of the converted point
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_TransformToLocal(sfSprite* Sprite, float PointX, float PointY, float* X, float* Y);
CSFML_API void sfSprite_TransformToLocal(sfSprite* sprite, float pointX, float pointY, float* x, float* y);
////////////////////////////////////////////////////////////
/// Transform a point from the sprite's local coordinates into global coordinates
/// (ie it applies the object's origin, translation, rotation and scale to the point)
///
/// \param Sprite : Sprite object
/// \param PointX : X coordinate of the point to transform
/// \param PointY : Y coordinate of the point to transform
/// \param X : Value to fill with the X coordinate of the converted point
/// \param Y : Value to fill with the y coordinate of the converted point
/// \param sprite : Sprite object
/// \param pointX : X coordinate of the point to transform
/// \param pointY : Y coordinate of the point to transform
/// \param x : Value to fill with the X coordinate of the converted point
/// \param y : Value to fill with the y coordinate of the converted point
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_TransformToGlobal(sfSprite* Sprite, float PointX, float PointY, float* X, float* Y);
CSFML_API void sfSprite_TransformToGlobal(sfSprite* sprite, float pointX, float pointY, float* x, float* y);
////////////////////////////////////////////////////////////
/// Change the image of a sprite
///
/// \param Sprite : Sprite to modify
/// \param Image : New image
/// \param image : New image
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_SetImage(sfSprite* Sprite, sfImage* Image);
CSFML_API void sfSprite_SetImage(sfSprite* sprite, sfImage* image);
////////////////////////////////////////////////////////////
/// Set the sub-rectangle of a sprite inside the source image
///
/// \param Sprite : Sprite to modify
/// \param SubRect : New sub-rectangle
/// \param sprite : Sprite to modify
/// \param rectangle : New sub-rectangle
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_SetSubRect(sfSprite* Sprite, sfIntRect SubRect);
CSFML_API void sfSprite_SetSubRect(sfSprite* sprite, sfIntRect rectangle);
////////////////////////////////////////////////////////////
/// Resize a sprite (by changing its scale factors)
///
/// \param Sprite : Sprite to modify
/// \param Width : New width (must be strictly positive)
/// \param Height : New height (must be strictly positive)
/// \param sprite : Sprite to modify
/// \param width : New width (must be strictly positive)
/// \param height : New height (must be strictly positive)
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_Resize(sfSprite* Sprite, float Width, float Height);
CSFML_API void sfSprite_Resize(sfSprite* sprite, float width, float height);
////////////////////////////////////////////////////////////
/// Flip a sprite horizontally
///
/// \param Sprite : Sprite to modify
/// \param Flipped : sfTrue to flip the sprite
/// \param sprite : Sprite to modify
/// \param flipped : sfTrue to flip the sprite
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_FlipX(sfSprite* Sprite, sfBool Flipped);
CSFML_API void sfSprite_FlipX(sfSprite* sprite, sfBool flipped);
////////////////////////////////////////////////////////////
/// Flip a sprite vertically
///
/// \param Sprite : Sprite to modify
/// \param Flipped : sfTrue to flip the sprite
/// \param sprite : Sprite to modify
/// \param flipped : sfTrue to flip the sprite
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_FlipY(sfSprite* Sprite, sfBool Flipped);
CSFML_API void sfSprite_FlipY(sfSprite* sprite, sfBool flipped);
////////////////////////////////////////////////////////////
/// Get the source image of a sprite
///
/// \param Sprite : Sprite to read
/// \param sprite : Sprite to read
///
/// \return Pointer to the image (can be NULL)
///
////////////////////////////////////////////////////////////
CSFML_API sfImage* sfSprite_GetImage(sfSprite* Sprite);
CSFML_API sfImage* sfSprite_GetImage(sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get the sub-rectangle of a sprite inside the source image
///
/// \param Sprite : Sprite to read
/// \param sprite : Sprite to read
///
/// \return Sub-rectangle
///
////////////////////////////////////////////////////////////
CSFML_API sfIntRect sfSprite_GetSubRect(sfSprite* Sprite);
CSFML_API sfIntRect sfSprite_GetSubRect(sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get a sprite width
///
/// \param Sprite : Sprite to read
/// \param sprite : Sprite to read
///
/// \return Width of the sprite
///
////////////////////////////////////////////////////////////
CSFML_API float sfSprite_GetWidth(sfSprite* Sprite);
CSFML_API float sfSprite_GetWidth(sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get a sprite height
///
/// \param Sprite : Sprite to read
/// \param sprite : Sprite to read
///
/// \return Height of the sprite
///
////////////////////////////////////////////////////////////
CSFML_API float sfSprite_GetHeight(sfSprite* Sprite);
CSFML_API float sfSprite_GetHeight(sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get the color of a given pixel in a sprite
///
/// \param Sprite : Sprite to read
/// \param X : X coordinate of the pixel to get
/// \param Y : Y coordinate of the pixel to get
/// \param sprite : Sprite to read
/// \param x : X coordinate of the pixel to get
/// \param y : Y coordinate of the pixel to get
///
/// \return Color of pixel (X, Y)
///
////////////////////////////////////////////////////////////
CSFML_API sfColor sfSprite_GetPixel(sfSprite* Sprite, unsigned int X, unsigned int Y);
CSFML_API sfColor sfSprite_GetPixel(sfSprite* sprite, unsigned int x, unsigned int y);
#endif // SFML_SPRITE_H

216
CSFML/include/SFML/Graphics/String.h
View File

@ -58,367 +58,367 @@ CSFML_API sfString* sfString_Create();
////////////////////////////////////////////////////////////
/// Destroy an existing string
///
/// \param String : String to delete
/// \param string : String to delete
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_Destroy(sfString* String);
CSFML_API void sfString_Destroy(sfString* string);
////////////////////////////////////////////////////////////
/// Set the X position of a string
///
/// \param String : String to modify
/// \param X : New X coordinate
/// \param string : String to modify
/// \param x : New X coordinate
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_SetX(sfString* String, float X);
CSFML_API void sfString_SetX(sfString* string, float x);
////////////////////////////////////////////////////////////
/// Set the Y position of a string
///
/// \param String : String to modify
/// \param Y : New Y coordinate
/// \param string : String to modify
/// \param y : New Y coordinate
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_SetY(sfString* String, float Y);
CSFML_API void sfString_SetY(sfString* string, float y);
////////////////////////////////////////////////////////////
/// Set the position of a string
///
/// \param String : String to modify
/// \param Left : New left coordinate
/// \param Top : New top coordinate
/// \param string : String to modify
/// \param x : New X coordinate
/// \param y : New Y coordinate
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_SetPosition(sfString* String, float Left, float Top);
CSFML_API void sfString_SetPosition(sfString* string, float x, float y);
////////////////////////////////////////////////////////////
/// Set the horizontal scale of a string
///
/// \param String : String to modify
/// \param Scale : New scale (must be strictly positive)
/// \param string : String to modify
/// \param scale : New scale (must be strictly positive)
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_SetScaleX(sfString* String, float Scale);
CSFML_API void sfString_SetScaleX(sfString* string, float scale);
////////////////////////////////////////////////////////////
/// Set the vertical scale of a string
///
/// \param String : String to modify
/// \param Scale : New scale (must be strictly positive)
/// \param string : String to modify
/// \param scale : New scale (must be strictly positive)
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_SetScaleY(sfString* String, float Scale);
CSFML_API void sfString_SetScaleY(sfString* string, float scale);
////////////////////////////////////////////////////////////
/// Set the scale of a string
///
/// \param String : String to modify
/// \param ScaleX : New horizontal scale (must be strictly positive)
/// \param ScaleY : New vertical scale (must be strictly positive)
/// \param string : String to modify
/// \param scaleX : New horizontal scale (must be strictly positive)
/// \param scaleY : New vertical scale (must be strictly positive)
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_SetScale(sfString* String, float ScaleX, float ScaleY);
CSFML_API void sfString_SetScale(sfString* string, float scaleX, float scaleY);
////////////////////////////////////////////////////////////
/// Set the orientation of a string
///
/// \param String : String to modify
/// \param Rotation : Angle of rotation, in degrees
/// \param string : String to modify
/// \param rotation : Angle of rotation, in degrees
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_SetRotation(sfString* String, float Rotation);
CSFML_API void sfString_SetRotation(sfString* string, float rotation);
////////////////////////////////////////////////////////////
/// Set the local origin of a string, in coordinates
/// relative to its left-top corner
///
/// \param String : String to modify
/// \param X : X coordinate of the origin
/// \param Y : Y coordinate of the origin
/// \param string : String to modify
/// \param x : X coordinate of the origin
/// \param y : Y coordinate of the origin
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_SetOrigin(sfString* String, float X, float Y);
CSFML_API void sfString_SetOrigin(sfString* string, float x, float y);
////////////////////////////////////////////////////////////
/// Set the color of a string
///
/// \param String : String to modify
/// \param Color : New color
/// \param string : String to modify
/// \param color : New color
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_SetColor(sfString* String, sfColor Color);
CSFML_API void sfString_SetColor(sfString* string, sfColor color);
////////////////////////////////////////////////////////////
/// Set the blending mode for a string
///
/// \param String : String to modify
/// \param Mode : New blending mode
/// \param string : String to modify
/// \param mode : New blending mode
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_SetBlendMode(sfString* String, sfBlendMode Mode);
CSFML_API void sfString_SetBlendMode(sfString* string, sfBlendMode mode);
////////////////////////////////////////////////////////////
/// Get the X position of a string
///
/// \param String : String to read
/// \param string : String to read
///
/// \return Current X position
///
////////////////////////////////////////////////////////////
CSFML_API float sfString_GetX(sfString* String);
CSFML_API float sfString_GetX(sfString* string);
////////////////////////////////////////////////////////////
/// Get the top Y of a string
///
/// \param String : String to read
/// \param string : String to read
///
/// \return Current Y position
///
////////////////////////////////////////////////////////////
CSFML_API float sfString_GetY(sfString* String);
CSFML_API float sfString_GetY(sfString* string);
////////////////////////////////////////////////////////////
/// Get the horizontal scale of a string
///
/// \param String : String to read
/// \param string : String to read
///
/// \return Current X scale factor (always positive)
///
////////////////////////////////////////////////////////////
CSFML_API float sfString_GetScaleX(sfString* String);
CSFML_API float sfString_GetScaleX(sfString* string);
////////////////////////////////////////////////////////////
/// Get the vertical scale of a string
///
/// \param String : String to read
/// \param string : String to read
///
/// \return Current Y scale factor (always positive)
///
////////////////////////////////////////////////////////////
CSFML_API float sfString_GetScaleY(sfString* String);
CSFML_API float sfString_GetScaleY(sfString* string);
////////////////////////////////////////////////////////////
/// Get the orientation of a string
///
/// \param String : String to read
/// \param string : String to read
///
/// \return Current rotation, in degrees
///
////////////////////////////////////////////////////////////
CSFML_API float sfString_GetRotation(sfString* String);
CSFML_API float sfString_GetRotation(sfString* string);
////////////////////////////////////////////////////////////
/// Get the X position of the origin a string
///
/// \param String : String to read
/// \param string : String to read
///
/// \return Current X origin position
///
////////////////////////////////////////////////////////////
CSFML_API float sfString_GetOriginX(sfString* String);
CSFML_API float sfString_GetOriginX(sfString* string);
////////////////////////////////////////////////////////////
/// Get the top Y of the origin of a string
///
/// \param String : String to read
/// \param string : String to read
///
/// \return Current Y origin position
///
////////////////////////////////////////////////////////////
CSFML_API float sfString_GetOriginY(sfString* String);
CSFML_API float sfString_GetOriginY(sfString* string);
////////////////////////////////////////////////////////////
/// Get the color of a string
///
/// \param String : String to read
/// \param string : String to read
///
/// \return Current color
///
////////////////////////////////////////////////////////////
CSFML_API sfColor sfString_GetColor(sfString* String);
CSFML_API sfColor sfString_GetColor(sfString* string);
////////////////////////////////////////////////////////////
/// Get the current blending mode of a string
///
/// \param String : String to read
/// \param string : String to read
///
/// \return Current blending mode
///
////////////////////////////////////////////////////////////
CSFML_API sfBlendMode sfString_GetBlendMode(sfString* String);
CSFML_API sfBlendMode sfString_GetBlendMode(sfString* string);
////////////////////////////////////////////////////////////
/// Move a string
///
/// \param String : String to modify
/// \param OffsetX : Offset on the X axis
/// \param OffsetY : Offset on the Y axis
/// \param string : String to modify
/// \param offsetX : Offset on the X axis
/// \param offsetY : Offset on the Y axis
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_Move(sfString* String, float OffsetX, float OffsetY);
CSFML_API void sfString_Move(sfString* string, float offsetX, float offsetY);
////////////////////////////////////////////////////////////
/// Scale a string
///
/// \param String : String to modify
/// \param FactorX : Horizontal scaling factor (must be strictly positive)
/// \param FactorY : Vertical scaling factor (must be strictly positive)
/// \param string : String to modify
/// \param factorX : Horizontal scaling factor (must be strictly positive)
/// \param factorY : Vertical scaling factor (must be strictly positive)
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_Scale(sfString* String, float FactorX, float FactorY);
CSFML_API void sfString_Scale(sfString* string, float factorX, float factorY);
////////////////////////////////////////////////////////////
/// Rotate a string
///
/// \param String : String to modify
/// \param Angle : Angle of rotation, in degrees
/// \param string : String to modify
/// \param angle : Angle of rotation, in degrees
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_Rotate(sfString* String, float Angle);
CSFML_API void sfString_Rotate(sfString* string, float angle);
////////////////////////////////////////////////////////////
/// Transform a point from global coordinates into the string's local coordinates
/// (ie it applies the inverse of object's origin, translation, rotation and scale to the point)
///
/// \param String : String object
/// \param PointX : X coordinate of the point to transform
/// \param PointY : Y coordinate of the point to transform
/// \param X : Value to fill with the X coordinate of the converted point
/// \param Y : Value to fill with the y coordinate of the converted point
/// \param string : String object
/// \param pointX : X coordinate of the point to transform
/// \param pointY : Y coordinate of the point to transform
/// \param x : Value to fill with the X coordinate of the converted point
/// \param y : Value to fill with the y coordinate of the converted point
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_TransformToLocal(sfString* String, float PointX, float PointY, float* X, float* Y);
CSFML_API void sfString_TransformToLocal(sfString* string, float pointX, float pointY, float* x, float* y);
////////////////////////////////////////////////////////////
/// Transform a point from the string's local coordinates into global coordinates
/// (ie it applies the object's origin, translation, rotation and scale to the point)
///
/// \param String : String object
/// \param PointX : X coordinate of the point to transform
/// \param PointY : Y coordinate of the point to transform
/// \param X : Value to fill with the X coordinate of the converted point
/// \param Y : Value to fill with the y coordinate of the converted point
/// \param string : String object
/// \param pointX : X coordinate of the point to transform
/// \param pointY : Y coordinate of the point to transform
/// \param x : Value to fill with the X coordinate of the converted point
/// \param y : Value to fill with the y coordinate of the converted point
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_TransformToGlobal(sfString* String, float PointX, float PointY, float* X, float* Y);
CSFML_API void sfString_TransformToGlobal(sfString* string, float pointX, float pointY, float* X, float* y);
////////////////////////////////////////////////////////////
/// Set the text of a string (from a multibyte string)
///
/// \param String : String to modify
/// \param Text : New text
/// \param string : String to modify
/// \param text : New text
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_SetText(sfString* String, const char* Text);
CSFML_API void sfString_SetText(sfString* string, const char* text);
////////////////////////////////////////////////////////////
/// Set the text of a string (from a unicode string)
///
/// \param String : String to modify
/// \param Text : New text
/// \param string : String to modify
/// \param text : New text
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_SetUnicodeText(sfString* String, const sfUint32* Text);
CSFML_API void sfString_SetUnicodeText(sfString* string, const sfUint32* text);
////////////////////////////////////////////////////////////
/// Set the font of a string
///
/// \param String : String to modify
/// \param Font : Font to use
/// \param string : String to modify
/// \param font : Font to use
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_SetFont(sfString* String, sfFont* Font);
CSFML_API void sfString_SetFont(sfString* string, sfFont* font);
////////////////////////////////////////////////////////////
/// Set the size of a string
///
/// \param String : String to modify
/// \param Size : New size, in pixels
/// \param string : String to modify
/// \param size : New size, in pixels
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_SetSize(sfString* String, float Size);
CSFML_API void sfString_SetSize(sfString* string, float size);
////////////////////////////////////////////////////////////
/// Set the style of a string
///
/// \param String : String to modify
/// \param Size : New style (see sfStringStyle enum)
/// \param string : String to modify
/// \param style : New style (see sfStringStyle enum)
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_SetStyle(sfString* String, unsigned long Style);
CSFML_API void sfString_SetStyle(sfString* string, unsigned long style);
////////////////////////////////////////////////////////////
/// Get the text of a string (returns a unicode string)
///
/// \param String : String to read
/// \param string : String to read
///
/// \return Text as UTF-32
///
////////////////////////////////////////////////////////////
CSFML_API const sfUint32* sfString_GetUnicodeText(sfString* String);
CSFML_API const sfUint32* sfString_GetUnicodeText(sfString* string);
////////////////////////////////////////////////////////////
/// Get the text of a string (returns an ANSI string)
///
/// \param String : String to read
/// \param string : String to read
///
/// \return Text an a locale-dependant ANSI string
///
////////////////////////////////////////////////////////////
CSFML_API const char* sfString_GetText(sfString* String);
CSFML_API const char* sfString_GetText(sfString* string);
////////////////////////////////////////////////////////////
/// Get the font used by a string
///
/// \param String : String to read
/// \param string : String to read
///
/// \return Pointer to the font
///
////////////////////////////////////////////////////////////
CSFML_API sfFont* sfString_GetFont(sfString* String);
CSFML_API sfFont* sfString_GetFont(sfString* string);
////////////////////////////////////////////////////////////
/// Get the size of the characters of a string
///
/// \param String : String to read
/// \param string : String to read
///
/// \return Size of the characters
///
////////////////////////////////////////////////////////////
CSFML_API float sfString_GetSize(sfString* String);
CSFML_API float sfString_GetSize(sfString* string);
////////////////////////////////////////////////////////////
/// Get the style of a string
///
/// \param String : String to read
/// \param string : String to read
///
/// \return Current string style (see sfStringStyle enum)
///
////////////////////////////////////////////////////////////
CSFML_API unsigned long sfString_GetStyle(sfString* String);
CSFML_API unsigned long sfString_GetStyle(sfString* string);
////////////////////////////////////////////////////////////
/// Return the visual position of the Index-th character of the string,
/// in coordinates relative to the string
/// (note : translation, origin, rotation and scale are not applied)
///
/// \param String : String to read
/// \param Index : Index of the character
/// \param X : Value to fill with the X coordinate of the position
/// \param Y : Value to fill with the y coordinate of the position
/// \param string : String to read
/// \param index : Index of the character
/// \param x : Value to fill with the X coordinate of the position
/// \param y : Value to fill with the y coordinate of the position
///
////////////////////////////////////////////////////////////
CSFML_API void sfString_GetCharacterPos(sfString* String, size_t Index, float* X, float* Y);
CSFML_API void sfString_GetCharacterPos(sfString* string, size_t index, float* x, float* y);
////////////////////////////////////////////////////////////
/// Get the bounding rectangle of a string on screen
///
/// \param String : String to read
/// \param string : String to read
///
/// \return Rectangle contaning the string in screen coordinates
///
////////////////////////////////////////////////////////////
CSFML_API sfFloatRect sfString_GetRect(sfString* String);
CSFML_API sfFloatRect sfString_GetRect(sfString* string);
#endif // SFML_STRING_H

86
CSFML/include/SFML/Graphics/View.h
View File

@ -42,47 +42,47 @@ CSFML_API sfView* sfView_Create();
////////////////////////////////////////////////////////////
/// Construct a view from a rectangle
///
/// \param Rect : Rectangle defining the bounds of the view
/// \param rectangle : Rectangle defining the bounds of the view
///
////////////////////////////////////////////////////////////
CSFML_API sfView* sfView_CreateFromRect(sfFloatRect Rect);
CSFML_API sfView* sfView_CreateFromRect(sfFloatRect rectangle);
////////////////////////////////////////////////////////////
/// Destroy an existing view
///
/// \param View : View to destroy
/// \param view : View to destroy
///
////////////////////////////////////////////////////////////
CSFML_API void sfView_Destroy(sfView* View);
CSFML_API void sfView_Destroy(sfView* view);
////////////////////////////////////////////////////////////
/// Change the center of a view
///
/// \param View : View to modify
/// \param X : X coordinate of the new center
/// \param Y : Y coordinate of the new center
/// \param view : View to modify
/// \param x : X coordinate of the new center
/// \param y : Y coordinate of the new center
///
////////////////////////////////////////////////////////////
CSFML_API void sfView_SetCenter(sfView* View, float X, float Y);
CSFML_API void sfView_SetCenter(sfView* view, float x, float y);
////////////////////////////////////////////////////////////
/// Change the size of a view
///
/// \param View : View to modify
/// \param Width : New width
/// \param Height : New height
/// \param view : View to modify
/// \param width : New width
/// \param height : New height
///
////////////////////////////////////////////////////////////
CSFML_API void sfView_SetSize(sfView* View, float Width, float Height);
CSFML_API void sfView_SetSize(sfView* view, float width, float height);
////////////////////////////////////////////////////////////
/// Set the angle of rotation of a view
///
/// \param View : View to modify
/// \param Angle : New angle, in degrees
/// \param view : View to modify
/// \param angle : New angle, in degrees
///
////////////////////////////////////////////////////////////
CSFML_API void sfView_SetRotation(sfView* View, float Angle);
CSFML_API void sfView_SetRotation(sfView* view, float angle);
////////////////////////////////////////////////////////////
/// Set the target viewport of a view
@ -91,109 +91,109 @@ CSFML_API void sfView_SetRotation(sfView* View, float Angle);
/// view are displayed, expressed as a factor (between 0 and 1)
/// of the size of the RenderTarget to which the view is applied.
///
/// \param View : View to modify
/// \param Viewport : New viewport
/// \param view : View to modify
/// \param viewport : New viewport
///
////////////////////////////////////////////////////////////
CSFML_API void sfView_SetViewport(sfView* View, sfFloatRect Viewport);
CSFML_API void sfView_SetViewport(sfView* view, sfFloatRect viewport);
////////////////////////////////////////////////////////////
/// Reset a view to the given rectangle.
/// Note: this function resets the rotation angle to 0.
///
/// \param View : View to modify
/// \param Rectangle : Rectangle defining the position and size of the view
/// \param view : View to modify
/// \param rectangle : Rectangle defining the position and size of the view
///
////////////////////////////////////////////////////////////
CSFML_API void sfView_Reset(sfView* View, sfFloatRect Rectangle);
CSFML_API void sfView_Reset(sfView* view, sfFloatRect rectangle);
////////////////////////////////////////////////////////////
/// Get the X coordinate of the center of a view
///
/// \param View : View to read
/// \param view : View to read
///
/// \return X coordinate of the center of the view
///
////////////////////////////////////////////////////////////
CSFML_API float sfView_GetCenterX(sfView* View);
CSFML_API float sfView_GetCenterX(sfView* view);
////////////////////////////////////////////////////////////
/// Get the Y coordinate of the center of a view
///
/// \param View : View to read
/// \param view : View to read
///
/// \return Y coordinate of the center of the view
///
////////////////////////////////////////////////////////////
CSFML_API float sfView_GetCenterY(sfView* View);
CSFML_API float sfView_GetCenterY(sfView* view);
////////////////////////////////////////////////////////////
/// Get the width of the view
///
/// \param View : View to read
/// \param view : View to read
///
/// \return Width of the view
///
////////////////////////////////////////////////////////////
CSFML_API float sfView_GetWidth(sfView* View);
CSFML_API float sfView_GetWidth(sfView* view);
////////////////////////////////////////////////////////////
/// Get the height of the view
///
/// \param View : View to read
/// \param view : View to read
///
/// \return Height of the view
///
////////////////////////////////////////////////////////////
CSFML_API float sfView_GetHeight(sfView* View);
CSFML_API float sfView_GetHeight(sfView* view);
////////////////////////////////////////////////////////////
/// Get the current rotation of a view
///
/// \param View : View to read
/// \param view : View to read
///
/// \return Rotation of the view, in degrees
///
////////////////////////////////////////////////////////////
CSFML_API float sfView_GetRotation(sfView* View);
CSFML_API float sfView_GetRotation(sfView* view);
////////////////////////////////////////////////////////////
/// Get the target viewport of a view
///
/// \param View : View to read
/// \param view : View to read
///
/// \return Viewport rectangle, expressed as a factor of the target size
///
////////////////////////////////////////////////////////////
CSFML_API sfFloatRect sfView_GetViewport(sfView* View);
CSFML_API sfFloatRect sfView_GetViewport(sfView* view);
////////////////////////////////////////////////////////////
/// Move a view
///
/// \param View : View to move
/// \param OffsetX : Offset to move the view, on X axis
/// \param OffsetY : Offset to move the view, on Y axis
/// \param view : View to move
/// \param offsetX : Offset to move the view, on X axis
/// \param offsetY : Offset to move the view, on Y axis
///
////////////////////////////////////////////////////////////
CSFML_API void sfView_Move(sfView* View, float OffsetX, float OffsetY);
CSFML_API void sfView_Move(sfView* view, float offsetX, float offsetY);
////////////////////////////////////////////////////////////
/// Rotate a view
///
/// \param View : View to rotate
/// \param Angle : Angle in degrees
/// \param view : View to rotate
/// \param angle : Angle in degrees
///
////////////////////////////////////////////////////////////
CSFML_API void sfView_Rotate(sfView* View, float Angle);
CSFML_API void sfView_Rotate(sfView* view, float angle);
////////////////////////////////////////////////////////////
/// Resize a view rectangle to simulate a zoom / unzoom effect
///
/// \param View : View to zoom
/// \param Factor : Zoom factor to apply, relative to the current zoom
/// \param view : View to zoom
/// \param factor : Zoom factor to apply, relative to the current zoom
///
////////////////////////////////////////////////////////////
CSFML_API void sfView_Zoom(sfView* View, float Factor);
CSFML_API void sfView_Zoom(sfView* view, float factor);
#endif // SFML_VIEW_H

162
CSFML/include/SFML/Network/Ftp.h
View File

@ -114,151 +114,151 @@ enum sfFtpStatus
////////////////////////////////////////////////////////////
/// Destroy an existing Ftp listing response
///
/// \param FtpResponse : Ftp listing response to destroy
/// \param ftpListingResponse : Ftp listing response to destroy
///
////////////////////////////////////////////////////////////
CSFML_API void sfFtpListingResponse_Destroy(sfFtpListingResponse* FtpListingResponse);
CSFML_API void sfFtpListingResponse_Destroy(sfFtpListingResponse* ftpListingResponse);
////////////////////////////////////////////////////////////
/// Convenience function to check if the response status code
/// means a success
///
/// \param FtpListingResponse : Ftp listing response
/// \param ftpListingResponse : Ftp listing response
///
/// \return sfTrue if status is success (code < 400)
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfFtpListingResponse_IsOk(sfFtpListingResponse* FtpListingResponse);
CSFML_API sfBool sfFtpListingResponse_IsOk(sfFtpListingResponse* ftpListingResponse);
////////////////////////////////////////////////////////////
/// Get the response status code
///
/// \param FtpListingResponse : Ftp listing response
/// \param ftpListingResponse : Ftp listing response
///
/// \return Status code
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpStatus sfFtpListingResponse_GetStatus(sfFtpListingResponse* FtpListingResponse);
CSFML_API sfFtpStatus sfFtpListingResponse_GetStatus(sfFtpListingResponse* ftpListingResponse);
////////////////////////////////////////////////////////////
/// Get the full message contained in the response
///
/// \param FtpListingResponse : Ftp listing response
/// \param ftpListingResponse : Ftp listing response
///
/// \return The response message
///
////////////////////////////////////////////////////////////
CSFML_API const char* sfFtpListingResponse_GetMessage(sfFtpListingResponse* FtpListingResponse);
CSFML_API const char* sfFtpListingResponse_GetMessage(sfFtpListingResponse* ftpListingResponse);
////////////////////////////////////////////////////////////
/// Get the number of filenames in the listing
///
/// \param FtpListingResponse : Ftp listing response
/// \param ftpListingResponse : Ftp listing response
///
/// \return Total number of filenames
///
////////////////////////////////////////////////////////////
CSFML_API size_t sfFtpListingResponse_GetCount(sfFtpListingResponse* FtpListingResponse);
CSFML_API size_t sfFtpListingResponse_GetCount(sfFtpListingResponse* ftpListingResponse);
////////////////////////////////////////////////////////////
/// Get the Index-th filename in the directory
///
/// \param FtpListingResponse : Ftp listing response
/// \param Index : Index of the filename to get
/// \param ftpListingResponse : Ftp listing response
/// \param index : Index of the filename to get
///
/// \return Index-th filename
///
////////////////////////////////////////////////////////////
CSFML_API const char* sfFtpListingResponse_GetFilename(sfFtpListingResponse* FtpListingResponse, size_t Index);
CSFML_API const char* sfFtpListingResponse_GetFilename(sfFtpListingResponse* ftpListingResponse, size_t index);
////////////////////////////////////////////////////////////
/// Destroy an existing Ftp directory response
///
/// \param FtpDirectoryResponse : Ftp directory response to destroy
/// \param ftpDirectoryResponse : Ftp directory response to destroy
///
////////////////////////////////////////////////////////////
CSFML_API void sfFtpDirectoryResponse_Destroy(sfFtpDirectoryResponse* FtpDirectoryResponse);
CSFML_API void sfFtpDirectoryResponse_Destroy(sfFtpDirectoryResponse* ftpDirectoryResponse);
////////////////////////////////////////////////////////////
/// Convenience function to check if the response status code
/// means a success
///
/// \param FtpDirectoryResponse : Ftp directory response
/// \param ftpDirectoryResponse : Ftp directory response
///
/// \return sfTrue if status is success (code < 400)
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfFtpDirectoryResponse_IsOk(sfFtpDirectoryResponse* FtpDirectoryResponse);
CSFML_API sfBool sfFtpDirectoryResponse_IsOk(sfFtpDirectoryResponse* ftpDirectoryResponse);
////////////////////////////////////////////////////////////
/// Get the response status code
///
/// \param FtpDirectoryResponse : Ftp directory response
/// \param ftpDirectoryResponse : Ftp directory response
///
/// \return Status code
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpStatus sfFtpDirectoryResponse_GetStatus(sfFtpDirectoryResponse* FtpDirectoryResponse);
CSFML_API sfFtpStatus sfFtpDirectoryResponse_GetStatus(sfFtpDirectoryResponse* ftpDirectoryResponse);
////////////////////////////////////////////////////////////
/// Get the full message contained in the response
///
/// \param FtpDirectoryResponse : Ftp directory response
/// \param ftpDirectoryResponse : Ftp directory response
///
/// \return The response message
///
////////////////////////////////////////////////////////////
CSFML_API const char* sfFtpDirectoryResponse_GetMessage(sfFtpDirectoryResponse* FtpDirectoryResponse);
CSFML_API const char* sfFtpDirectoryResponse_GetMessage(sfFtpDirectoryResponse* ftpDirectoryResponse);
////////////////////////////////////////////////////////////
/// Get the directory returned in the response
///
/// \param FtpDirectoryResponse : Ftp directory response
/// \param ftpDirectoryResponse : Ftp directory response
///
/// \return Directory name
///
////////////////////////////////////////////////////////////
CSFML_API const char* sfFtpDirectoryResponse_GetDirectory(sfFtpDirectoryResponse* FtpDirectoryResponse);
CSFML_API const char* sfFtpDirectoryResponse_GetDirectory(sfFtpDirectoryResponse* ftpDirectoryResponse);
////////////////////////////////////////////////////////////
/// Destroy an existing Ftp response
///
/// \param FtpResponse : Ftp response to destroy
/// \param ftpResponse : Ftp response to destroy
///
////////////////////////////////////////////////////////////
CSFML_API void sfFtpResponse_Destroy(sfFtpResponse* FtpResponse);
CSFML_API void sfFtpResponse_Destroy(sfFtpResponse* ftpResponse);
////////////////////////////////////////////////////////////
/// Convenience function to check if the response status code
/// means a success
///
/// \param FtpResponse : Ftp response
/// \param ftpResponse : Ftp response
///
/// \return sfTrue if status is success (code < 400)
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfFtpResponse_IsOk(sfFtpResponse* FtpResponse);
CSFML_API sfBool sfFtpResponse_IsOk(sfFtpResponse* ftpResponse);
////////////////////////////////////////////////////////////
/// Get the response status code
///
/// \param FtpResponse : Ftp response
/// \param ftpResponse : Ftp response
///
/// \return Status code
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpStatus sfFtpResponse_GetStatus(sfFtpResponse* FtpResponse);
CSFML_API sfFtpStatus sfFtpResponse_GetStatus(sfFtpResponse* ftpResponse);
////////////////////////////////////////////////////////////
/// Get the full message contained in the response
///
/// \param FtpResponse : Ftp response
/// \param ftpResponse : Ftp response
///
/// \return The response message
///
////////////////////////////////////////////////////////////
CSFML_API const char* sfFtpResponse_GetMessage(sfFtpResponse* FtpResponse);
CSFML_API const char* sfFtpResponse_GetMessage(sfFtpResponse* ftpResponse);
////////////////////////////////////////////////////////////
/// Construct a new Ftp
@ -271,179 +271,179 @@ CSFML_API sfFtp* sfFtp_Create();
////////////////////////////////////////////////////////////
/// Destroy an existing Ftp
///
/// \param Ftp : Ftp to destroy
/// \param ftp : Ftp to destroy
///
////////////////////////////////////////////////////////////
CSFML_API void sfFtp_Destroy(sfFtp* Ftp);
CSFML_API void sfFtp_Destroy(sfFtp* ftp);
////////////////////////////////////////////////////////////
/// Connect to the specified FTP server
///
/// \param Ftp : Ftp instance
/// \param Server : FTP server to connect to
/// \param Port : Port used for connection (21 by default, standard FTP port)
/// \param Timeout : Maximum time to wait (0 to use no timeout)
/// \param ftp : Ftp instance
/// \param server : FTP server to connect to
/// \param port : Port used for connection (21 by default, standard FTP port)
/// \param timeout : Maximum time to wait (0 to use no timeout)
///
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpResponse* sfFtp_Connect(sfFtp* Ftp, sfIPAddress Server, unsigned short Port, float Timeout);
CSFML_API sfFtpResponse* sfFtp_Connect(sfFtp* ftp, sfIPAddress server, unsigned short port, float timeout);
////////////////////////////////////////////////////////////
/// Log in using anonymous account
///
/// \param Ftp : Ftp instance
/// \param ftp : Ftp instance
///
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpResponse* sfFtp_LoginAnonymous(sfFtp* Ftp);
CSFML_API sfFtpResponse* sfFtp_LoginAnonymous(sfFtp* ftp);
////////////////////////////////////////////////////////////
/// Log in using a username and a password
///
/// \param Ftp : Ftp instance
/// \param UserName : User name
/// \param Password : Password
/// \param ftp : Ftp instance
/// \param userName : User name
/// \param password : Password
///
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpResponse* sfFtp_Login(sfFtp* Ftp, const char* UserName, const char* Password);
CSFML_API sfFtpResponse* sfFtp_Login(sfFtp* ftp, const char* userName, const char* password);
////////////////////////////////////////////////////////////
/// Close the connection with FTP server
///
/// \param Ftp : Ftp instance
/// \param ftp : Ftp instance
///
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpResponse* sfFtp_Disconnect(sfFtp* Ftp);
CSFML_API sfFtpResponse* sfFtp_Disconnect(sfFtp* ftp);
////////////////////////////////////////////////////////////
/// Send a null command just to prevent from being disconnected
///
/// \param Ftp : Ftp instance
/// \param ftp : Ftp instance
///
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpResponse* sfFtp_KeepAlive(sfFtp* Ftp);
CSFML_API sfFtpResponse* sfFtp_KeepAlive(sfFtp* ftp);
////////////////////////////////////////////////////////////
/// Get the current working directory
///
/// \param Ftp : Ftp instance
/// \param ftp : Ftp instance
///
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpDirectoryResponse* sfFtp_GetWorkingDirectory(sfFtp* Ftp);
CSFML_API sfFtpDirectoryResponse* sfFtp_GetWorkingDirectory(sfFtp* ftp);
////////////////////////////////////////////////////////////
/// Get the contents of the given directory
/// (subdirectories and files)
///
/// \param Ftp : Ftp instance
/// \param Directory : Directory to list ("" by default, the current one)
/// \param ftp : Ftp instance
/// \param directory : Directory to list ("" by default, the current one)
///
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpListingResponse* sfFtp_GetDirectoryListing(sfFtp* Ftp, const char* Directory);
CSFML_API sfFtpListingResponse* sfFtp_GetDirectoryListing(sfFtp* ftp, const char* directory);
////////////////////////////////////////////////////////////
/// Change the current working directory
///
/// \param Ftp : Ftp instance
/// \param Directory : New directory, relative to the current one
/// \param ftp : Ftp instance
/// \param directory : New directory, relative to the current one
///
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpResponse* sfFtp_ChangeDirectory(sfFtp* Ftp, const char* Directory);
CSFML_API sfFtpResponse* sfFtp_ChangeDirectory(sfFtp* ftp, const char* directory);
////////////////////////////////////////////////////////////
/// Go to the parent directory of the current one
///
/// \param Ftp : Ftp instance
/// \param ftp : Ftp instance
///
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpResponse* sfFtp_ParentDirectory(sfFtp* Ftp);
CSFML_API sfFtpResponse* sfFtp_ParentDirectory(sfFtp* ftp);
////////////////////////////////////////////////////////////
/// Create a new directory
///
/// \param Ftp : Ftp instance
/// \param Name : Name of the directory to create
/// \param ftp : Ftp instance
/// \param name : Name of the directory to create
///
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpResponse* sfFtp_MakeDirectory(sfFtp* Ftp, const char* Name);
CSFML_API sfFtpResponse* sfFtp_MakeDirectory(sfFtp* ftp, const char* name);
////////////////////////////////////////////////////////////
/// Remove an existing directory
///
/// \param Ftp : Ftp instance
/// \param Name : Name of the directory to remove
/// \param ftp : Ftp instance
/// \param name : Name of the directory to remove
///
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpResponse* sfFtp_DeleteDirectory(sfFtp* Ftp, const char* Name);
CSFML_API sfFtpResponse* sfFtp_DeleteDirectory(sfFtp* ftp, const char* name);
////////////////////////////////////////////////////////////
/// Rename a file
///
/// \param Ftp : Ftp instance
/// \param File : File to rename
/// \param NewName : New name
/// \param ftp : Ftp instance
/// \param file : File to rename
/// \param newName : New name
///
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpResponse* sfFtp_RenameFile(sfFtp* Ftp, const char* File, const char* NewName);
CSFML_API sfFtpResponse* sfFtp_RenameFile(sfFtp* ftp, const char* file, const char* newName);
////////////////////////////////////////////////////////////
/// Remove an existing file
///
/// \param Ftp : Ftp instance
/// \param Name : File to remove
/// \param ftp : Ftp instance
/// \param name : File to remove
///
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpResponse* sfFtp_DeleteFile(sfFtp* Ftp, const char* Name);
CSFML_API sfFtpResponse* sfFtp_DeleteFile(sfFtp* ftp, const char* name);
////////////////////////////////////////////////////////////
/// Download a file from the server
///
/// \param Ftp : Ftp instance
/// \param DistantFile : Path of the distant file to download
/// \param DestPath : Where to put to file on the local computer
/// \param Mode : Transfer mode (binary by default)
/// \param ftp : Ftp instance
/// \param distantFile : Path of the distant file to download
/// \param destPath : Where to put to file on the local computer
/// \param mode : Transfer mode (binary by default)
///
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpResponse* sfFtp_Download(sfFtp* Ftp, const char* DistantFile, const char* DestPath, sfFtpTransferMode Mode);
CSFML_API sfFtpResponse* sfFtp_Download(sfFtp* ftp, const char* distantFile, const char* destPath, sfFtpTransferMode mode);
////////////////////////////////////////////////////////////
/// Upload a file to the server
///
/// \param Ftp : Ftp instance
/// \param LocalFile : Path of the local file to upload
/// \param DestPath : Where to put to file on the server
/// \param Mode : Transfer mode (binary by default)
/// \param ftp : Ftp instance
/// \param localFile : Path of the local file to upload
/// \param destPath : Where to put to file on the server
/// \param mode : Transfer mode (binary by default)
///
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpResponse* sfFtp_Upload(sfFtp* Ftp, const char* LocalFile, const char* DestPath, sfFtpTransferMode Mode);
CSFML_API sfFtpResponse* sfFtp_Upload(sfFtp* ftp, const char* localFile, const char* destPath, sfFtpTransferMode mode);
#endif // SFML_FTP_H

80
CSFML/include/SFML/Network/Http.h
View File

@ -90,111 +90,111 @@ CSFML_API sfHttpRequest* sfHttpRequest_Create();
////////////////////////////////////////////////////////////
/// Destroy an existing Http request
///
/// \param HttpRequest : Http request to destroy
/// \param httpRequest : Http request to destroy
///
////////////////////////////////////////////////////////////
CSFML_API void sfHttpRequest_Destroy(sfHttpRequest* HttpRequest);
CSFML_API void sfHttpRequest_Destroy(sfHttpRequest* httpRequest);
////////////////////////////////////////////////////////////
/// Set the value of a field; the field is added if it doesn't exist
///
/// \param HttpRequest : Http request to modify
/// \param Field : Name of the field to set (case-insensitive)
/// \param Value : Value of the field
/// \param httpRequest : Http request to modify
/// \param field : Name of the field to set (case-insensitive)
/// \param value : Value of the field
///
////////////////////////////////////////////////////////////
CSFML_API void sfHttpRequest_SetField(sfHttpRequest* HttpRequest, const char* Field, const char* Value);
CSFML_API void sfHttpRequest_SetField(sfHttpRequest* httpRequest, const char* field, const char* value);
////////////////////////////////////////////////////////////
/// Set the request method.
/// This parameter is sfHttpGet by default
///
/// \param HttpRequest : Http request to modify
/// \param RequestMethod : Method to use for the request
/// \param httpRequest : Http request to modify
/// \param method : Method to use for the request
///
////////////////////////////////////////////////////////////
CSFML_API void sfHttpRequest_SetMethod(sfHttpRequest* HttpRequest, sfHttpMethod Method);
CSFML_API void sfHttpRequest_SetMethod(sfHttpRequest* httpRequest, sfHttpMethod method);
////////////////////////////////////////////////////////////
/// Set the target URI of the request.
/// This parameter is "/" by default
///
/// \param HttpRequest : Http request to modify
/// \param httpRequest : Http request to modify
/// \param URI : URI to request, local to the host
///
////////////////////////////////////////////////////////////
CSFML_API void sfHttpRequest_SetURI(sfHttpRequest* HttpRequest, const char* URI);
CSFML_API void sfHttpRequest_SetURI(sfHttpRequest* httpRequest, const char* URI);
////////////////////////////////////////////////////////////
/// Set the HTTP version of the request.
/// This parameter is 1.0 by default
///
/// \param HttpRequest : Http request to modify
/// \param Major : Major version number
/// \param Minor : Minor version number
/// \param httpRequest : Http request to modify
/// \param major : Major version number
/// \param minor : Minor version number
///
////////////////////////////////////////////////////////////
CSFML_API void sfHttpRequest_SetHttpVersion(sfHttpRequest* HttpRequest, unsigned int Major, unsigned int Minor);
CSFML_API void sfHttpRequest_SetHttpVersion(sfHttpRequest* httpRequest, unsigned int major, unsigned int minor);
////////////////////////////////////////////////////////////
/// Set the body of the request. This parameter is optional and
/// makes sense only for POST requests.
/// This parameter is empty by default
///
/// \param HttpRequest : Http request to modify
/// \param Body : Content of the request body
/// \param httpRequest : Http request to modify
/// \param body : Content of the request body
///
////////////////////////////////////////////////////////////
CSFML_API void sfHttpRequest_SetBody(sfHttpRequest* HttpRequest, const char* Body);
CSFML_API void sfHttpRequest_SetBody(sfHttpRequest* httpRequest, const char* body);
////////////////////////////////////////////////////////////
/// Destroy an existing Http response
///
/// \param HttpResponse : Http response to destroy
/// \param httpResponse : Http response to destroy
///
////////////////////////////////////////////////////////////
CSFML_API void sfHttpResponse_Destroy(sfHttpResponse* HttpResponse);
CSFML_API void sfHttpResponse_Destroy(sfHttpResponse* httpResponse);
////////////////////////////////////////////////////////////
/// Get the value of a field; returns NULL if the field doesn't exist
///
/// \param HttpResponse : Http response
/// \param Field : Field to get
/// \param httpResponse : Http response
/// \param field : Field to get
///
/// \return Value of the field (NULL if it doesn't exist)
///
////////////////////////////////////////////////////////////
CSFML_API const char* sfHttpResponse_GetField(sfHttpResponse* HttpResponse, const char* Field);
CSFML_API const char* sfHttpResponse_GetField(sfHttpResponse* httpResponse, const char* field);
////////////////////////////////////////////////////////////
/// Get the status of a response
///
/// \param HttpResponse : Http response
/// \param httpResponse : Http response
///
/// \return Status of the response
///
////////////////////////////////////////////////////////////
CSFML_API sfHttpStatus sfHttpResponse_GetStatus(sfHttpResponse* HttpResponse);
CSFML_API sfHttpStatus sfHttpResponse_GetStatus(sfHttpResponse* httpResponse);
////////////////////////////////////////////////////////////
/// Get the major HTTP version of a response
///
/// \param HttpResponse : Http response
/// \param httpResponse : Http response
///
/// \return HTTP major version of the response
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfHttpResponse_GetMajorVersion(sfHttpResponse* HttpResponse);
CSFML_API unsigned int sfHttpResponse_GetMajorVersion(sfHttpResponse* httpResponse);
////////////////////////////////////////////////////////////
/// Get the minor HTTP version of a response
///
/// \param HttpResponse : Http response
/// \param httpResponse : Http response
///
/// \return HTTP minor version of the response
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfHttpResponse_GetMinorVersion(sfHttpResponse* HttpResponse);
CSFML_API unsigned int sfHttpResponse_GetMinorVersion(sfHttpResponse* httpResponse);
////////////////////////////////////////////////////////////
/// Get the body of the response. The body can contain :
@ -203,12 +203,12 @@ CSFML_API unsigned int sfHttpResponse_GetMinorVersion(sfHttpResponse* HttpRespon
/// - nothing (for HEAD requests)
/// - an error message (in case of an error)
///
/// \param HttpResponse : Http response
/// \param httpResponse : Http response
///
/// \return Body of the response (empty string if no body)
///
////////////////////////////////////////////////////////////
CSFML_API const char* sfHttpResponse_GetBody(sfHttpResponse* HttpResponse);
CSFML_API const char* sfHttpResponse_GetBody(sfHttpResponse* httpResponse);
////////////////////////////////////////////////////////////
/// Construct a new Http object
@ -224,17 +224,17 @@ CSFML_API sfHttp* sfHttp_Create();
/// \param Http : Http to destroy
///
////////////////////////////////////////////////////////////
CSFML_API void sfHttp_Destroy(sfHttp* Http);
CSFML_API void sfHttp_Destroy(sfHttp* http);
////////////////////////////////////////////////////////////
/// Set the target host of a Http server
///
/// \param Http : Http object
/// \param Host : Web server to connect to
/// \param Port : Port to use for connection (0 to use the standard port of the protocol used)
/// \param http : Http object
/// \param host : Web server to connect to
/// \param port : Port to use for connection (0 to use the standard port of the protocol used)
///
////////////////////////////////////////////////////////////
CSFML_API void sfHttp_SetHost(sfHttp* Http, const char* Host, unsigned short Port);
CSFML_API void sfHttp_SetHost(sfHttp* http, const char* host, unsigned short port);
////////////////////////////////////////////////////////////
/// Send a HTTP request and return the server's response.
@ -244,14 +244,14 @@ CSFML_API void sfHttp_SetHost(sfHttp* Http, const char* Host, unsigned short Por
/// not return instantly; use a thread if you don't want to block your
/// application.
///
/// \param Http : Http object
/// \param Request : Request to send
/// \param Timeout : Maximum time to wait (0 to use no timeout)
/// \param http : Http object
/// \param request : Request to send
/// \param timeout : Maximum time to wait (0 to use no timeout)
///
/// \return Server's response, or NULL if request is invalid
///
////////////////////////////////////////////////////////////
CSFML_API sfHttpResponse* sfHttp_SendRequest(sfHttp* Http, sfHttpRequest* Request, float Timeout);
CSFML_API sfHttpResponse* sfHttp_SendRequest(sfHttp* http, sfHttpRequest* request, float timeout);
#endif // SFML_HTTP_H

36
CSFML/include/SFML/Network/IPAddress.h
View File

@ -43,62 +43,62 @@ typedef struct
////////////////////////////////////////////////////////////
/// Construct an address from a string
///
/// \param String : IP address ("xxx.xxx.xxx.xxx") or network name
/// \param string : IP address ("xxx.xxx.xxx.xxx") or network name
///
/// \return Resulting address
///
////////////////////////////////////////////////////////////
CSFML_API sfIPAddress sfIPAddress_FromString(const char* String);
CSFML_API sfIPAddress sfIPAddress_FromString(const char* string);
////////////////////////////////////////////////////////////
/// Construct an address from 4 bytes
///
/// \param Byte0 : First byte of the address
/// \param Byte1 : Second byte of the address
/// \param Byte2 : Third byte of the address
/// \param Byte3 : Fourth byte of the address
/// \param byte0 : First byte of the address
/// \param byte1 : Second byte of the address
/// \param byte2 : Third byte of the address
/// \param byte3 : Fourth byte of the address
///
/// \return Resulting address
///
////////////////////////////////////////////////////////////
CSFML_API sfIPAddress sfIPAddress_FromBytes(sfUint8 Byte0, sfUint8 Byte1, sfUint8 Byte2, sfUint8 Byte3);
CSFML_API sfIPAddress sfIPAddress_FromBytes(sfUint8 byte0, sfUint8 byte1, sfUint8 byte2, sfUint8 byte3);
////////////////////////////////////////////////////////////
/// Construct the address from a 32-bits integer
///
/// \param Address : 4 bytes of the address packed into a 32-bits integer
/// \param address : 4 bytes of the address packed into a 32-bits integer
///
////////////////////////////////////////////////////////////
CSFML_API sfIPAddress sfIPAddress_FromInteger(sfUint32 Address);
CSFML_API sfIPAddress sfIPAddress_FromInteger(sfUint32 address);
////////////////////////////////////////////////////////////
/// Tell if an address is a valid one
///
/// \param Address : Address to check
/// \param address : Address to check
///
/// \return sfTrue if address has a valid syntax
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfIPAddress_IsValid(sfIPAddress Address);
CSFML_API sfBool sfIPAddress_IsValid(sfIPAddress address);
////////////////////////////////////////////////////////////
/// Get a string representation of an address
///
/// \param Address : Address to convert
/// \param String : Char array to fill (size must be >= 16)
/// \param address : Address to convert
/// \param string : Char array to fill (size must be >= 16)
///
////////////////////////////////////////////////////////////
CSFML_API void sfIPAddress_ToString(sfIPAddress Address, char* String);
CSFML_API void sfIPAddress_ToString(sfIPAddress address, char* string);
////////////////////////////////////////////////////////////
/// Get an integer representation of the address
///
/// \param Address : Address to convert
/// \param address : Address to convert
///
/// \return 32-bits integer containing the 4 bytes of the address, in system endianness
///
////////////////////////////////////////////////////////////
CSFML_API sfUint32 sfIPAddress_ToInteger(sfIPAddress Address);
CSFML_API sfUint32 sfIPAddress_ToInteger(sfIPAddress address);
////////////////////////////////////////////////////////////
/// Get the computer's local IP address (from the LAN point of view)
@ -114,12 +114,12 @@ CSFML_API sfIPAddress sfIPAddress_GetLocalAddress();
/// distant website ; as a consequence, this function may be
/// very slow -- use it as few as possible !
///
/// \param Timeout : Maximum time to wait, in seconds (use 0 for no timeout)
/// \param timeout : Maximum time to wait, in seconds (use 0 for no timeout)
///
/// \return Public IP address
///
////////////////////////////////////////////////////////////
CSFML_API sfIPAddress sfIPAddress_GetPublicAddress(float Timeout);
CSFML_API sfIPAddress sfIPAddress_GetPublicAddress(float timeout);
////////////////////////////////////////////////////////////
/// Get the computer's loopback address

80
CSFML/include/SFML/Network/Packet.h
View File

@ -43,106 +43,106 @@ CSFML_API sfPacket* sfPacket_Create();
////////////////////////////////////////////////////////////
/// Destroy an existing packet
///
/// \param Packet : Packet to delete
/// \param packet : Packet to delete
///
////////////////////////////////////////////////////////////
CSFML_API void sfPacket_Destroy(sfPacket* Packet);
CSFML_API void sfPacket_Destroy(sfPacket* packet);
////////////////////////////////////////////////////////////
/// Append data to the end of a packet
///
/// \param Packet : Packet to fill
/// \param Data : Pointer to the bytes to append
/// \param SizeInBytes : Number of bytes to append
/// \param packet : Packet to fill
/// \param data : Pointer to the bytes to append
/// \param sizeInBytes : Number of bytes to append
///
////////////////////////////////////////////////////////////
CSFML_API void sfPacket_Append(sfPacket* Packet, void* Data, size_t SizeInBytes);
CSFML_API void sfPacket_Append(sfPacket* packet, void* data, size_t sizeInBytes);
////////////////////////////////////////////////////////////
/// Clear all the data of a packet
///
/// \param Packet : Packet to clear
/// \param packet : Packet to clear
///
///////////////////////////////////////////////////////////
CSFML_API void sfPacket_Clear(sfPacket* Packet);
CSFML_API void sfPacket_Clear(sfPacket* packet);
////////////////////////////////////////////////////////////
/// Get a pointer to the data contained in a packet
/// Warning : the returned pointer may be invalid after you
/// append data to the packet
///
/// \param Packet : Packet to get data from
/// \param packet : Packet to get data from
///
/// \return Pointer to the data
///
////////////////////////////////////////////////////////////
CSFML_API const char* sfPacket_GetData(sfPacket* Packet);
CSFML_API const char* sfPacket_GetData(sfPacket* packet);
////////////////////////////////////////////////////////////
/// Get the size of the data contained in a packet
///
/// \param Packet : Packet to get data size from
/// \param packet : Packet to get data size from
///
/// \return Data size, in bytes
///
////////////////////////////////////////////////////////////
CSFML_API size_t sfPacket_GetDataSize(sfPacket* Packet);
CSFML_API size_t sfPacket_GetDataSize(sfPacket* packet);
////////////////////////////////////////////////////////////
/// Tell if the reading position has reached the end of the packet
///
/// \param Packet : Packet to check
/// \param packet : Packet to check
///
/// \return sfTrue if all data have been read into the packet
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfPacket_EndOfPacket(sfPacket* Packet);
CSFML_API sfBool sfPacket_EndOfPacket(sfPacket* packet);
////////////////////////////////////////////////////////////
/// Return the validity of packet
///
/// \param Packet : Packet to check
/// \param packet : Packet to check
///
/// \return sfTrue if last data extraction from packet was successful
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfPacket_CanRead(sfPacket* Packet);
CSFML_API sfBool sfPacket_CanRead(sfPacket* packet);
////////////////////////////////////////////////////////////
/// Functions to extract data from a packet
///
/// \param Packet : Packet to read
/// \param packet : Packet to read
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfPacket_ReadBool(sfPacket* Packet);
CSFML_API sfInt8 sfPacket_ReadInt8(sfPacket* Packet);
CSFML_API sfUint8 sfPacket_ReadUint8(sfPacket* Packet);
CSFML_API sfInt16 sfPacket_ReadInt16(sfPacket* Packet);
CSFML_API sfUint16 sfPacket_ReadUint16(sfPacket* Packet);
CSFML_API sfInt32 sfPacket_ReadInt32(sfPacket* Packet);
CSFML_API sfUint32 sfPacket_ReadUint32(sfPacket* Packet);
CSFML_API float sfPacket_ReadFloat(sfPacket* Packet);
CSFML_API double sfPacket_ReadDouble(sfPacket* Packet);
CSFML_API void sfPacket_ReadString(sfPacket* Packet, char* String);
CSFML_API void sfPacket_ReadWideString(sfPacket* Packet, wchar_t* String);
CSFML_API sfBool sfPacket_ReadBool(sfPacket* packet);
CSFML_API sfInt8 sfPacket_ReadInt8(sfPacket* packet);
CSFML_API sfUint8 sfPacket_ReadUint8(sfPacket* packet);
CSFML_API sfInt16 sfPacket_ReadInt16(sfPacket* packet);
CSFML_API sfUint16 sfPacket_ReadUint16(sfPacket* packet);
CSFML_API sfInt32 sfPacket_ReadInt32(sfPacket* packet);
CSFML_API sfUint32 sfPacket_ReadUint32(sfPacket* packet);
CSFML_API float sfPacket_ReadFloat(sfPacket* packet);
CSFML_API double sfPacket_ReadDouble(sfPacket* packet);
CSFML_API void sfPacket_ReadString(sfPacket* packet, char* string);
CSFML_API void sfPacket_ReadWideString(sfPacket* packet, wchar_t* string);
////////////////////////////////////////////////////////////
/// Functions to insert data into a packet
///
/// \param Packet : Packet to write
/// \param packet : Packet to write
///
////////////////////////////////////////////////////////////
CSFML_API void sfPacket_WriteBool(sfPacket* Packet, sfBool);
CSFML_API void sfPacket_WriteInt8(sfPacket* Packet, sfInt8);
CSFML_API void sfPacket_WriteUint8(sfPacket* Packet, sfUint8);
CSFML_API void sfPacket_WriteInt16(sfPacket* Packet, sfInt16);
CSFML_API void sfPacket_WriteUint16(sfPacket* Packet, sfUint16);
CSFML_API void sfPacket_WriteInt32(sfPacket* Packet, sfInt32);
CSFML_API void sfPacket_WriteUint32(sfPacket* Packet, sfUint32);
CSFML_API void sfPacket_WriteFloat(sfPacket* Packet, float);
CSFML_API void sfPacket_WriteDouble(sfPacket* Packet, double);
CSFML_API void sfPacket_WriteString(sfPacket* Packet, const char* String);
CSFML_API void sfPacket_WriteWideString(sfPacket* Packet, const wchar_t* String);
CSFML_API void sfPacket_WriteBool(sfPacket* packet, sfBool);
CSFML_API void sfPacket_WriteInt8(sfPacket* packet, sfInt8);
CSFML_API void sfPacket_WriteUint8(sfPacket* packet, sfUint8);
CSFML_API void sfPacket_WriteInt16(sfPacket* packet, sfInt16);
CSFML_API void sfPacket_WriteUint16(sfPacket* packet, sfUint16);
CSFML_API void sfPacket_WriteInt32(sfPacket* packet, sfInt32);
CSFML_API void sfPacket_WriteUint32(sfPacket* packet, sfUint32);
CSFML_API void sfPacket_WriteFloat(sfPacket* packet, float);
CSFML_API void sfPacket_WriteDouble(sfPacket* packet, double);
CSFML_API void sfPacket_WriteString(sfPacket* packet, const char* string);
CSFML_API void sfPacket_WriteWideString(sfPacket* packet, const wchar_t* string);
#endif // SFML_PACKET_H

44
CSFML/include/SFML/Network/Selector.h
View File

@ -44,68 +44,68 @@ CSFML_API sfSelectorUDP* sfSelectorUDP_Create();
////////////////////////////////////////////////////////////
/// Destroy an existing selector
///
/// \param Selector : Selector to delete
/// \param selector : Selector to delete
///
////////////////////////////////////////////////////////////
CSFML_API void sfSelectorTCP_Destroy(sfSelectorTCP* Selector);
CSFML_API void sfSelectorUDP_Destroy(sfSelectorUDP* Selector);
CSFML_API void sfSelectorTCP_Destroy(sfSelectorTCP* selector);
CSFML_API void sfSelectorUDP_Destroy(sfSelectorUDP* selector);
////////////////////////////////////////////////////////////
/// Add a socket to watch to a selector
///
/// \param Selector : Selector to add the socket to
/// \param Socket : Socket to add
/// \param selector : Selector to add the socket to
/// \param socket : Socket to add
///
////////////////////////////////////////////////////////////
CSFML_API void sfSelectorTCP_Add(sfSelectorTCP* Selector, sfSocketTCP* Socket);
CSFML_API void sfSelectorUDP_Add(sfSelectorUDP* Selector, sfSocketUDP* Socket);
CSFML_API void sfSelectorTCP_Add(sfSelectorTCP* selector, sfSocketTCP* socket);
CSFML_API void sfSelectorUDP_Add(sfSelectorUDP* selector, sfSocketUDP* socket);
////////////////////////////////////////////////////////////
/// Remove a socket from a selector
///
/// \param Selector : Selector to remove the socket from
/// \param Socket : Socket to remove
/// \param selector : Selector to remove the socket from
/// \param socket : Socket to remove
///
////////////////////////////////////////////////////////////
CSFML_API void sfSelectorTCP_Remove(sfSelectorTCP* Selector, sfSocketTCP* Socket);
CSFML_API void sfSelectorUDP_Remove(sfSelectorUDP* Selector, sfSocketUDP* Socket);
CSFML_API void sfSelectorTCP_Remove(sfSelectorTCP* selector, sfSocketTCP* socket);
CSFML_API void sfSelectorUDP_Remove(sfSelectorUDP* selector, sfSocketUDP* socket);
////////////////////////////////////////////////////////////
/// Remove all sockets from a selector
///
/// \param Selector : Selector to remove the socket from
/// \param selector : Selector to remove the socket from
///
////////////////////////////////////////////////////////////
CSFML_API void sfSelectorTCP_Clear(sfSelectorTCP* Selector);
CSFML_API void sfSelectorUDP_Clear(sfSelectorUDP* Selector);
CSFML_API void sfSelectorTCP_Clear(sfSelectorTCP* selector);
CSFML_API void sfSelectorUDP_Clear(sfSelectorUDP* selector);
////////////////////////////////////////////////////////////
/// Wait and collect sockets which are ready for reading.
/// This functions will return either when at least one socket
/// is ready, or when the given time is out
///
/// \param Selector : Selector to check
/// \param Timeout : Maximum time to wait, in seconds (0 to disable timeout)
/// \param selector : Selector to check
/// \param timeout : Maximum time to wait, in seconds (0 to disable timeout)
///
/// \return Number of sockets ready
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfSelectorTCP_Wait(sfSelectorTCP* Selector, float Timeout);
CSFML_API unsigned int sfSelectorUDP_Wait(sfSelectorUDP* Selector, float Timeout);
CSFML_API unsigned int sfSelectorTCP_Wait(sfSelectorTCP* selector, float timeout);
CSFML_API unsigned int sfSelectorUDP_Wait(sfSelectorUDP* selector, float timeout);
////////////////////////////////////////////////////////////
/// After a call to Wait(), get the Index-th socket which is
/// ready for reading. The total number of sockets ready
/// is the integer returned by the previous call to Wait()
///
/// \param Selector : Selector to check
/// \param Index : Index of the socket to get
/// \param selector : Selector to check
/// \param index : Index of the socket to get
///
/// \return The Index-th socket
///
////////////////////////////////////////////////////////////
CSFML_API sfSocketTCP* sfSelectorTCP_GetSocketReady(sfSelectorTCP* Selector, unsigned int Index);
CSFML_API sfSocketUDP* sfSelectorUDP_GetSocketReady(sfSelectorUDP* Selector, unsigned int Index);
CSFML_API sfSocketTCP* sfSelectorTCP_GetSocketReady(sfSelectorTCP* selector, unsigned int index);
CSFML_API sfSocketUDP* sfSelectorUDP_GetSocketReady(sfSelectorUDP* selector, unsigned int index);
#endif // SFML_SELECTOR_H

68
CSFML/include/SFML/Network/SocketTCP.h
View File

@ -45,116 +45,116 @@ CSFML_API sfSocketTCP* sfSocketTCP_Create();
////////////////////////////////////////////////////////////
/// Destroy an existing TCP socket
///
/// \param Socket : Socket to destroy
/// \param socket : Socket to destroy
///
////////////////////////////////////////////////////////////
CSFML_API void sfSocketTCP_Destroy(sfSocketTCP* Socket);
CSFML_API void sfSocketTCP_Destroy(sfSocketTCP* socket);
////////////////////////////////////////////////////////////
/// Change the blocking state of a TCP socket.
/// The default behaviour of a socket is blocking
///
/// \param Socket : Socket to modify
/// \param Blocking : Pass sfTrue to set the socket as blocking, or false for non-blocking
/// \param socket : Socket to modify
/// \param blocking : Pass sfTrue to set the socket as blocking, or false for non-blocking
///
////////////////////////////////////////////////////////////
CSFML_API void sfSocketTCP_SetBlocking(sfSocketTCP* Socket, sfBool Blocking);
CSFML_API void sfSocketTCP_SetBlocking(sfSocketTCP* socket, sfBool blocking);
////////////////////////////////////////////////////////////
/// Connect a TCP socket to another computer on a specified port
///
/// \param Socket : Socket to use for connecting
/// \param Port : Port to use for transfers (warning : ports < 1024 are reserved)
/// \param HostAddress : IP Address of the host to connect to
/// \param Timeout : Maximum time to wait (0 to use no timeout)
/// \param socket : Socket to use for connecting
/// \param port : Port to use for transfers (warning : ports < 1024 are reserved)
/// \param host : IP Address of the host to connect to
/// \param timeout : Maximum time to wait (0 to use no timeout)
///
/// \return sfTrue if operation has been successful
///
////////////////////////////////////////////////////////////
CSFML_API sfSocketStatus sfSocketTCP_Connect(sfSocketTCP* Socket, unsigned short Port, sfIPAddress HostAddress, float Timeout);
CSFML_API sfSocketStatus sfSocketTCP_Connect(sfSocketTCP* socket, unsigned short port, sfIPAddress host, float timeout);
////////////////////////////////////////////////////////////
/// Listen to a specified port for incoming data or connections
///
/// \param Socket : Socket to use for listening
/// \param Port : Port to listen to
/// \param socket : Socket to use for listening
/// \param port : Port to listen to
///
/// \return sfTrue if operation has been successful
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfSocketTCP_Listen(sfSocketTCP* Socket, unsigned short Port);
CSFML_API sfBool sfSocketTCP_Listen(sfSocketTCP* socket, unsigned short port);
////////////////////////////////////////////////////////////
/// Wait for a connection (must be listening to a port).
/// This function is blocking, ie. it won't return before
/// a connection has been accepted
///
/// \param Socket : Socket to use for accepting
/// \param Connected : Pointer to a socket pointer that will be filled with the connected client
/// \param Address : Pointer to an address to fill with client infos
/// \param socket : Socket to use for accepting
/// \param connected : Pointer to a socket pointer that will be filled with the connected client
/// \param address : Pointer to an address to fill with client infos
///
/// \return Socket status
///
////////////////////////////////////////////////////////////
CSFML_API sfSocketStatus sfSocketTCP_Accept(sfSocketTCP* Socket, sfSocketTCP** Connected, sfIPAddress* Address);
CSFML_API sfSocketStatus sfSocketTCP_Accept(sfSocketTCP* socket, sfSocketTCP** connected, sfIPAddress* address);
////////////////////////////////////////////////////////////
/// Send an array of bytes to the host (must be connected first)
///
/// \param Socket : Socket to use for sending
/// \param Data : Pointer to the bytes to send
/// \param Size : Number of bytes to send
/// \param socket : Socket to use for sending
/// \param data : Pointer to the bytes to send
/// \param size : Number of bytes to send
///
/// \return Socket status
///
////////////////////////////////////////////////////////////
CSFML_API sfSocketStatus sfSocketTCP_Send(sfSocketTCP* Socket, const char* Data, size_t Size);
CSFML_API sfSocketStatus sfSocketTCP_Send(sfSocketTCP* socket, const char* data, size_t size);
////////////////////////////////////////////////////////////
/// Receive an array of bytes from the host (must be connected first)
///
/// \param Socket : Socket to use for receiving
/// \param Data : Pointer to a byte array to fill (make sure it is big enough)
/// \param MaxSize : Maximum number of bytes to read
/// \param SizeReceived : Number of bytes received
/// \param socket : Socket to use for receiving
/// \param data : Pointer to a byte array to fill (make sure it is big enough)
/// \param maxSize : Maximum number of bytes to read
/// \param sizeReceived : Number of bytes received
///
/// \return Socket status
///
////////////////////////////////////////////////////////////
CSFML_API sfSocketStatus sfSocketTCP_Receive(sfSocketTCP* Socket, char* Data, size_t MaxSize, size_t* SizeReceived);
CSFML_API sfSocketStatus sfSocketTCP_Receive(sfSocketTCP* socket, char* data, size_t maxSize, size_t* sizeReceived);
////////////////////////////////////////////////////////////
/// Send a packet of data to the host (must be connected first)
///
/// \param Socket : Socket to use for sending
/// \param Packet : Packet to send
/// \param socket : Socket to use for sending
/// \param packet : Packet to send
///
/// \return Socket status
///
////////////////////////////////////////////////////////////
CSFML_API sfSocketStatus sfSocketTCP_SendPacket(sfSocketTCP* Socket, sfPacket* Packet);
CSFML_API sfSocketStatus sfSocketTCP_SendPacket(sfSocketTCP* socket, sfPacket* packet);
////////////////////////////////////////////////////////////
/// Receive a packet from the host (must be connected first)
///
/// \param Socket : Socket to use for receiving
/// \param Packet : Packet to fill with received data
/// \param socket : Socket to use for receiving
/// \param packet : Packet to fill with received data
///
/// \return Socket status
///
////////////////////////////////////////////////////////////
CSFML_API sfSocketStatus sfSocketTCP_ReceivePacket(sfSocketTCP* Socket, sfPacket* Packet);
CSFML_API sfSocketStatus sfSocketTCP_ReceivePacket(sfSocketTCP* socket, sfPacket* packet);
////////////////////////////////////////////////////////////
/// Check if a socket is in a valid state ; this function
/// can be called any time to check if the socket is OK
///
/// \param Socket : Socket to check
/// \param socket : Socket to check
///
/// \return True if the socket is valid
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfSocketTCP_IsValid(sfSocketTCP* Socket);
CSFML_API sfBool sfSocketTCP_IsValid(sfSocketTCP* socket);
#endif // SFML_SOCKETTCP_H

70
CSFML/include/SFML/Network/SocketUDP.h
View File

@ -45,111 +45,111 @@ CSFML_API sfSocketUDP* sfSocketUDP_Create();
////////////////////////////////////////////////////////////
/// Destroy an existing UDP socket
///
/// \param Socket : Socket to destroy
/// \param socket : Socket to destroy
///
////////////////////////////////////////////////////////////
CSFML_API void sfSocketUDP_Destroy(sfSocketUDP* Socket);
CSFML_API void sfSocketUDP_Destroy(sfSocketUDP* socket);
////////////////////////////////////////////////////////////
/// Change the blocking state of a UDP socket.
/// The default behaviour of a socket is blocking
///
/// \param Socket : Socket to modify
/// \param Blocking : Pass sfTrue to set the socket as blocking, or false for non-blocking
/// \param socket : Socket to modify
/// \param blocking : Pass sfTrue to set the socket as blocking, or false for non-blocking
///
////////////////////////////////////////////////////////////
CSFML_API void sfSocketUDP_SetBlocking(sfSocketUDP* Socket, sfBool Blocking);
CSFML_API void sfSocketUDP_SetBlocking(sfSocketUDP* socket, sfBool blocking);
////////////////////////////////////////////////////////////
/// Bind a socket to a specific port
///
/// \param Socket : Socket to bind
/// \param Port : Port to bind the socket to
/// \param socket : Socket to bind
/// \param port : Port to bind the socket to
///
/// \return True if operation has been successful
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfSocketUDP_Bind(sfSocketUDP* Socket, unsigned short Port);
CSFML_API sfBool sfSocketUDP_Bind(sfSocketUDP* socket, unsigned short port);
////////////////////////////////////////////////////////////
/// Unbind a socket from its previous port, if any
///
/// \param Socket : Socket to unbind
/// \param socket : Socket to unbind
///
/// \return sfTrue if operation has been successful
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfSocketUDP_Unbind(sfSocketUDP* Socket);
CSFML_API sfBool sfSocketUDP_Unbind(sfSocketUDP* socket);
////////////////////////////////////////////////////////////
/// Send an array of bytes
///
/// \param Socket : Socket to use for sending
/// \param Data : Pointer to the bytes to send
/// \param Size : Number of bytes to send
/// \param Address : Address of the computer to send the packet to
/// \param Port : Port to use for communication
/// \param socket : Socket to use for sending
/// \param data : Pointer to the bytes to send
/// \param size : Number of bytes to send
/// \param address : Address of the computer to send the packet to
/// \param port : Port to use for communication
///
/// \return Socket status
///
////////////////////////////////////////////////////////////
CSFML_API sfSocketStatus sfSocketUDP_Send(sfSocketUDP* Socket, const char* Data, size_t Size, sfIPAddress Address, unsigned short Port);
CSFML_API sfSocketStatus sfSocketUDP_Send(sfSocketUDP* socket, const char* data, size_t size, sfIPAddress address, unsigned short port);
////////////////////////////////////////////////////////////
/// Receive an array of bytes.
/// This function is blocking, ie. it won't return before some
/// bytes have been received
///
/// \param Socket : Socket to use for receiving
/// \param Data : Pointer to a byte array to fill (make sure it is big enough)
/// \param MaxSize : Maximum number of bytes to read
/// \param SizeReceived : Number of bytes received
/// \param Address : Address of the computer which sent the data
/// \param Port : Port on which the remote computer sent the data
/// \param socket : Socket to use for receiving
/// \param data : Pointer to a byte array to fill (make sure it is big enough)
/// \param maxSize : Maximum number of bytes to read
/// \param sizeReceived : Number of bytes received
/// \param address : Address of the computer which sent the data
/// \param port : Port on which the remote computer sent the data
///
/// \return Socket status
///
////////////////////////////////////////////////////////////
CSFML_API sfSocketStatus sfSocketUDP_Receive(sfSocketUDP* Socket, char* Data, size_t MaxSize, size_t* SizeReceived, sfIPAddress* Address, unsigned short* Port);
CSFML_API sfSocketStatus sfSocketUDP_Receive(sfSocketUDP* socket, char* data, size_t maxSize, size_t* sizeReceived, sfIPAddress* address, unsigned short* port);
////////////////////////////////////////////////////////////
/// Send a packet of data
///
/// \param Socket : Socket to use for sending
/// \param Packet : Packet to send
/// \param Address : Address of the computer to send the packet to
/// \param Port : Port to use for communication
/// \param socket : Socket to use for sending
/// \param packet : Packet to send
/// \param address : Address of the computer to send the packet to
/// \param port : Port to use for communication
///
/// \return Socket status
///
////////////////////////////////////////////////////////////
CSFML_API sfSocketStatus sfSocketUDP_SendPacket(sfSocketUDP* Socket, sfPacket* Packet, sfIPAddress Address, unsigned short Port);
CSFML_API sfSocketStatus sfSocketUDP_SendPacket(sfSocketUDP* socket, sfPacket* packet, sfIPAddress address, unsigned short port);
////////////////////////////////////////////////////////////
/// Receive a packet.
/// This function is blocking, ie. it won't return before a
/// packet is received
///
/// \param Socket : Socket to use for receiving
/// \param Packet : Packet to fill with received data
/// \param Address : Address of the computer which sent the packet
/// \param Port : Port on which the remote computer sent the data
/// \param socket : Socket to use for receiving
/// \param packet : Packet to fill with received data
/// \param address : Address of the computer which sent the packet
/// \param port : Port on which the remote computer sent the data
///
/// \return Socket status
///
////////////////////////////////////////////////////////////
CSFML_API sfSocketStatus sfSocketUDP_ReceivePacket(sfSocketUDP* Socket, sfPacket* Packet, sfIPAddress* Address, unsigned short* Port);
CSFML_API sfSocketStatus sfSocketUDP_ReceivePacket(sfSocketUDP* socket, sfPacket* packet, sfIPAddress* address, unsigned short* port);
////////////////////////////////////////////////////////////
/// Check if a socket is in a valid state ; this function
/// can be called any time to check if the socket is OK
///
/// \param Socket : Socket to check
/// \param socket : Socket to check
///
/// \return sfTrue if the socket is valid
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfSocketUDP_IsValid(sfSocketUDP* Socket);
CSFML_API sfBool sfSocketUDP_IsValid(sfSocketUDP* socket);
#endif // SFML_SOCKETUDP_H

12
CSFML/include/SFML/System/Clock.h
View File

@ -43,26 +43,26 @@ CSFML_API sfClock* sfClock_Create();
////////////////////////////////////////////////////////////
/// Destroy an existing clock
///
/// \param Clock : Clock to delete
/// \param clock : Clock to delete
///
////////////////////////////////////////////////////////////
CSFML_API void sfClock_Destroy(sfClock* Clock);
CSFML_API void sfClock_Destroy(sfClock* clock);
////////////////////////////////////////////////////////////
/// Get the time elapsed for a clock
///
/// \param Clock : Clock to get time from
/// \param clock : Clock to get time from
///
////////////////////////////////////////////////////////////
CSFML_API float sfClock_GetTime(sfClock* Clock);
CSFML_API float sfClock_GetTime(sfClock* clock);
////////////////////////////////////////////////////////////
/// Restart a clock
///
/// \param Clock : Clock to restart
/// \param clock : Clock to restart
///
////////////////////////////////////////////////////////////
CSFML_API void sfClock_Reset(sfClock* Clock);
CSFML_API void sfClock_Reset(sfClock* clock);
#endif // SFML_CLOCK_H

12
CSFML/include/SFML/System/Mutex.h
View File

@ -43,26 +43,26 @@ CSFML_API sfMutex* sfMutex_Create();
////////////////////////////////////////////////////////////
/// Destroy an existing mutex
///
/// \param Mutex : Mutex to delete
/// \param mutex : Mutex to delete
///
////////////////////////////////////////////////////////////
CSFML_API void sfMutex_Destroy(sfMutex* Mutex);
CSFML_API void sfMutex_Destroy(sfMutex* mutex);
////////////////////////////////////////////////////////////
/// Lock a mutex
///
/// \param Mutex : Mutex to lock
/// \param mutex : Mutex to lock
///
////////////////////////////////////////////////////////////
CSFML_API void sfMutex_Lock(sfMutex* Mutex);
CSFML_API void sfMutex_Lock(sfMutex* mutex);
////////////////////////////////////////////////////////////
/// Unlock a mutex
///
/// \param Mutex : Mutex to unlock
/// \param mutex : Mutex to unlock
///
////////////////////////////////////////////////////////////
CSFML_API void sfMutex_Unlock(sfMutex* Mutex);
CSFML_API void sfMutex_Unlock(sfMutex* mutex);
#endif // SFML_MUTEX_H

20
CSFML/include/SFML/System/Randomizer.h
View File

@ -35,10 +35,10 @@
/// Set the seed for the random numbers generator. Using a known seed
/// allows you to reproduce the same sequence of random numbers
///
/// \param Seed : Number to use as the seed
/// \param seed : Number to use as the seed
///
////////////////////////////////////////////////////////////
CSFML_API void sfRandom_SetSeed(unsigned int Seed);
CSFML_API void sfRandom_SetSeed(unsigned int seed);
////////////////////////////////////////////////////////////
/// Get the seed used to generate random numbers the generator
@ -51,24 +51,24 @@ CSFML_API unsigned int sfRandom_GetSeed();
////////////////////////////////////////////////////////////
/// Get a random float number in a given range
///
/// \return Start : Start of the range
/// \return End : End of the range
/// \return begin : Start of the range
/// \return end : End of the range
///
/// \return Random number in [Begin, End]
/// \return Random number in [begin, end]
///
////////////////////////////////////////////////////////////
CSFML_API float sfRandom_Float(float Begin, float End);
CSFML_API float sfRandom_Float(float begin, float end);
////////////////////////////////////////////////////////////
/// Get a random integer number in a given range
///
/// \return Start : Start of the range
/// \return End : End of the range
/// \return begin : Start of the range
/// \return end : End of the range
///
/// \return Random number in [Begin, End]
/// \return Random number in [begin, end]
///
////////////////////////////////////////////////////////////
CSFML_API int sfRandom_Int(int Begin, int End);
CSFML_API int sfRandom_Int(int begin, int end);
#endif // SFML_RANDOMIZER_H

4
CSFML/include/SFML/System/Sleep.h
View File

@ -34,10 +34,10 @@
////////////////////////////////////////////////////////////
/// Make the current thread sleep for a given time
///
/// \param Duration : Time to sleep, in seconds
/// \param duration : Time to sleep, in seconds
///
////////////////////////////////////////////////////////////
CSFML_API void sfSleep(float Duration);
CSFML_API void sfSleep(float duration);
#endif // SFML_SLEEP_H

22
CSFML/include/SFML/System/Thread.h
View File

@ -35,35 +35,35 @@
////////////////////////////////////////////////////////////
/// Construct a new thread from a function pointer
///
/// \param Function : Entry point of the thread
/// \param UserData : Data to pass to the thread function
/// \param function : Entry point of the thread
/// \param userData : Data to pass to the thread function
///
////////////////////////////////////////////////////////////
CSFML_API sfThread* sfThread_Create(void (*Function)(void*), void* UserData);
CSFML_API sfThread* sfThread_Create(void (*function)(void*), void* userData);
////////////////////////////////////////////////////////////
/// Destroy an existing thread
///
/// \param Thread : Thread to delete
/// \param thread : Thread to delete
///
////////////////////////////////////////////////////////////
CSFML_API void sfThread_Destroy(sfThread* Thread);
CSFML_API void sfThread_Destroy(sfThread* thread);
////////////////////////////////////////////////////////////
/// Run a thread
///
/// \param Thread : Thread to launch
/// \param thread : Thread to launch
///
////////////////////////////////////////////////////////////
CSFML_API void sfThread_Launch(sfThread* Thread);
CSFML_API void sfThread_Launch(sfThread* thread);
////////////////////////////////////////////////////////////
/// Wait until a thread finishes
///
/// \param Thread : Thread to wait for
/// \param thread : Thread to wait for
///
////////////////////////////////////////////////////////////
CSFML_API void sfThread_Wait(sfThread* Thread);
CSFML_API void sfThread_Wait(sfThread* thread);
////////////////////////////////////////////////////////////
/// Terminate a thread
@ -71,10 +71,10 @@ CSFML_API void sfThread_Wait(sfThread* Thread);
/// you should rather try to make the thread function
/// terminate by itself
///
/// \param Thread : Thread to terminate
/// \param thread : Thread to terminate
///
////////////////////////////////////////////////////////////
CSFML_API void sfThread_Terminate(sfThread* Thread);
CSFML_API void sfThread_Terminate(sfThread* thread);
#endif // SFML_THREAD_H

10
CSFML/include/SFML/Window/Context.h
View File

@ -43,19 +43,19 @@ CSFML_API sfContext* sfContext_Create();
////////////////////////////////////////////////////////////
/// Destroy an existing context
///
/// \param Context : Context to destroy
/// \param context : Context to destroy
///
////////////////////////////////////////////////////////////
CSFML_API void sfContext_Destroy(sfContext* Context);
CSFML_API void sfContext_Destroy(sfContext* context);
////////////////////////////////////////////////////////////
/// Activate or deactivate a context
///
/// \param Context : Context to activate or deactivate
/// \param Active : sfTrue to activate, sfFalse to deactivate
/// \param context : Context to activate or deactivate
/// \param active : sfTrue to activate, sfFalse to deactivate
///
////////////////////////////////////////////////////////////
CSFML_API void sfContext_SetActive(sfContext* Context, sfBool Active);
CSFML_API void sfContext_SetActive(sfContext* context, sfBool active);
#endif // SFML_CONTEXT_H

36
CSFML/include/SFML/Window/Input.h
View File

@ -35,68 +35,68 @@
////////////////////////////////////////////////////////////
/// Get the state of a key
///
/// \param Input : Input object
/// \param KeyCode : Key to check
/// \param input : Input object
/// \param code : Key to check
///
/// \return sfTrue if key is down, sfFalse if key is up
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfInput_IsKeyDown(sfInput* Input, sfKeyCode KeyCode);
CSFML_API sfBool sfInput_IsKeyDown(sfInput* input, sfKeyCode code);
////////////////////////////////////////////////////////////
/// Get the state of a mouse button
///
/// \param Input : Input object
/// \param Button : Button to check
/// \param input : Input object
/// \param button : Button to check
///
/// \return sfTrue if button is down, sfFalse if button is up
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfInput_IsMouseButtonDown(sfInput* Input, sfMouseButton Button);
CSFML_API sfBool sfInput_IsMouseButtonDown(sfInput* input, sfMouseButton button);
////////////////////////////////////////////////////////////
/// Get the state of a joystick button
///
/// \param Input : Input object
/// \param JoyId : Identifier of the joystick to check (0 or 1)
/// \param Button : Button to check
/// \param input : Input object
/// \param joyId : Identifier of the joystick to check (0 or 1)
/// \param button : Button to check
///
/// \return sfTrue if button is down, sfFalse if button is up
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfInput_IsJoystickButtonDown(sfInput* Input, unsigned int JoyId, unsigned int Button);
CSFML_API sfBool sfInput_IsJoystickButtonDown(sfInput* input, unsigned int joyId, unsigned int button);
////////////////////////////////////////////////////////////
/// Get the mouse X position
///
/// \param Input : Input object
/// \param input : Input object
///
/// \return Current mouse left position, relative to owner window
///
////////////////////////////////////////////////////////////
CSFML_API int sfInput_GetMouseX(sfInput* Input);
CSFML_API int sfInput_GetMouseX(sfInput* input);
////////////////////////////////////////////////////////////
/// Get the mouse Y position
///
/// \param Input : Input object
/// \param input : Input object
///
/// \return Current mouse top position, relative to owner window
///
////////////////////////////////////////////////////////////
CSFML_API int sfInput_GetMouseY(sfInput* Input);
CSFML_API int sfInput_GetMouseY(sfInput* input);
////////////////////////////////////////////////////////////
/// Get the joystick position on a given axis
///
/// \param Input : Input object
/// \param JoyId : Identifier of the joystick to check (0 or 1)
/// \param Axis : Identifier of the axis to read
/// \param input : Input object
/// \param joyId : Identifier of the joystick to check (0 or 1)
/// \param axis : Identifier of the axis to read
///
/// \return Current joystick position, in the range [-100, 100]
///
////////////////////////////////////////////////////////////
CSFML_API float sfInput_GetJoystickAxis(sfInput* Input, unsigned int JoyId, sfJoyAxis Axis);
CSFML_API float sfInput_GetJoystickAxis(sfInput* input, unsigned int joyId, sfJoyAxis axis);
#endif // SFML_INPUT_H

8
CSFML/include/SFML/Window/VideoMode.h
View File

@ -56,12 +56,12 @@ CSFML_API sfVideoMode sfVideoMode_GetDesktopMode();
/// Index must be in range [0, GetModesCount()[
/// Modes are sorted from best to worst
///
/// \param Index : Index of video mode to get
/// \param index : Index of video mode to get
///
/// \return Corresponding video mode (invalid mode if index is out of range)
///
////////////////////////////////////////////////////////////
CSFML_API sfVideoMode sfVideoMode_GetMode(size_t Index);
CSFML_API sfVideoMode sfVideoMode_GetMode(size_t index);
////////////////////////////////////////////////////////////
/// Get valid video modes count
@ -74,13 +74,13 @@ CSFML_API size_t sfVideoMode_GetModesCount();
////////////////////////////////////////////////////////////
/// Tell whether or not a video mode is supported
///
/// \param Mode : Video mode to check
/// \param mode : Video mode to check
///
///
/// \return True if video mode is supported, false otherwise
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfVideoMode_IsValid(sfVideoMode Mode);
CSFML_API sfBool sfVideoMode_IsValid(sfVideoMode mode);
#endif // SFML_VIDEOMODE_H

135
CSFML/include/SFML/Window/Window.h
View File

@ -63,225 +63,224 @@ typedef struct
////////////////////////////////////////////////////////////
/// Construct a new window
///
/// \param Mode : Video mode to use
/// \param Title : Title of the window
/// \param Style : Window style
/// \param Params : Creation settings
/// \param mode : Video mode to use
/// \param title : Title of the window
/// \param style : Window style
/// \param settings : Creation settings
///
////////////////////////////////////////////////////////////
CSFML_API sfWindow* sfWindow_Create(sfVideoMode Mode, const char* Title, unsigned long Style, sfContextSettings Params);
CSFML_API sfWindow* sfWindow_Create(sfVideoMode mode, const char* title, unsigned long style, sfContextSettings settings);
////////////////////////////////////////////////////////////
/// Construct a window from an existing control
///
/// \param Handle : Platform-specific handle of the control
/// \param Params : Creation settings
/// \param handle : Platform-specific handle of the control
/// \param settings : Creation settings
///
////////////////////////////////////////////////////////////
CSFML_API sfWindow* sfWindow_CreateFromHandle(sfWindowHandle Handle, sfContextSettings Params);
CSFML_API sfWindow* sfWindow_CreateFromHandle(sfWindowHandle handle, sfContextSettings settings);
////////////////////////////////////////////////////////////
/// Destroy an existing window
///
/// \param Window : Window to destroy
/// \param window : Window to destroy
///
////////////////////////////////////////////////////////////
CSFML_API void sfWindow_Destroy(sfWindow* Window);
CSFML_API void sfWindow_Destroy(sfWindow* window);
////////////////////////////////////////////////////////////
/// Close a window (but doesn't destroy the internal data)
///
/// \param Window : Window to close
/// \param window : Window to close
///
////////////////////////////////////////////////////////////
CSFML_API void sfWindow_Close(sfWindow* Window);
CSFML_API void sfWindow_Close(sfWindow* window);
////////////////////////////////////////////////////////////
/// Tell whether or not a window is opened
///
/// \param Window : Window object
/// \param window : Window object
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfWindow_IsOpened(sfWindow* Window);
CSFML_API sfBool sfWindow_IsOpened(sfWindow* window);
////////////////////////////////////////////////////////////
/// Get the width of the rendering region of a window
///
/// \param Window : Window object
/// \param window : Window object
///
/// \return Width in pixels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfWindow_GetWidth(sfWindow* Window);
CSFML_API unsigned int sfWindow_GetWidth(sfWindow* window);
////////////////////////////////////////////////////////////
/// Get the height of the rendering region of a window
///
/// \param Window : Window object
/// \param window : Window object
///
/// \return Height in pixels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfWindow_GetHeight(sfWindow* Window);
CSFML_API unsigned int sfWindow_GetHeight(sfWindow* window);
////////////////////////////////////////////////////////////
/// Get the creation settings of a window
///
/// \param Window : Window object
/// \param window : Window object
///
/// \return Settings used to create the window
///
////////////////////////////////////////////////////////////
CSFML_API sfContextSettings sfWindow_GetSettings(sfWindow* Window);
CSFML_API sfContextSettings sfWindow_GetSettings(sfWindow* window);
////////////////////////////////////////////////////////////
/// Get the event on top of events stack of a window, if any, and pop it
///
/// \param Window : Window object
/// \param Event : Event to fill, if any
/// \param window : Window object
/// \param event : Event to fill, if any
///
/// \return sfTrue if an event was returned, sfFalse if events stack was empty
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfWindow_GetEvent(sfWindow* Window, sfEvent* Event);
CSFML_API sfBool sfWindow_GetEvent(sfWindow* window, sfEvent* event);
////////////////////////////////////////////////////////////
/// Enable / disable vertical synchronization on a window
///
/// \param Window : Window object
/// \param Enabled : sfTrue to enable v-sync, sfFalse to deactivate
/// \param window : Window object
/// \param enabled : sfTrue to enable v-sync, sfFalse to deactivate
///
////////////////////////////////////////////////////////////
CSFML_API void sfWindow_UseVerticalSync(sfWindow* Window, sfBool Enabled);
CSFML_API void sfWindow_UseVerticalSync(sfWindow* window, sfBool enabled);
////////////////////////////////////////////////////////////
/// Show or hide the mouse cursor on a window
///
/// \param Window : Window object
/// \param Show : sfTrue to show, sfFalse to hide
/// \param window : Window object
/// \param show : sfTrue to show, sfFalse to hide
///
////////////////////////////////////////////////////////////
CSFML_API void sfWindow_ShowMouseCursor(sfWindow* Window, sfBool Show);
CSFML_API void sfWindow_ShowMouseCursor(sfWindow* window, sfBool show);
////////////////////////////////////////////////////////////
/// Change the position of the mouse cursor on a window
///
/// \param Window : Window object
/// \param Left : Left coordinate of the cursor, relative to the window
/// \param Top : Top coordinate of the cursor, relative to the window
/// \param window : Window object
/// \param left : Left coordinate of the cursor, relative to the window
/// \param top : Top coordinate of the cursor, relative to the window
///
////////////////////////////////////////////////////////////
CSFML_API void sfWindow_SetCursorPosition(sfWindow* Window, unsigned int Left, unsigned int Top);
CSFML_API void sfWindow_SetCursorPosition(sfWindow* window, unsigned int left, unsigned int Top);
////////////////////////////////////////////////////////////
/// Change the position of a window on screen.
/// Only works for top-level windows
///
/// \param Window : Window object
/// \param Left : Left position
/// \param Top : Top position
/// \param window : Window object
/// \param left : Left position
/// \param top : Top position
///
////////////////////////////////////////////////////////////
CSFML_API void sfWindow_SetPosition(sfWindow* Window, int Left, int Top);
CSFML_API void sfWindow_SetPosition(sfWindow* window, int left, int top);
////////////////////////////////////////////////////////////
/// Change the size of the rendering region of a window
///
/// \param Window : Window object
/// \param Width : New Width
/// \param Height : New Height
/// \param window : Window object
/// \param width : New Width
/// \param height : New Height
///
////////////////////////////////////////////////////////////
CSFML_API void sfWindow_SetSize(sfWindow* Window, unsigned int Width, unsigned int Height);
CSFML_API void sfWindow_SetSize(sfWindow* window, unsigned int width, unsigned int height);
////////////////////////////////////////////////////////////
/// Show or hide a window
///
/// \param Window : Window object
/// \param State : sfTrue to show, sfFalse to hide
/// \param window : Window object
/// \param show : sfTrue to show, sfFalse to hide
///
////////////////////////////////////////////////////////////
CSFML_API void sfWindow_Show(sfWindow* Window, sfBool State);
CSFML_API void sfWindow_Show(sfWindow* window, sfBool show);
////////////////////////////////////////////////////////////
/// Enable or disable automatic key-repeat for keydown events.
/// Automatic key-repeat is enabled by default
///
/// \param Window : Window object
/// \param Enabled : sfTrue to enable, sfFalse to disable
/// \param window : Window object
/// \param enabled : sfTrue to enable, sfFalse to disable
///
////////////////////////////////////////////////////////////
CSFML_API void sfWindow_EnableKeyRepeat(sfWindow* Window, sfBool Enabled);
CSFML_API void sfWindow_EnableKeyRepeat(sfWindow* window, sfBool enabled);
////////////////////////////////////////////////////////////
/// Change the window's icon
///
/// \param Window : Window object
/// \param Width : Icon's width, in pixels
/// \param Height : Icon's height, in pixels
/// \param Pixels : Pointer to the pixels in memory, format must be RGBA 32 bits
/// \param window : Window object
/// \param width : Icon's width, in pixels
/// \param height : Icon's height, in pixels
/// \param pixels : Pointer to the pixels in memory, format must be RGBA 32 bits
///
////////////////////////////////////////////////////////////
CSFML_API void sfWindow_SetIcon(sfWindow* Window, unsigned int Width, unsigned int Height, sfUint8* Pixels);
CSFML_API void sfWindow_SetIcon(sfWindow* window, unsigned int width, unsigned int height, sfUint8* pixels);
////////////////////////////////////////////////////////////
/// Activate or deactivate a window as the current target for rendering
///
/// \param Window : Window object
/// \param Active : sfTrue to activate, sfFalse to deactivate
/// \param window : Window object
/// \param active : sfTrue to activate, sfFalse to deactivate
///
/// \return True if operation was successful, false otherwise
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfWindow_SetActive(sfWindow* Window, sfBool Active);
CSFML_API sfBool sfWindow_SetActive(sfWindow* window, sfBool active);
////////////////////////////////////////////////////////////
/// Display a window on screen
///
/// \param Window : Window object
/// \param window : Window object
///
////////////////////////////////////////////////////////////
CSFML_API void sfWindow_Display(sfWindow* Window);
CSFML_API void sfWindow_Display(sfWindow* window);
////////////////////////////////////////////////////////////
/// Get the input manager of a window
///
/// \param Window : Window object
/// \param window : Window object
///
/// \return Reference to the input
///
////////////////////////////////////////////////////////////
CSFML_API sfInput* sfWindow_GetInput(sfWindow* Window);
CSFML_API sfInput* sfWindow_GetInput(sfWindow* window);
////////////////////////////////////////////////////////////
/// Limit the framerate to a maximum fixed frequency for a window
///
/// \param Window : Window object
///
/// \param Limit : Framerate limit, in frames per seconds (use 0 to disable limit)
/// \param window : Window object
/// \param limit : Framerate limit, in frames per seconds (use 0 to disable limit)
///
////////////////////////////////////////////////////////////
CSFML_API void sfWindow_SetFramerateLimit(sfWindow* Window, unsigned int Limit);
CSFML_API void sfWindow_SetFramerateLimit(sfWindow* window, unsigned int limit);
////////////////////////////////////////////////////////////
/// Get time elapsed since last frame of a window
///
/// \param Window : Window object
/// \param window : Window object
///
/// \return Time elapsed, in seconds
///
////////////////////////////////////////////////////////////
CSFML_API float sfWindow_GetFrameTime(sfWindow* Window);
CSFML_API float sfWindow_GetFrameTime(sfWindow* window);
////////////////////////////////////////////////////////////
/// Change the joystick threshold, ie. the value below which
/// no move event will be generated
///
/// \param Window : Window object
/// \param Threshold : New threshold, in range [0, 100]
/// \param window : Window object
/// \param threshold : New threshold, in range [0, 100]
///
////////////////////////////////////////////////////////////
CSFML_API void sfWindow_SetJoystickThreshold(sfWindow* Window, float Threshold);
CSFML_API void sfWindow_SetJoystickThreshold(sfWindow* window, float threshold);
#endif // SFML_WINDOW_H

36
CSFML/src/SFML/Audio/Listener.cpp
View File

@ -33,9 +33,9 @@
////////////////////////////////////////////////////////////
/// Change the global volume of all the sounds
////////////////////////////////////////////////////////////
void sfListener_SetGlobalVolume(float Volume)
void sfListener_SetGlobalVolume(float volume)
{
sf::Listener::SetGlobalVolume(Volume);
sf::Listener::SetGlobalVolume(volume);
}
@ -51,23 +51,23 @@ float sfListener_GetGlobalVolume()
////////////////////////////////////////////////////////////
/// Change the position of the listener
////////////////////////////////////////////////////////////
void sfListener_SetPosition(float PosX, float PosY, float PosZ)
void sfListener_SetPosition(float x, float y, float PosZ)
{
sf::Listener::SetPosition(sf::Vector3f(PosX, PosY, PosZ));
sf::Listener::SetPosition(sf::Vector3f(x, y, PosZ));
}
////////////////////////////////////////////////////////////
/// Get the current position of the listener
////////////////////////////////////////////////////////////
void sfListener_GetPosition(float* PosX, float* PosY, float* PosZ)
void sfListener_GetPosition(float* x, float* y, float* z)
{
if (PosX && PosY && PosZ)
if (x && y && z)
{
sf::Vector3f Position = sf::Listener::GetPosition();
*PosX = Position.x;
*PosY = Position.y;
*PosZ = Position.z;
sf::Vector3f position = sf::Listener::GetPosition();
*x = position.x;
*y = position.y;
*z = position.z;
}
}
@ -76,9 +76,9 @@ void sfListener_GetPosition(float* PosX, float* PosY, float* PosZ)
/// Change the orientation of the listener (the point
/// he must look at)
////////////////////////////////////////////////////////////
void sfListener_SetTarget(float TargetX, float TargetY, float TargetZ)
void sfListener_SetTarget(float x, float y, float z)
{
sf::Listener::SetTarget(sf::Vector3f(TargetX, TargetY, TargetZ));
sf::Listener::SetTarget(sf::Vector3f(x, y, z));
}
@ -86,13 +86,13 @@ void sfListener_SetTarget(float TargetX, float TargetY, float TargetZ)
/// Get the current orientation of the listener (the point
/// he's looking at)
////////////////////////////////////////////////////////////
void sfListener_GetTarget(float* TargetX, float* TargetY, float* TargetZ)
void sfListener_GetTarget(float* x, float* y, float* z)
{
if (TargetX && TargetY && TargetZ)
if (x && y && z)
{
sf::Vector3f Target = sf::Listener::GetTarget();
*TargetX = Target.x;
*TargetY = Target.y;
*TargetZ = Target.z;
sf::Vector3f target = sf::Listener::GetTarget();
*x = target.x;
*y = target.y;
*z = target.z;
}
}

132
CSFML/src/SFML/Audio/Music.cpp
View File

@ -33,162 +33,162 @@
////////////////////////////////////////////////////////////
/// Create a new music and load it from a file
////////////////////////////////////////////////////////////
sfMusic* sfMusic_CreateFromFile(const char* Filename)
sfMusic* sfMusic_CreateFromFile(const char* filename)
{
sfMusic* Music = new sfMusic;
sfMusic* music = new sfMusic;
if (!Music->This.OpenFromFile(Filename))
if (!music->This.OpenFromFile(filename))
{
delete Music;
Music = NULL;
delete music;
music = NULL;
}
return Music;
return music;
}
////////////////////////////////////////////////////////////
/// Create a new music and load it from a file in memory
////////////////////////////////////////////////////////////
sfMusic* sfMusic_CreateFromMemory(const char* Data, size_t SizeInBytes)
sfMusic* sfMusic_CreateFromMemory(const char* data, size_t sizeInBytes)
{
sfMusic* Music = new sfMusic;
sfMusic* music = new sfMusic;
if (!Music->This.OpenFromMemory(Data, SizeInBytes))
if (!music->This.OpenFromMemory(data, sizeInBytes))
{
delete Music;
Music = NULL;
delete music;
music = NULL;
}
return Music;
return music;
}
////////////////////////////////////////////////////////////
/// Destroy an existing music
////////////////////////////////////////////////////////////
void sfMusic_Destroy(sfMusic* Music)
void sfMusic_Destroy(sfMusic* music)
{
delete Music;
delete music;
}
////////////////////////////////////////////////////////////
/// Set a music loop state
////////////////////////////////////////////////////////////
void sfMusic_SetLoop(sfMusic* Music, sfBool Loop)
void sfMusic_SetLoop(sfMusic* music, sfBool loop)
{
CSFML_CALL(Music, SetLoop(Loop != 0));
CSFML_CALL(music, SetLoop(loop != 0));
}
////////////////////////////////////////////////////////////
/// Tell whether or not a music is looping
////////////////////////////////////////////////////////////
sfBool sfMusic_GetLoop(sfMusic* Music)
sfBool sfMusic_GetLoop(sfMusic* music)
{
CSFML_CALL_RETURN(Music, GetLoop(), sfFalse);
CSFML_CALL_RETURN(music, GetLoop(), sfFalse);
}
////////////////////////////////////////////////////////////
/// Get a music duration
////////////////////////////////////////////////////////////
float sfMusic_GetDuration(sfMusic* Music)
float sfMusic_GetDuration(sfMusic* music)
{
CSFML_CALL_RETURN(Music, GetDuration(), 0.f);
CSFML_CALL_RETURN(music, GetDuration(), 0.f);
}
////////////////////////////////////////////////////////////
/// Start playing a music
////////////////////////////////////////////////////////////
void sfMusic_Play(sfMusic* Music)
void sfMusic_Play(sfMusic* music)
{
CSFML_CALL(Music, Play());
CSFML_CALL(music, Play());
}
////////////////////////////////////////////////////////////
/// Pause a music
////////////////////////////////////////////////////////////
void sfMusic_Pause(sfMusic* Music)
void sfMusic_Pause(sfMusic* music)
{
CSFML_CALL(Music, Pause());
CSFML_CALL(music, Pause());
}
////////////////////////////////////////////////////////////
/// Stop playing a music
////////////////////////////////////////////////////////////
void sfMusic_Stop(sfMusic* Music)
void sfMusic_Stop(sfMusic* music)
{
CSFML_CALL(Music, Stop());
CSFML_CALL(music, Stop());
}
////////////////////////////////////////////////////////////
/// Return the number of channels of a music (1 = mono, 2 = stereo)
////////////////////////////////////////////////////////////
unsigned int sfMusic_GetChannelsCount(sfMusic* Music)
unsigned int sfMusic_GetChannelsCount(sfMusic* music)
{
CSFML_CALL_RETURN(Music, GetChannelsCount(), 0);
CSFML_CALL_RETURN(music, GetChannelsCount(), 0);
}
////////////////////////////////////////////////////////////
/// Get the stream sample rate of a music
////////////////////////////////////////////////////////////
unsigned int sfMusic_GetSampleRate(sfMusic* Music)
unsigned int sfMusic_GetSampleRate(sfMusic* music)
{
CSFML_CALL_RETURN(Music, GetSampleRate(), 0);
CSFML_CALL_RETURN(music, GetSampleRate(), 0);
}
////////////////////////////////////////////////////////////
/// Get the status of a music (stopped, paused, playing)
////////////////////////////////////////////////////////////
sfSoundStatus sfMusic_GetStatus(sfMusic* Music)
sfSoundStatus sfMusic_GetStatus(sfMusic* music)
{
CSFML_CHECK_RETURN(Music, sfStopped);
CSFML_CHECK_RETURN(music, sfStopped);
return static_cast<sfSoundStatus>(Music->This.GetStatus());
return static_cast<sfSoundStatus>(music->This.GetStatus());
}
////////////////////////////////////////////////////////////
/// Get the current playing position of a music
////////////////////////////////////////////////////////////
float sfMusic_GetPlayingOffset(sfMusic* Music)
float sfMusic_GetPlayingOffset(sfMusic* music)
{
CSFML_CALL_RETURN(Music, GetPlayingOffset(), 0.f);
CSFML_CALL_RETURN(music, GetPlayingOffset(), 0.f);
}
////////////////////////////////////////////////////////////
/// Set the pitch of a music
////////////////////////////////////////////////////////////
void sfMusic_SetPitch(sfMusic* Music, float Pitch)
void sfMusic_SetPitch(sfMusic* music, float pitch)
{
CSFML_CALL(Music, SetPitch(Pitch));
CSFML_CALL(music, SetPitch(pitch));
}
////////////////////////////////////////////////////////////
/// Set the volume of a music
////////////////////////////////////////////////////////////
void sfMusic_SetVolume(sfMusic* Music, float Volume)
void sfMusic_SetVolume(sfMusic* music, float volume)
{
CSFML_CALL(Music, SetVolume(Volume));
CSFML_CALL(music, SetVolume(volume));
}
////////////////////////////////////////////////////////////
/// Set the position of a music
////////////////////////////////////////////////////////////
void sfMusic_SetPosition(sfMusic* Music, float X, float Y, float Z)
void sfMusic_SetPosition(sfMusic* music, float x, float y, float z)
{
CSFML_CALL(Music, SetPosition(sf::Vector3f(X, Y, Z)));
CSFML_CALL(music, SetPosition(sf::Vector3f(x, y, z)));
}
@ -197,9 +197,9 @@ void sfMusic_SetPosition(sfMusic* Music, float X, float Y, float Z)
/// position, or absolute.
/// The default value is false (absolute)
////////////////////////////////////////////////////////////
void sfMusic_SetRelativeToListener(sfMusic* music, sfBool Relative)
void sfMusic_SetRelativeToListener(sfMusic* music, sfBool relative)
{
CSFML_CALL(music, SetRelativeToListener(Relative == sfTrue));
CSFML_CALL(music, SetRelativeToListener(relative == sfTrue));
}
@ -208,9 +208,9 @@ void sfMusic_SetRelativeToListener(sfMusic* music, sfBool Relative)
/// the listener will hear the music at its maximum volume.
/// The default minimum distance is 1.0
////////////////////////////////////////////////////////////
void sfMusic_SetMinDistance(sfMusic* Music, float MinDistance)
void sfMusic_SetMinDistance(sfMusic* music, float distance)
{
CSFML_CALL(Music, SetMinDistance(MinDistance));
CSFML_CALL(music, SetMinDistance(distance));
}
@ -219,52 +219,52 @@ void sfMusic_SetMinDistance(sfMusic* Music, float MinDistance)
/// more the sound will be attenuated with distance from listener.
/// The default attenuation factor 1.0
////////////////////////////////////////////////////////////
void sfMusic_SetAttenuation(sfMusic* Music, float Attenuation)
void sfMusic_SetAttenuation(sfMusic* music, float attenuation)
{
CSFML_CALL(Music, SetAttenuation(Attenuation));
CSFML_CALL(music, SetAttenuation(attenuation));
}
////////////////////////////////////////////////////////////
/// Set the current playing position of a stream
////////////////////////////////////////////////////////////
void sfMusic_SetPlayingOffset(sfMusic* Music, float TimeOffset)
void sfMusic_SetPlayingOffset(sfMusic* music, float timeOffset)
{
CSFML_CALL(Music, SetPlayingOffset(TimeOffset));
CSFML_CALL(music, SetPlayingOffset(timeOffset));
}
////////////////////////////////////////////////////////////
/// Get the pitch of a music
////////////////////////////////////////////////////////////
float sfMusic_GetPitch(sfMusic* Music)
float sfMusic_GetPitch(sfMusic* music)
{
CSFML_CALL_RETURN(Music, GetPitch(), 0.f);
CSFML_CALL_RETURN(music, GetPitch(), 0.f);
}
////////////////////////////////////////////////////////////
/// Get the volume of a music
////////////////////////////////////////////////////////////
float sfMusic_GetVolume(sfMusic* Music)
float sfMusic_GetVolume(sfMusic* music)
{
CSFML_CALL_RETURN(Music, GetVolume(), 0.f);
CSFML_CALL_RETURN(music, GetVolume(), 0.f);
}
////////////////////////////////////////////////////////////
/// Get the position of a music
////////////////////////////////////////////////////////////
void sfMusic_GetPosition(sfMusic* Music, float* X, float* Y, float* Z)
void sfMusic_GetPosition(sfMusic* music, float* x, float* y, float* z)
{
CSFML_CHECK(Music);
CSFML_CHECK(music);
if (X && Y && Z)
if (x && y && z)
{
sf::Vector3f Position = Music->This.GetPosition();
*X = Position.x;
*Y = Position.y;
*Z = Position.z;
sf::Vector3f position = music->This.GetPosition();
*x = position.x;
*y = position.y;
*z = position.z;
}
}
@ -273,25 +273,25 @@ void sfMusic_GetPosition(sfMusic* Music, float* X, float* Y, float* Z)
/// Tell if the music's position is relative to the listener's
/// position, or if it's absolute
////////////////////////////////////////////////////////////
CSFML_API sfBool sfMusic_IsRelativeToListener(sfMusic* Music)
CSFML_API sfBool sfMusic_IsRelativeToListener(sfMusic* music)
{
CSFML_CALL_RETURN(Music, IsRelativeToListener(), sfFalse);
CSFML_CALL_RETURN(music, IsRelativeToListener(), sfFalse);
}
////////////////////////////////////////////////////////////
/// Get the minimum distance of a music
////////////////////////////////////////////////////////////
float sfMusic_GetMinDistance(sfMusic* Music)
float sfMusic_GetMinDistance(sfMusic* music)
{
CSFML_CALL_RETURN(Music, GetMinDistance(), 0.f);
CSFML_CALL_RETURN(music, GetMinDistance(), 0.f);
}
////////////////////////////////////////////////////////////
/// Get the attenuation factor of a a
////////////////////////////////////////////////////////////
float sfMusic_GetAttenuation(sfMusic* Music)
float sfMusic_GetAttenuation(sfMusic* music)
{
CSFML_CALL_RETURN(Music, GetAttenuation(), 0.f);
CSFML_CALL_RETURN(music, GetAttenuation(), 0.f);
}

108
CSFML/src/SFML/Audio/Sound.cpp
View File

@ -42,48 +42,48 @@ sfSound* sfSound_Create()
////////////////////////////////////////////////////////////
/// Destroy an existing sound
////////////////////////////////////////////////////////////
void sfSound_Destroy(sfSound* Sound)
void sfSound_Destroy(sfSound* sound)
{
delete Sound;
delete sound;
}
////////////////////////////////////////////////////////////
/// Start playing a sound
////////////////////////////////////////////////////////////
void sfSound_Play(sfSound* Sound)
void sfSound_Play(sfSound* sound)
{
CSFML_CALL(Sound, Play())
CSFML_CALL(sound, Play())
}
////////////////////////////////////////////////////////////
/// Pause a sound
////////////////////////////////////////////////////////////
void sfSound_Pause(sfSound* Sound)
void sfSound_Pause(sfSound* sound)
{
CSFML_CALL(Sound, Pause())
CSFML_CALL(sound, Pause())
}
////////////////////////////////////////////////////////////
/// Stop playing a sound
////////////////////////////////////////////////////////////
void sfSound_Stop(sfSound* Sound)
void sfSound_Stop(sfSound* sound)
{
CSFML_CALL(Sound, Stop())
CSFML_CALL(sound, Stop())
}
////////////////////////////////////////////////////////////
/// Bind a sound buffer to a sound
////////////////////////////////////////////////////////////
void sfSound_SetBuffer(sfSound* Sound, sfSoundBuffer* Buffer)
void sfSound_SetBuffer(sfSound* sound, sfSoundBuffer* buffer)
{
if (Buffer)
if (buffer)
{
CSFML_CALL(Sound, SetBuffer(Buffer->This))
Sound->Buffer = Buffer;
CSFML_CALL(sound, SetBuffer(buffer->This))
sound->Buffer = buffer;
}
}
@ -91,67 +91,67 @@ void sfSound_SetBuffer(sfSound* Sound, sfSoundBuffer* Buffer)
////////////////////////////////////////////////////////////
/// Get the sound buffer bound to a sound
////////////////////////////////////////////////////////////
sfSoundBuffer* sfSound_GetBuffer(sfSound* Sound)
sfSoundBuffer* sfSound_GetBuffer(sfSound* sound)
{
CSFML_CHECK_RETURN(Sound, NULL)
CSFML_CHECK_RETURN(sound, NULL)
return Sound->Buffer;
return sound->Buffer;
}
////////////////////////////////////////////////////////////
/// Set a sound loop state
////////////////////////////////////////////////////////////
void sfSound_SetLoop(sfSound* Sound, sfBool Loop)
void sfSound_SetLoop(sfSound* sound, sfBool loop)
{
CSFML_CALL(Sound, SetLoop(Loop == sfTrue))
CSFML_CALL(sound, SetLoop(loop == sfTrue))
}
////////////////////////////////////////////////////////////
/// Tell whether or not a sound is looping
////////////////////////////////////////////////////////////
sfBool sfSound_GetLoop(sfSound* Sound)
sfBool sfSound_GetLoop(sfSound* sound)
{
CSFML_CALL_RETURN(Sound, GetLoop(), sfFalse)
CSFML_CALL_RETURN(sound, GetLoop(), sfFalse)
}
////////////////////////////////////////////////////////////
/// Get the status of a sound (stopped, paused, playing)
////////////////////////////////////////////////////////////
sfSoundStatus sfSound_GetStatus(sfSound* Sound)
sfSoundStatus sfSound_GetStatus(sfSound* sound)
{
CSFML_CHECK_RETURN(Sound, sfStopped);
CSFML_CHECK_RETURN(sound, sfStopped);
return static_cast<sfSoundStatus>(Sound->This.GetStatus());
return static_cast<sfSoundStatus>(sound->This.GetStatus());
}
////////////////////////////////////////////////////////////
/// Set the pitch of a sound
////////////////////////////////////////////////////////////
void sfSound_SetPitch(sfSound* Sound, float Pitch)
void sfSound_SetPitch(sfSound* sound, float pitch)
{
CSFML_CALL(Sound, SetPitch(Pitch))
CSFML_CALL(sound, SetPitch(pitch))
}
////////////////////////////////////////////////////////////
/// Set the volume of a sound
////////////////////////////////////////////////////////////
void sfSound_SetVolume(sfSound* Sound, float Volume)
void sfSound_SetVolume(sfSound* sound, float volume)
{
CSFML_CALL(Sound, SetVolume(Volume))
CSFML_CALL(sound, SetVolume(volume))
}
////////////////////////////////////////////////////////////
/// Set the position of a sound
////////////////////////////////////////////////////////////
void sfSound_SetPosition(sfSound* Sound, float X, float Y, float Z)
void sfSound_SetPosition(sfSound* sound, float x, float y, float z)
{
CSFML_CALL(Sound, SetPosition(sf::Vector3f(X, Y, Z)))
CSFML_CALL(sound, SetPosition(sf::Vector3f(x, y, z)))
}
@ -160,9 +160,9 @@ void sfSound_SetPosition(sfSound* Sound, float X, float Y, float Z)
/// position, or absolute.
/// The default value is false (absolute)
////////////////////////////////////////////////////////////
void sfSound_SetRelativeToListener(sfSound* Sound, sfBool Relative)
void sfSound_SetRelativeToListener(sfSound* sound, sfBool relative)
{
CSFML_CALL(Sound, SetRelativeToListener(Relative == sfTrue));
CSFML_CALL(sound, SetRelativeToListener(relative == sfTrue));
}
@ -171,9 +171,9 @@ void sfSound_SetRelativeToListener(sfSound* Sound, sfBool Relative)
/// the listener will hear the sound at its maximum volume.
/// The default minimum distance is 1.0
////////////////////////////////////////////////////////////
void sfSound_SetMinDistance(sfSound* Sound, float MinDistance)
void sfSound_SetMinDistance(sfSound* sound, float distance)
{
CSFML_CALL(Sound, SetMinDistance(MinDistance));
CSFML_CALL(sound, SetMinDistance(distance));
}
@ -182,50 +182,50 @@ void sfSound_SetMinDistance(sfSound* Sound, float MinDistance)
/// more the sound will be attenuated with distance from listener.
/// The default attenuation factor is 1.0
////////////////////////////////////////////////////////////
void sfSound_SetAttenuation(sfSound* Sound, float Attenuation)
void sfSound_SetAttenuation(sfSound* sound, float attenuation)
{
CSFML_CALL(Sound, SetAttenuation(Attenuation));
CSFML_CALL(sound, SetAttenuation(attenuation));
}
////////////////////////////////////////////////////////////
/// Set the current playing position of a sound
////////////////////////////////////////////////////////////
void sfSound_SetPlayingOffset(sfSound* Sound, float TimeOffset)
void sfSound_SetPlayingOffset(sfSound* sound, float timeOffset)
{
CSFML_CALL(Sound, SetPlayingOffset(TimeOffset));
CSFML_CALL(sound, SetPlayingOffset(timeOffset));
}
////////////////////////////////////////////////////////////
/// Get the pitch of a sound
////////////////////////////////////////////////////////////
float sfSound_GetPitch(sfSound* Sound)
float sfSound_GetPitch(sfSound* sound)
{
CSFML_CALL_RETURN(Sound, GetPitch(), 0.f)
CSFML_CALL_RETURN(sound, GetPitch(), 0.f)
}
////////////////////////////////////////////////////////////
/// Get the volume of a sound
////////////////////////////////////////////////////////////
float sfSound_GetVolume(sfSound* Sound)
float sfSound_GetVolume(sfSound* sound)
{
CSFML_CALL_RETURN(Sound, GetVolume(), 0.f)
CSFML_CALL_RETURN(sound, GetVolume(), 0.f)
}
////////////////////////////////////////////////////////////
/// Get the position of a sound
////////////////////////////////////////////////////////////
void sfSound_GetPosition(sfSound* Sound, float* X, float* Y, float* Z)
void sfSound_GetPosition(sfSound* sound, float* x, float* y, float* z)
{
CSFML_CHECK(Sound);
CSFML_CHECK(sound);
sf::Vector3f Position = Sound->This.GetPosition();
if (X) *X = Position.x;
if (Y) *Y = Position.y;
if (Z) *Z = Position.z;
sf::Vector3f position = sound->This.GetPosition();
if (x) *x = position.x;
if (y) *y = position.y;
if (z) *z = position.z;
}
@ -233,34 +233,34 @@ void sfSound_GetPosition(sfSound* Sound, float* X, float* Y, float* Z)
/// Tell if the sound's position is relative to the listener's
/// position, or if it's absolute
////////////////////////////////////////////////////////////
CSFML_API sfBool sfSound_IsRelativeToListener(sfSound* Sound)
CSFML_API sfBool sfSound_IsRelativeToListener(sfSound* sound)
{
CSFML_CALL_RETURN(Sound, IsRelativeToListener(), sfFalse);
CSFML_CALL_RETURN(sound, IsRelativeToListener(), sfFalse);
}
////////////////////////////////////////////////////////////
/// Get the minimum distance of a sound
////////////////////////////////////////////////////////////
float sfSound_GetMinDistance(sfSound* Sound)
float sfSound_GetMinDistance(sfSound* sound)
{
CSFML_CALL_RETURN(Sound, GetMinDistance(), 0.f);
CSFML_CALL_RETURN(sound, GetMinDistance(), 0.f);
}
////////////////////////////////////////////////////////////
/// Get the attenuation factor of a sound
////////////////////////////////////////////////////////////
float sfSound_GetAttenuation(sfSound* Sound)
float sfSound_GetAttenuation(sfSound* sound)
{
CSFML_CALL_RETURN(Sound, GetAttenuation(), 0.f);
CSFML_CALL_RETURN(sound, GetAttenuation(), 0.f);
}
////////////////////////////////////////////////////////////
/// Get the current playing position of a sound
////////////////////////////////////////////////////////////
float sfSound_GetPlayingOffset(sfSound* Sound)
float sfSound_GetPlayingOffset(sfSound* sound)
{
CSFML_CALL_RETURN(Sound, GetPlayingOffset(), 0.f)
CSFML_CALL_RETURN(sound, GetPlayingOffset(), 0.f)
}

64
CSFML/src/SFML/Audio/SoundBuffer.cpp
View File

@ -33,34 +33,34 @@
////////////////////////////////////////////////////////////
/// Create a new sound buffer and load it from a file
////////////////////////////////////////////////////////////
sfSoundBuffer* sfSoundBuffer_CreateFromFile(const char* Filename)
sfSoundBuffer* sfSoundBuffer_CreateFromFile(const char* filename)
{
sfSoundBuffer* Buffer = new sfSoundBuffer;
sfSoundBuffer* buffer = new sfSoundBuffer;
if (!Buffer->This.LoadFromFile(Filename))
if (!buffer->This.LoadFromFile(filename))
{
delete Buffer;
Buffer = NULL;
delete buffer;
buffer = NULL;
}
return Buffer;
return buffer;
}
////////////////////////////////////////////////////////////
/// Create a new sound buffer and load it from a file in memory
////////////////////////////////////////////////////////////
sfSoundBuffer* sfSoundBuffer_CreateFromMemory(const char* Data, size_t SizeInBytes)
sfSoundBuffer* sfSoundBuffer_CreateFromMemory(const char* data, size_t sizeInBytes)
{
sfSoundBuffer* Buffer = new sfSoundBuffer;
sfSoundBuffer* buffer = new sfSoundBuffer;
if (!Buffer->This.LoadFromMemory(Data, SizeInBytes))
if (!buffer->This.LoadFromMemory(data, sizeInBytes))
{
delete Buffer;
Buffer = NULL;
delete buffer;
buffer = NULL;
}
return Buffer;
return buffer;
}
@ -69,78 +69,78 @@ sfSoundBuffer* sfSoundBuffer_CreateFromMemory(const char* Data, size_t SizeInByt
/// samples in memory - assumed format for samples is
/// 16 bits signed integer
////////////////////////////////////////////////////////////
sfSoundBuffer* sfSoundBuffer_CreateFromSamples(const sfInt16* Samples, size_t SamplesCount, unsigned int ChannelsCount, unsigned int SampleRate)
sfSoundBuffer* sfSoundBuffer_CreateFromSamples(const sfInt16* samples, size_t samplesCount, unsigned int channelsCount, unsigned int sampleRate)
{
sfSoundBuffer* Buffer = new sfSoundBuffer;
sfSoundBuffer* buffer = new sfSoundBuffer;
if (!Buffer->This.LoadFromSamples(Samples, SamplesCount, ChannelsCount, SampleRate))
if (!buffer->This.LoadFromSamples(samples, samplesCount, channelsCount, sampleRate))
{
delete Buffer;
Buffer = NULL;
delete buffer;
buffer = NULL;
}
return Buffer;
return buffer;
}
////////////////////////////////////////////////////////////
/// Destroy an existing sound buffer
////////////////////////////////////////////////////////////
void sfSoundBuffer_Destroy(sfSoundBuffer* SoundBuffer)
void sfSoundBuffer_Destroy(sfSoundBuffer* soundBuffer)
{
delete SoundBuffer;
delete soundBuffer;
}
////////////////////////////////////////////////////////////
/// Save a sound buffer to a file
////////////////////////////////////////////////////////////
sfBool sfSoundBuffer_SaveToFile(sfSoundBuffer* SoundBuffer, const char* Filename)
sfBool sfSoundBuffer_SaveToFile(sfSoundBuffer* soundBuffer, const char* filename)
{
CSFML_CALL_RETURN(SoundBuffer, SaveToFile(Filename), sfFalse)
CSFML_CALL_RETURN(soundBuffer, SaveToFile(filename), sfFalse)
}
////////////////////////////////////////////////////////////
/// Return the samples contained in a sound buffer
////////////////////////////////////////////////////////////
const sfInt16* sfSoundBuffer_GetSamples(sfSoundBuffer* SoundBuffer)
const sfInt16* sfSoundBuffer_GetSamples(sfSoundBuffer* soundBuffer)
{
CSFML_CALL_RETURN(SoundBuffer, GetSamples(), NULL)
CSFML_CALL_RETURN(soundBuffer, GetSamples(), NULL)
}
////////////////////////////////////////////////////////////
/// Return the number of samples contained in a sound buffer
////////////////////////////////////////////////////////////
size_t sfSoundBuffer_GetSamplesCount(sfSoundBuffer* SoundBuffer)
size_t sfSoundBuffer_GetSamplesCount(sfSoundBuffer* soundBuffer)
{
CSFML_CALL_RETURN(SoundBuffer, GetSamplesCount(), 0)
CSFML_CALL_RETURN(soundBuffer, GetSamplesCount(), 0)
}
////////////////////////////////////////////////////////////
/// Get the sample rate of a sound buffer
////////////////////////////////////////////////////////////
unsigned int sfSoundBuffer_GetSampleRate(sfSoundBuffer* SoundBuffer)
unsigned int sfSoundBuffer_GetSampleRate(sfSoundBuffer* soundBuffer)
{
CSFML_CALL_RETURN(SoundBuffer, GetSampleRate(), 0)
CSFML_CALL_RETURN(soundBuffer, GetSampleRate(), 0)
}
////////////////////////////////////////////////////////////
/// Return the number of channels of a sound buffer (1 = mono, 2 = stereo, ...)
////////////////////////////////////////////////////////////
unsigned int sfSoundBuffer_GetChannelsCount(sfSoundBuffer* SoundBuffer)
unsigned int sfSoundBuffer_GetChannelsCount(sfSoundBuffer* soundBuffer)
{
CSFML_CALL_RETURN(SoundBuffer, GetChannelsCount(), 0)
CSFML_CALL_RETURN(soundBuffer, GetChannelsCount(), 0)
}
////////////////////////////////////////////////////////////
/// Get the duration of a sound buffer
////////////////////////////////////////////////////////////
float sfSoundBuffer_GetDuration(sfSoundBuffer* SoundBuffer)
float sfSoundBuffer_GetDuration(sfSoundBuffer* soundBuffer)
{
CSFML_CALL_RETURN(SoundBuffer, GetDuration(), 0.f)
CSFML_CALL_RETURN(soundBuffer, GetDuration(), 0.f)
}

24
CSFML/src/SFML/Audio/SoundBufferRecorder.cpp
View File

@ -42,9 +42,9 @@ sfSoundBufferRecorder* sfSoundBufferRecorder_Create()
////////////////////////////////////////////////////////////
/// Destroy an existing sound buffer recorder
////////////////////////////////////////////////////////////
void sfSoundBufferRecorder_Destroy(sfSoundBufferRecorder* SoundBufferRecorder)
void sfSoundBufferRecorder_Destroy(sfSoundBufferRecorder* soundBufferRecorder)
{
delete SoundBufferRecorder;
delete soundBufferRecorder;
}
@ -52,27 +52,27 @@ void sfSoundBufferRecorder_Destroy(sfSoundBufferRecorder* SoundBufferRecorder)
/// Start the capture.
/// Warning : only one capture can happen at the same time
////////////////////////////////////////////////////////////
void sfSoundBufferRecorder_Start(sfSoundBufferRecorder* SoundBufferRecorder, unsigned int SampleRate)
void sfSoundBufferRecorder_Start(sfSoundBufferRecorder* soundBufferRecorder, unsigned int sampleRate)
{
CSFML_CALL(SoundBufferRecorder, Start(SampleRate));
CSFML_CALL(soundBufferRecorder, Start(sampleRate));
}
////////////////////////////////////////////////////////////
/// Stop the capture
////////////////////////////////////////////////////////////
void sfSoundBufferRecorder_Stop(sfSoundBufferRecorder* SoundBufferRecorder)
void sfSoundBufferRecorder_Stop(sfSoundBufferRecorder* soundBufferRecorder)
{
CSFML_CALL(SoundBufferRecorder, Stop());
CSFML_CALL(soundBufferRecorder, Stop());
}
////////////////////////////////////////////////////////////
/// Get the sample rate of a sound buffer recorder
////////////////////////////////////////////////////////////
unsigned int sfSoundBufferRecorder_GetSampleRate(sfSoundBufferRecorder* SoundBufferRecorder)
unsigned int sfSoundBufferRecorder_GetSampleRate(sfSoundBufferRecorder* soundBufferRecorder)
{
CSFML_CALL_RETURN(SoundBufferRecorder, GetSampleRate(), 0);
CSFML_CALL_RETURN(soundBufferRecorder, GetSampleRate(), 0);
}
@ -80,11 +80,11 @@ unsigned int sfSoundBufferRecorder_GetSampleRate(sfSoundBufferRecorder* SoundBuf
/// Get the sound buffer containing the captured audio data
/// of a sound buffer recorder
////////////////////////////////////////////////////////////
sfSoundBuffer* sfSoundBufferRecorder_GetBuffer(sfSoundBufferRecorder* SoundBufferRecorder)
sfSoundBuffer* sfSoundBufferRecorder_GetBuffer(sfSoundBufferRecorder* soundBufferRecorder)
{
CSFML_CHECK_RETURN(SoundBufferRecorder, NULL);
CSFML_CHECK_RETURN(soundBufferRecorder, NULL);
SoundBufferRecorder->SoundBuffer.This = SoundBufferRecorder->This.GetBuffer();
soundBufferRecorder->SoundBuffer.This = soundBufferRecorder->This.GetBuffer();
return &SoundBufferRecorder->SoundBuffer;
return &soundBufferRecorder->SoundBuffer;
}

26
CSFML/src/SFML/Audio/SoundRecorder.cpp
View File

@ -34,21 +34,21 @@
/// Construct a new sound recorder with callback functions
/// for processing captured samples
////////////////////////////////////////////////////////////
sfSoundRecorder* sfSoundRecorder_Create(sfSoundRecorderStartCallback OnStart,
sfSoundRecorderProcessCallback OnProcess,
sfSoundRecorderStopCallback OnStop,
void* UserData)
sfSoundRecorder* sfSoundRecorder_Create(sfSoundRecorderStartCallback onStart,
sfSoundRecorderProcessCallback onProcess,
sfSoundRecorderStopCallback onStop,
void* userData)
{
return new sfSoundRecorder(OnStart, OnProcess, OnStop, UserData);
return new sfSoundRecorder(onStart, onProcess, onStop, userData);
}
////////////////////////////////////////////////////////////
/// Destroy an existing sound recorder
////////////////////////////////////////////////////////////
void sfSoundRecorder_Destroy(sfSoundRecorder* SoundRecorder)
void sfSoundRecorder_Destroy(sfSoundRecorder* soundRecorder)
{
delete SoundRecorder;
delete soundRecorder;
}
@ -56,27 +56,27 @@ void sfSoundRecorder_Destroy(sfSoundRecorder* SoundRecorder)
/// Start the capture.
/// Warning : only one capture can happen at the same time
////////////////////////////////////////////////////////////
void sfSoundRecorder_Start(sfSoundRecorder* SoundRecorder, unsigned int SampleRate)
void sfSoundRecorder_Start(sfSoundRecorder* soundRecorder, unsigned int sampleRate)
{
CSFML_CALL(SoundRecorder, Start(SampleRate));
CSFML_CALL(soundRecorder, Start(sampleRate));
}
////////////////////////////////////////////////////////////
/// Stop the capture
////////////////////////////////////////////////////////////
void sfSoundRecorder_Stop(sfSoundRecorder* SoundRecorder)
void sfSoundRecorder_Stop(sfSoundRecorder* soundRecorder)
{
CSFML_CALL(SoundRecorder, Stop());
CSFML_CALL(soundRecorder, Stop());
}
////////////////////////////////////////////////////////////
/// Get the sample rate of a sound recorder
////////////////////////////////////////////////////////////
unsigned int sfSoundRecorder_GetSampleRate(sfSoundRecorder* SoundRecorder)
unsigned int sfSoundRecorder_GetSampleRate(sfSoundRecorder* soundRecorder)
{
CSFML_CALL_RETURN(SoundRecorder, GetSampleRate(), 0);
CSFML_CALL_RETURN(soundRecorder, GetSampleRate(), 0);
}

114
CSFML/src/SFML/Audio/SoundStream.cpp
View File

@ -33,60 +33,60 @@
////////////////////////////////////////////////////////////
/// Construct a new sound stream
////////////////////////////////////////////////////////////
sfSoundStream* sfSoundStream_Create(sfSoundStreamGetDataCallback OnGetData,
sfSoundStreamSeekCallback OnSeek,
unsigned int ChannelsCount,
unsigned int SampleRate,
void* UserData)
sfSoundStream* sfSoundStream_Create(sfSoundStreamGetDataCallback onGetData,
sfSoundStreamSeekCallback onSeek,
unsigned int channelsCount,
unsigned int sampleRate,
void* userData)
{
return new sfSoundStream(OnGetData, OnSeek, ChannelsCount, SampleRate, UserData);
return new sfSoundStream(onGetData, onSeek, channelsCount, sampleRate, userData);
}
////////////////////////////////////////////////////////////
/// Destroy an existing sound stream
////////////////////////////////////////////////////////////
void sfSoundStream_Destroy(sfSoundStream* SoundStream)
void sfSoundStream_Destroy(sfSoundStream* soundStream)
{
delete SoundStream;
delete soundStream;
}
////////////////////////////////////////////////////////////
/// Start playing a sound stream
////////////////////////////////////////////////////////////
void sfSoundStream_Play(sfSoundStream* SoundStream)
void sfSoundStream_Play(sfSoundStream* soundStream)
{
CSFML_CALL(SoundStream, Play());
CSFML_CALL(soundStream, Play());
}
////////////////////////////////////////////////////////////
/// Pause a sound stream
////////////////////////////////////////////////////////////
void sfSoundStream_Pause(sfSoundStream* SoundStream)
void sfSoundStream_Pause(sfSoundStream* soundStream)
{
CSFML_CALL(SoundStream, Pause());
CSFML_CALL(soundStream, Pause());
}
////////////////////////////////////////////////////////////
/// Stop playing a sound stream
////////////////////////////////////////////////////////////
void sfSoundStream_Stop(sfSoundStream* SoundStream)
void sfSoundStream_Stop(sfSoundStream* soundStream)
{
CSFML_CALL(SoundStream, Stop());
CSFML_CALL(soundStream, Stop());
}
////////////////////////////////////////////////////////////
/// Get the status of a sound stream (stopped, paused, playing)
////////////////////////////////////////////////////////////
sfSoundStatus sfSoundStream_GetStatus(sfSoundStream* SoundStream)
sfSoundStatus sfSoundStream_GetStatus(sfSoundStream* soundStream)
{
CSFML_CHECK_RETURN(SoundStream, sfStopped);
CSFML_CHECK_RETURN(soundStream, sfStopped);
return static_cast<sfSoundStatus>(SoundStream->This.GetStatus());
return static_cast<sfSoundStatus>(soundStream->This.GetStatus());
}
@ -94,45 +94,45 @@ sfSoundStatus sfSoundStream_GetStatus(sfSoundStream* SoundStream)
/// Return the number of channels of a sound stream
/// (1 = mono, 2 = stereo)
////////////////////////////////////////////////////////////
unsigned int sfSoundStream_GetChannelsCount(sfSoundStream* SoundStream)
unsigned int sfSoundStream_GetChannelsCount(sfSoundStream* soundStream)
{
CSFML_CALL_RETURN(SoundStream, GetChannelsCount(), 0);
CSFML_CALL_RETURN(soundStream, GetChannelsCount(), 0);
}
////////////////////////////////////////////////////////////
/// Get the sample rate of a sound stream
////////////////////////////////////////////////////////////
unsigned int sfSoundStream_GetSampleRate(sfSoundStream* SoundStream)
unsigned int sfSoundStream_GetSampleRate(sfSoundStream* soundStream)
{
CSFML_CALL_RETURN(SoundStream, GetSampleRate(), 0);
CSFML_CALL_RETURN(soundStream, GetSampleRate(), 0);
}
////////////////////////////////////////////////////////////
/// Set the pitch of a sound stream
////////////////////////////////////////////////////////////
void sfSoundStream_SetPitch(sfSoundStream* SoundStream, float Pitch)
void sfSoundStream_SetPitch(sfSoundStream* soundStream, float pitch)
{
CSFML_CALL(SoundStream, SetPitch(Pitch));
CSFML_CALL(soundStream, SetPitch(pitch));
}
////////////////////////////////////////////////////////////
/// Set the volume of a sound stream
////////////////////////////////////////////////////////////
void sfSoundStream_SetVolume(sfSoundStream* SoundStream, float Volume)
void sfSoundStream_SetVolume(sfSoundStream* soundStream, float volume)
{
CSFML_CALL(SoundStream, SetVolume(Volume));
CSFML_CALL(soundStream, SetVolume(volume));
}
////////////////////////////////////////////////////////////
/// Set the position of a sound stream
////////////////////////////////////////////////////////////
void sfSoundStream_SetPosition(sfSoundStream* SoundStream, float X, float Y, float Z)
void sfSoundStream_SetPosition(sfSoundStream* soundStream, float x, float y, float z)
{
CSFML_CALL(SoundStream, SetPosition(X, Y, Z));
CSFML_CALL(soundStream, SetPosition(x, y, z));
}
@ -141,9 +141,9 @@ void sfSoundStream_SetPosition(sfSoundStream* SoundStream, float X, float Y, flo
/// position, or absolute.
/// The default value is false (absolute)
////////////////////////////////////////////////////////////
void sfSoundStream_SetRelativeToListener(sfSoundStream* SoundStream, sfBool Relative)
void sfSoundStream_SetRelativeToListener(sfSoundStream* soundStream, sfBool relative)
{
CSFML_CALL(SoundStream, SetRelativeToListener(Relative == sfTrue));
CSFML_CALL(soundStream, SetRelativeToListener(relative == sfTrue));
}
@ -152,9 +152,9 @@ void sfSoundStream_SetRelativeToListener(sfSoundStream* SoundStream, sfBool Rela
/// the listener will hear the sound stream at its maximum volume.
/// The default minimum distance is 1.0
////////////////////////////////////////////////////////////
void sfSoundStream_SetMinDistance(sfSoundStream* SoundStream, float MinDistance)
void sfSoundStream_SetMinDistance(sfSoundStream* soundStream, float distance)
{
CSFML_CALL(SoundStream, SetMinDistance(MinDistance));
CSFML_CALL(soundStream, SetMinDistance(distance));
}
@ -163,59 +163,59 @@ void sfSoundStream_SetMinDistance(sfSoundStream* SoundStream, float MinDistance)
/// more the sound stream will be attenuated with distance from listener.
/// The default attenuation factor 1.0
////////////////////////////////////////////////////////////
void sfSoundStream_SetAttenuation(sfSoundStream* SoundStream, float Attenuation)
void sfSoundStream_SetAttenuation(sfSoundStream* soundStream, float attenuation)
{
CSFML_CALL(SoundStream, SetAttenuation(Attenuation));
CSFML_CALL(soundStream, SetAttenuation(attenuation));
}
////////////////////////////////////////////////////////////
/// Set the current playing position of a stream
////////////////////////////////////////////////////////////
void sfSoundStream_SetPlayingOffset(sfSoundStream* SoundStream, float TimeOffset)
void sfSoundStream_SetPlayingOffset(sfSoundStream* soundStream, float timeOffset)
{
CSFML_CALL(SoundStream, SetPlayingOffset(TimeOffset));
CSFML_CALL(soundStream, SetPlayingOffset(timeOffset));
}
////////////////////////////////////////////////////////////
/// Set a stream loop state
////////////////////////////////////////////////////////////
void sfSoundStream_SetLoop(sfSoundStream* SoundStream, sfBool Loop)
void sfSoundStream_SetLoop(sfSoundStream* soundStream, sfBool loop)
{
CSFML_CALL(SoundStream, SetLoop(Loop == sfTrue));
CSFML_CALL(soundStream, SetLoop(loop == sfTrue));
}
////////////////////////////////////////////////////////////
/// Get the pitch of a sound stream
////////////////////////////////////////////////////////////
float sfSoundStream_GetPitch(sfSoundStream* SoundStream)
float sfSoundStream_GetPitch(sfSoundStream* soundStream)
{
CSFML_CALL_RETURN(SoundStream, GetPitch(), 0.f);
CSFML_CALL_RETURN(soundStream, GetPitch(), 0.f);
}
////////////////////////////////////////////////////////////
/// Get the volume of a sound stream
////////////////////////////////////////////////////////////
float sfSoundStream_GetVolume(sfSoundStream* SoundStream)
float sfSoundStream_GetVolume(sfSoundStream* soundStream)
{
CSFML_CALL_RETURN(SoundStream, GetVolume(), 0.f);
CSFML_CALL_RETURN(soundStream, GetVolume(), 0.f);
}
////////////////////////////////////////////////////////////
/// Get the position of a sound stream
////////////////////////////////////////////////////////////
void sfSoundStream_GetPosition(sfSoundStream* SoundStream, float* X, float* Y, float* Z)
void sfSoundStream_GetPosition(sfSoundStream* soundStream, float* x, float* y, float* z)
{
CSFML_CHECK(SoundStream);
CSFML_CHECK(soundStream);
sf::Vector3f Position = SoundStream->This.GetPosition();
if (X) *X = Position.x;
if (Y) *Y = Position.y;
if (Z) *Z = Position.z;
sf::Vector3f position = soundStream->This.GetPosition();
if (x) *x = position.x;
if (y) *y = position.y;
if (z) *z = position.z;
}
@ -223,43 +223,43 @@ void sfSoundStream_GetPosition(sfSoundStream* SoundStream, float* X, float* Y, f
/// Tell if the sound stream's position is relative to the listener's
/// position, or if it's absolute
////////////////////////////////////////////////////////////
CSFML_API sfBool sfSoundStream_IsRelativeToListener(sfSoundStream* SoundStream)
CSFML_API sfBool sfSoundStream_IsRelativeToListener(sfSoundStream* soundStream)
{
CSFML_CALL_RETURN(SoundStream, IsRelativeToListener(), sfFalse);
CSFML_CALL_RETURN(soundStream, IsRelativeToListener(), sfFalse);
}
////////////////////////////////////////////////////////////
/// Get the minimum distance of a sound stream
////////////////////////////////////////////////////////////
float sfSoundStream_GetMinDistance(sfSoundStream* SoundStream)
float sfSoundStream_GetMinDistance(sfSoundStream* soundStream)
{
CSFML_CALL_RETURN(SoundStream, GetMinDistance(), 0.f);
CSFML_CALL_RETURN(soundStream, GetMinDistance(), 0.f);
}
////////////////////////////////////////////////////////////
/// Get the attenuation factor of a sound stream
////////////////////////////////////////////////////////////
float sfSoundStream_GetAttenuation(sfSoundStream* SoundStream)
float sfSoundStream_GetAttenuation(sfSoundStream* soundStream)
{
CSFML_CALL_RETURN(SoundStream, GetAttenuation(), 0.f);
CSFML_CALL_RETURN(soundStream, GetAttenuation(), 0.f);
}
////////////////////////////////////////////////////////////
/// Tell whether or not a stream is looping
////////////////////////////////////////////////////////////
sfBool sfSoundStream_GetLoop(sfSoundStream* SoundStream)
sfBool sfSoundStream_GetLoop(sfSoundStream* soundStream)
{
CSFML_CALL_RETURN(SoundStream, GetLoop(), sfFalse);
CSFML_CALL_RETURN(soundStream, GetLoop(), sfFalse);
}
////////////////////////////////////////////////////////////
/// Get the current playing position of a sound stream
////////////////////////////////////////////////////////////
float sfSoundStream_GetPlayingOffset(sfSoundStream* SoundStream)
float sfSoundStream_GetPlayingOffset(sfSoundStream* soundStream)
{
CSFML_CALL_RETURN(SoundStream, GetPlayingOffset(), 0.f);
CSFML_CALL_RETURN(soundStream, GetPlayingOffset(), 0.f);
}

48
CSFML/src/SFML/Graphics/Color.cpp
View File

@ -46,51 +46,57 @@ sfColor sfCyan = { 0, 255, 255, 255};
////////////////////////////////////////////////////////////
/// Construct a color from its 3 RGB components
////////////////////////////////////////////////////////////
sfColor sfColor_FromRGB(sfUint8 R, sfUint8 G, sfUint8 B)
sfColor sfColor_FromRGB(sfUint8 red, sfUint8 green, sfUint8 blue)
{
return sfColor_FromRGBA(R, G, B, 255);
return sfColor_FromRGBA(red, green, blue, 255);
}
////////////////////////////////////////////////////////////
/// Construct a color from its 4 RGBA components
////////////////////////////////////////////////////////////
sfColor sfColor_FromRGBA(sfUint8 R, sfUint8 G, sfUint8 B, sfUint8 A)
sfColor sfColor_FromRGBA(sfUint8 red, sfUint8 green, sfUint8 blue, sfUint8 alpha)
{
sfColor Color;
sfColor color;
Color.r = R;
Color.g = G;
Color.b = B;
Color.a = A;
color.r = red;
color.g = green;
color.b = blue;
color.a = alpha;
return Color;
return color;
}
////////////////////////////////////////////////////////////
/// Add two colors
////////////////////////////////////////////////////////////
sfColor sfColor_Add(sfColor Color1, sfColor Color2)
sfColor sfColor_Add(sfColor color1, sfColor color2)
{
int R = std::min(Color1.r + Color2.r, 255);
int G = std::min(Color1.g + Color2.g, 255);
int B = std::min(Color1.b + Color2.b, 255);
int A = std::min(Color1.a + Color2.a, 255);
int red = std::min(color1.r + color2.r, 255);
int green = std::min(color1.g + color2.g, 255);
int blue = std::min(color1.b + color2.b, 255);
int alpha = std::min(color1.a + color2.a, 255);
return sfColor_FromRGBA(static_cast<sfUint8>(R), static_cast<sfUint8>(G), static_cast<sfUint8>(B), static_cast<sfUint8>(A));
return sfColor_FromRGBA(static_cast<sfUint8>(red),
static_cast<sfUint8>(green),
static_cast<sfUint8>(blue),
static_cast<sfUint8>(alpha));
}
////////////////////////////////////////////////////////////
/// Modulate two colors
////////////////////////////////////////////////////////////
sfColor sfColor_Modulate(sfColor Color1, sfColor Color2)
sfColor sfColor_Modulate(sfColor color1, sfColor color2)
{
int R = Color1.r * Color2.r / 255;
int G = Color1.g * Color2.g / 255;
int B = Color1.b * Color2.b / 255;
int A = Color1.a * Color2.a / 255;
int red = color1.r * color2.r / 255;
int green = color1.g * color2.g / 255;
int blue = color1.b * color2.b / 255;
int alpha = color1.a * color2.a / 255;
return sfColor_FromRGBA(static_cast<sfUint8>(R), static_cast<sfUint8>(G), static_cast<sfUint8>(B), static_cast<sfUint8>(A));
return sfColor_FromRGBA(static_cast<sfUint8>(red),
static_cast<sfUint8>(green),
static_cast<sfUint8>(blue),
static_cast<sfUint8>(alpha));
}

52
CSFML/src/SFML/Graphics/Font.cpp
View File

@ -42,55 +42,55 @@ sfFont* sfFont_Create()
////////////////////////////////////////////////////////////
/// Create a new font from a file
////////////////////////////////////////////////////////////
sfFont* sfFont_CreateFromFile(const char* Filename, unsigned int CharSize, const sfUint32* Charset)
sfFont* sfFont_CreateFromFile(const char* filename, unsigned int charSize, const sfUint32* charset)
{
sfFont* Font = new sfFont;
sfFont* font = new sfFont;
bool bSucceeded = false;
if (Charset)
bSucceeded = Font->This.LoadFromFile(Filename, CharSize, Charset);
bool success = false;
if (charset)
success = font->This.LoadFromFile(filename, charSize, charset);
else
bSucceeded = Font->This.LoadFromFile(Filename, CharSize);
success = font->This.LoadFromFile(filename, charSize);
if (!bSucceeded)
if (!success)
{
delete Font;
Font = NULL;
delete font;
font = NULL;
}
return Font;
return font;
}
////////////////////////////////////////////////////////////
/// Create a new font from a file in memory
////////////////////////////////////////////////////////////
sfFont* sfFont_CreateFromMemory(const char* Data, size_t SizeInBytes, unsigned int CharSize, const sfUint32* Charset)
sfFont* sfFont_CreateFromMemory(const char* data, size_t sizeInBytes, unsigned int charSize, const sfUint32* charset)
{
sfFont* Font = new sfFont;
sfFont* font = new sfFont;
bool bSucceeded = false;
if (Charset)
bSucceeded = Font->This.LoadFromMemory(Data, SizeInBytes, CharSize, Charset);
bool success = false;
if (charset)
success = font->This.LoadFromMemory(data, sizeInBytes, charSize, charset);
else
bSucceeded = Font->This.LoadFromMemory(Data, SizeInBytes, CharSize);
success = font->This.LoadFromMemory(data, sizeInBytes, charSize);
if (!bSucceeded)
if (!success)
{
delete Font;
Font = NULL;
delete font;
font = NULL;
}
return Font;
return font;
}
////////////////////////////////////////////////////////////
/// Destroy an existing font
////////////////////////////////////////////////////////////
void sfFont_Destroy(sfFont* Font)
void sfFont_Destroy(sfFont* font)
{
delete Font;
delete font;
}
@ -98,9 +98,9 @@ void sfFont_Destroy(sfFont* Font)
/// Get the base size of characters in a font;
/// All glyphs dimensions are based on this value
////////////////////////////////////////////////////////////
unsigned int sfFont_GetCharacterSize(sfFont* Font)
unsigned int sfFont_GetCharacterSize(sfFont* font)
{
CSFML_CALL_RETURN(Font, GetCharacterSize(), 0);
CSFML_CALL_RETURN(font, GetCharacterSize(), 0);
}
@ -109,7 +109,7 @@ unsigned int sfFont_GetCharacterSize(sfFont* Font)
////////////////////////////////////////////////////////////
sfFont* sfFont_GetDefaultFont()
{
static sfFont DefaultFont = {sf::Font::GetDefaultFont()};
static sfFont defaultFont = {sf::Font::GetDefaultFont()};
return &DefaultFont;
return &defaultFont;
}

116
CSFML/src/SFML/Graphics/Image.cpp
View File

@ -43,96 +43,96 @@ sfImage* sfImage_Create()
////////////////////////////////////////////////////////////
/// Create a new image filled with a color
////////////////////////////////////////////////////////////
sfImage* sfImage_CreateFromColor(unsigned int Width, unsigned int Height, sfColor Color)
sfImage* sfImage_CreateFromColor(unsigned int width, unsigned int height, sfColor color)
{
sfImage* Image = new sfImage;
sfImage* image = new sfImage;
if (!Image->This->Create(Width, Height, sf::Color(Color.r, Color.g, Color.b, Color.a)))
if (!image->This->Create(width, height, sf::Color(color.r, color.g, color.b, color.a)))
{
delete Image;
Image = NULL;
delete image;
image = NULL;
}
return Image;
return image;
}
////////////////////////////////////////////////////////////
/// Create a new image from an array of pixels in memory
////////////////////////////////////////////////////////////
sfImage* sfImage_CreateFromPixels(unsigned int Width, unsigned int Height, const sfUint8* Data)
sfImage* sfImage_CreateFromPixels(unsigned int width, unsigned int height, const sfUint8* data)
{
sfImage* Image = new sfImage;
sfImage* image = new sfImage;
if (!Image->This->LoadFromPixels(Width, Height, Data))
if (!image->This->LoadFromPixels(width, height, data))
{
delete Image;
Image = NULL;
delete image;
image = NULL;
}
return Image;
return image;
}
////////////////////////////////////////////////////////////
/// Create a new image from a file
////////////////////////////////////////////////////////////
sfImage* sfImage_CreateFromFile(const char* Filename)
sfImage* sfImage_CreateFromFile(const char* filename)
{
sfImage* Image = new sfImage;
sfImage* image = new sfImage;
if (!Image->This->LoadFromFile(Filename))
if (!image->This->LoadFromFile(filename))
{
delete Image;
Image = NULL;
delete image;
image = NULL;
}
return Image;
return image;
}
////////////////////////////////////////////////////////////
/// Create a new image from a file in memory
////////////////////////////////////////////////////////////
sfImage* sfImage_CreateFromMemory(const char* Data, size_t SizeInBytes)
sfImage* sfImage_CreateFromMemory(const char* data, size_t sizeInBytes)
{
sfImage* Image = new sfImage;
sfImage* image = new sfImage;
if (!Image->This->LoadFromMemory(Data, SizeInBytes))
if (!image->This->LoadFromMemory(data, sizeInBytes))
{
delete Image;
Image = NULL;
delete image;
image = NULL;
}
return Image;
return image;
}
////////////////////////////////////////////////////////////
/// Destroy an existing image
////////////////////////////////////////////////////////////
void sfImage_Destroy(sfImage* Image)
void sfImage_Destroy(sfImage* image)
{
delete Image;
delete image;
}
////////////////////////////////////////////////////////////
/// Save the content of an image to a file
////////////////////////////////////////////////////////////
sfBool sfImage_SaveToFile(sfImage* Image, const char* Filename)
sfBool sfImage_SaveToFile(sfImage* image, const char* filename)
{
CSFML_CALL_PTR_RETURN(Image, SaveToFile(Filename), sfFalse);
CSFML_CALL_PTR_RETURN(image, SaveToFile(filename), sfFalse);
}
////////////////////////////////////////////////////////////
/// Create a transparency mask for an image from a specified colorkey
////////////////////////////////////////////////////////////
void sfImage_CreateMaskFromColor(sfImage* Image, sfColor ColorKey, sfUint8 Alpha)
void sfImage_CreateMaskFromColor(sfImage* image, sfColor colorKey, sfUint8 alpha)
{
sf::Color SFMLColor(ColorKey.r, ColorKey.g, ColorKey.b, ColorKey.a);
CSFML_CALL_PTR(Image, CreateMaskFromColor(SFMLColor, Alpha));
sf::Color SFMLColor(colorKey.r, colorKey.g, colorKey.b, colorKey.a);
CSFML_CALL_PTR(image, CreateMaskFromColor(SFMLColor, alpha));
}
@ -141,11 +141,11 @@ void sfImage_CreateMaskFromColor(sfImage* Image, sfColor ColorKey, sfUint8 Alpha
/// This function does a slow pixel copy and should only
/// be used at initialization time
////////////////////////////////////////////////////////////
void sfImage_Copy(sfImage* Image, sfImage* Source, unsigned int DestX, unsigned int DestY, sfIntRect SourceRect)
void sfImage_Copy(sfImage* image, sfImage* source, unsigned int destX, unsigned int destY, sfIntRect sourceRect)
{
CSFML_CHECK(Source);
sf::IntRect SFMLRect(SourceRect.Left, SourceRect.Top, SourceRect.Right, SourceRect.Bottom);
CSFML_CALL_PTR(Image, Copy(*Source->This, DestX, DestY, SFMLRect));
CSFML_CHECK(source);
sf::IntRect SFMLRect(sourceRect.Left, sourceRect.Top, sourceRect.Right, sourceRect.Bottom);
CSFML_CALL_PTR(image, Copy(*source->This, destX, destY, SFMLRect));
}
@ -153,11 +153,11 @@ void sfImage_Copy(sfImage* Image, sfImage* Source, unsigned int DestX, unsigned
/// Create the image from the current contents of the
/// given window
////////////////////////////////////////////////////////////
CSFML_API sfBool sfImage_CopyScreen(sfImage* Image, sfRenderWindow* Window, sfIntRect SourceRect)
CSFML_API sfBool sfImage_CopyScreen(sfImage* image, sfRenderWindow* window, sfIntRect sourceRect)
{
CSFML_CHECK_RETURN(Window, sfFalse);
sf::IntRect SFMLRect(SourceRect.Left, SourceRect.Top, SourceRect.Right, SourceRect.Bottom);
CSFML_CALL_PTR_RETURN(Image, CopyScreen(Window->This, SFMLRect), sfFalse);
CSFML_CHECK_RETURN(window, sfFalse);
sf::IntRect SFMLRect(sourceRect.Left, sourceRect.Top, sourceRect.Right, sourceRect.Bottom);
CSFML_CALL_PTR_RETURN(image, CopyScreen(window->This, SFMLRect), sfFalse);
}
@ -165,22 +165,22 @@ CSFML_API sfBool sfImage_CopyScreen(sfImage* Image, sfRenderWindow* Window, sfIn
/// Change the color of a pixel of an image
/// Don't forget to call Update when you end modifying pixels
////////////////////////////////////////////////////////////
void sfImage_SetPixel(sfImage* Image, unsigned int X, unsigned int Y, sfColor Color)
void sfImage_SetPixel(sfImage* image, unsigned int x, unsigned int y, sfColor color)
{
sf::Color SFMLColor(Color.r, Color.g, Color.b, Color.a);
CSFML_CALL_PTR(Image, SetPixel(X, Y, SFMLColor));
sf::Color SFMLColor(color.r, color.g, color.b, color.a);
CSFML_CALL_PTR(image, SetPixel(x, y, SFMLColor));
}
////////////////////////////////////////////////////////////
/// Get a pixel from an image
////////////////////////////////////////////////////////////
sfColor sfImage_GetPixel(sfImage* Image, unsigned int X, unsigned int Y)
sfColor sfImage_GetPixel(sfImage* image, unsigned int x, unsigned int y)
{
sfColor Color = {0, 0, 0, 0};
CSFML_CHECK_RETURN(Image, Color);
sfColor color = {0, 0, 0, 0};
CSFML_CHECK_RETURN(image, color);
sf::Color SFMLColor = Image->This->GetPixel(X, Y);
sf::Color SFMLColor = image->This->GetPixel(x, y);
return sfColor_FromRGBA(SFMLColor.r, SFMLColor.g, SFMLColor.b, SFMLColor.a);
}
@ -191,52 +191,52 @@ sfColor sfImage_GetPixel(sfImage* Image, unsigned int X, unsigned int Y)
/// Array size is sfImage_GetWidth() x sfImage_GetHeight() x 4
/// This pointer becomes invalid if you reload or resize the image
////////////////////////////////////////////////////////////
const sfUint8* sfImage_GetPixelsPtr(sfImage* Image)
const sfUint8* sfImage_GetPixelsPtr(sfImage* image)
{
CSFML_CALL_PTR_RETURN(Image, GetPixelsPtr(), NULL);
CSFML_CALL_PTR_RETURN(image, GetPixelsPtr(), NULL);
}
////////////////////////////////////////////////////////////
/// Bind the image for rendering
////////////////////////////////////////////////////////////
void sfImage_Bind(sfImage* Image)
void sfImage_Bind(sfImage* image)
{
CSFML_CALL_PTR(Image, Bind());
CSFML_CALL_PTR(image, Bind());
}
////////////////////////////////////////////////////////////
/// Enable or disable image smooth filter
////////////////////////////////////////////////////////////
void sfImage_SetSmooth(sfImage* Image, sfBool Smooth)
void sfImage_SetSmooth(sfImage* image, sfBool smooth)
{
CSFML_CALL_PTR(Image, SetSmooth(Smooth == sfTrue));
CSFML_CALL_PTR(image, SetSmooth(smooth == sfTrue));
}
////////////////////////////////////////////////////////////
/// Return the width of the image
////////////////////////////////////////////////////////////
unsigned int sfImage_GetWidth(sfImage* Image)
unsigned int sfImage_GetWidth(sfImage* image)
{
CSFML_CALL_PTR_RETURN(Image, GetWidth(), 0);
CSFML_CALL_PTR_RETURN(image, GetWidth(), 0);
}
////////////////////////////////////////////////////////////
/// Return the height of the image
////////////////////////////////////////////////////////////
unsigned int sfImage_GetHeight(sfImage* Image)
unsigned int sfImage_GetHeight(sfImage* image)
{
CSFML_CALL_PTR_RETURN(Image, GetHeight(), 0);
CSFML_CALL_PTR_RETURN(image, GetHeight(), 0);
}
////////////////////////////////////////////////////////////
/// Tells whether the smoothing filter is enabled or not on an image
////////////////////////////////////////////////////////////
sfBool sfImage_IsSmooth(sfImage* Image)
sfBool sfImage_IsSmooth(sfImage* image)
{
CSFML_CALL_PTR_RETURN(Image, IsSmooth(), sfFalse);
CSFML_CALL_PTR_RETURN(image, IsSmooth(), sfFalse);
}

48
CSFML/src/SFML/Graphics/PostFX.cpp
View File

@ -34,88 +34,88 @@
////////////////////////////////////////////////////////////
/// Create a new post-fx from a file
////////////////////////////////////////////////////////////
sfPostFX* sfPostFX_CreateFromFile(const char* Filename)
sfPostFX* sfPostFX_CreateFromFile(const char* filename)
{
sfPostFX* PostFX = new sfPostFX;
sfPostFX* postFX = new sfPostFX;
if (!PostFX->This.LoadFromFile(Filename))
if (!postFX->This.LoadFromFile(filename))
{
delete PostFX;
PostFX = NULL;
delete postFX;
postFX = NULL;
}
return PostFX;
return postFX;
}
////////////////////////////////////////////////////////////
/// Create a new post-fx from an effect source code
////////////////////////////////////////////////////////////
sfPostFX* sfPostFX_CreateFromMemory(const char* Effect)
sfPostFX* sfPostFX_CreateFromMemory(const char* effect)
{
sfPostFX* PostFX = new sfPostFX;
sfPostFX* postFX = new sfPostFX;
if (!PostFX->This.LoadFromMemory(Effect))
if (!postFX->This.LoadFromMemory(effect))
{
delete PostFX;
PostFX = NULL;
delete postFX;
postFX = NULL;
}
return PostFX;
return postFX;
}
////////////////////////////////////////////////////////////
/// Destroy an existing post-fx
////////////////////////////////////////////////////////////
void sfPostFX_Destroy(sfPostFX* PostFX)
void sfPostFX_Destroy(sfPostFX* postFX)
{
delete PostFX;
delete postFX;
}
////////////////////////////////////////////////////////////
/// Change a parameter of a post-fx (1 float)
////////////////////////////////////////////////////////////
void sfPostFX_SetParameter1(sfPostFX* PostFX, const char* Name, float X)
void sfPostFX_SetParameter1(sfPostFX* postFX, const char* name, float x)
{
CSFML_CALL(PostFX, SetParameter(Name, X))
CSFML_CALL(postFX, SetParameter(name, x))
}
////////////////////////////////////////////////////////////
/// Change a parameter of a post-fx (2 floats)
////////////////////////////////////////////////////////////
void sfPostFX_SetParameter2(sfPostFX* PostFX, const char* Name, float X, float Y)
void sfPostFX_SetParameter2(sfPostFX* postFX, const char* name, float x, float y)
{
CSFML_CALL(PostFX, SetParameter(Name, X, Y))
CSFML_CALL(postFX, SetParameter(name, x, y))
}
////////////////////////////////////////////////////////////
/// Change a parameter of a post-fx (3 floats)
////////////////////////////////////////////////////////////
void sfPostFX_SetParameter3(sfPostFX* PostFX, const char* Name, float X, float Y, float Z)
void sfPostFX_SetParameter3(sfPostFX* postFX, const char* name, float x, float y, float z)
{
CSFML_CALL(PostFX, SetParameter(Name, X, Y, Z))
CSFML_CALL(postFX, SetParameter(name, x, y, z))
}
////////////////////////////////////////////////////////////
/// Change a parameter of a post-fx (4 floats)
////////////////////////////////////////////////////////////
void sfPostFX_SetParameter4(sfPostFX* PostFX, const char* Name, float X, float Y, float Z, float W)
void sfPostFX_SetParameter4(sfPostFX* postFX, const char* name, float x, float y, float z, float w)
{
CSFML_CALL(PostFX, SetParameter(Name, X, Y, Z, W))
CSFML_CALL(postFX, SetParameter(name, x, y, z, w))
}
////////////////////////////////////////////////////////////
/// Set a texture parameter in a post-fx
////////////////////////////////////////////////////////////
void sfPostFX_SetTexture(sfPostFX* PostFX, const char* Name, sfImage* Texture)
void sfPostFX_SetTexture(sfPostFX* postFX, const char* name, sfImage* texture)
{
CSFML_CALL(PostFX, SetTexture(Name, Texture ? Texture->This : NULL))
CSFML_CALL(postFX, SetTexture(name, texture ? texture->This : NULL))
}

88
CSFML/src/SFML/Graphics/Rect.cpp
View File

@ -33,86 +33,86 @@
////////////////////////////////////////////////////////////
/// Move a rectangle by the given offset
////////////////////////////////////////////////////////////
void sfFloatRect_Offset(sfFloatRect* Rect, float OffsetX, float OffsetY)
void sfFloatRect_Offset(sfFloatRect* rect, float offsetX, float offsetY)
{
CSFML_CHECK(Rect)
Rect->Left += OffsetX;
Rect->Right += OffsetX;
Rect->Top += OffsetY;
Rect->Bottom += OffsetY;
CSFML_CHECK(rect)
rect->Left += offsetX;
rect->Right += offsetX;
rect->Top += offsetY;
rect->Bottom += offsetY;
}
void sfIntRect_Offset(sfIntRect* Rect, int OffsetX, int OffsetY)
void sfIntRect_Offset(sfIntRect* rect, int offsetX, int offsetY)
{
CSFML_CHECK(Rect)
Rect->Left += OffsetX;
Rect->Right += OffsetX;
Rect->Top += OffsetY;
Rect->Bottom += OffsetY;
CSFML_CHECK(rect)
rect->Left += offsetX;
rect->Right += offsetX;
rect->Top += offsetY;
rect->Bottom += offsetY;
}
////////////////////////////////////////////////////////////
/// Check if a point is inside a rectangle's area
////////////////////////////////////////////////////////////
sfBool sfFloatRect_Contains(sfFloatRect* Rect, float X, float Y)
sfBool sfFloatRect_Contains(sfFloatRect* rect, float x, float y)
{
CSFML_CHECK_RETURN(Rect, sfFalse)
return sf::FloatRect(Rect->Left, Rect->Top, Rect->Right, Rect->Bottom).Contains(X, Y);
CSFML_CHECK_RETURN(rect, sfFalse)
return sf::FloatRect(rect->Left, rect->Top, rect->Right, rect->Bottom).Contains(x, y);
}
sfBool sfIntRect_Contains(sfIntRect* Rect, int X, int Y)
sfBool sfIntRect_Contains(sfIntRect* rect, int x, int y)
{
CSFML_CHECK_RETURN(Rect, sfFalse)
return sf::IntRect(Rect->Left, Rect->Top, Rect->Right, Rect->Bottom).Contains(X, Y);
CSFML_CHECK_RETURN(rect, sfFalse)
return sf::IntRect(rect->Left, rect->Top, rect->Right, rect->Bottom).Contains(x, y);
}
////////////////////////////////////////////////////////////
/// Check intersection between two rectangles
////////////////////////////////////////////////////////////
sfBool sfFloatRect_Intersects(sfFloatRect* Rect1, sfFloatRect* Rect2, sfFloatRect* OverlappingRect)
sfBool sfFloatRect_Intersects(sfFloatRect* rect1, sfFloatRect* rect2, sfFloatRect* intersection)
{
CSFML_CHECK_RETURN(Rect1, sfFalse)
CSFML_CHECK_RETURN(Rect2, sfFalse)
CSFML_CHECK_RETURN(rect1, sfFalse)
CSFML_CHECK_RETURN(rect2, sfFalse)
sf::FloatRect SFMLRect1(Rect1->Left, Rect1->Top, Rect1->Right, Rect1->Bottom);
sf::FloatRect SFMLRect2(Rect2->Left, Rect2->Top, Rect2->Right, Rect2->Bottom);
sf::FloatRect SFMLRect1(rect1->Left, rect1->Top, rect1->Right, rect1->Bottom);
sf::FloatRect SFMLRect2(rect2->Left, rect2->Top, rect2->Right, rect2->Bottom);
if (OverlappingRect)
if (intersection)
{
sf::FloatRect Overlap;
bool Intersect = SFMLRect1.Intersects(SFMLRect2, Overlap);
sf::FloatRect overlap;
bool intersects = SFMLRect1.Intersects(SFMLRect2, overlap);
OverlappingRect->Left = Overlap.Left;
OverlappingRect->Top = Overlap.Top;
OverlappingRect->Right = Overlap.Right;
OverlappingRect->Bottom = Overlap.Bottom;
intersection->Left = overlap.Left;
intersection->Top = overlap.Top;
intersection->Right = overlap.Right;
intersection->Bottom = overlap.Bottom;
return Intersect;
return intersects;
}
else
{
return SFMLRect1.Intersects(SFMLRect2);
}
}
sfBool sfIntRect_Intersects(sfIntRect* Rect1, sfIntRect* Rect2, sfIntRect* OverlappingRect)
sfBool sfIntRect_Intersects(sfIntRect* rect1, sfIntRect* rect2, sfIntRect* intersection)
{
CSFML_CHECK_RETURN(Rect1, sfFalse)
CSFML_CHECK_RETURN(Rect2, sfFalse)
CSFML_CHECK_RETURN(rect1, sfFalse)
CSFML_CHECK_RETURN(rect2, sfFalse)
sf::IntRect SFMLRect1(Rect1->Left, Rect1->Top, Rect1->Right, Rect1->Bottom);
sf::IntRect SFMLRect2(Rect2->Left, Rect2->Top, Rect2->Right, Rect2->Bottom);
sf::IntRect SFMLRect1(rect1->Left, rect1->Top, rect1->Right, rect1->Bottom);
sf::IntRect SFMLRect2(rect2->Left, rect2->Top, rect2->Right, rect2->Bottom);
if (OverlappingRect)
if (intersection)
{
sf::IntRect Overlap;
bool Intersect = SFMLRect1.Intersects(SFMLRect2, Overlap);
sf::IntRect overlap;
bool intersects = SFMLRect1.Intersects(SFMLRect2, overlap);
OverlappingRect->Left = Overlap.Left;
OverlappingRect->Top = Overlap.Top;
OverlappingRect->Right = Overlap.Right;
OverlappingRect->Bottom = Overlap.Bottom;
intersection->Left = overlap.Left;
intersection->Top = overlap.Top;
intersection->Right = overlap.Right;
intersection->Bottom = overlap.Bottom;
return Intersect;
return intersects;
}
else
{

94
CSFML/src/SFML/Graphics/RenderImage.cpp
View File

@ -37,122 +37,122 @@
////////////////////////////////////////////////////////////
/// Construct a new renderimage
////////////////////////////////////////////////////////////
sfRenderImage* sfRenderImage_Create(unsigned int Width, unsigned int Height, sfBool DepthBuffer)
sfRenderImage* sfRenderImage_Create(unsigned int width, unsigned int height, sfBool depthBuffer)
{
sfRenderImage* RenderImage = new sfRenderImage;
RenderImage->This.Create(Width, Height, DepthBuffer == sfTrue);
RenderImage->Target = new sfImage(const_cast<sf::Image*>(&RenderImage->This.GetImage()));
RenderImage->DefaultView = new sfView(const_cast<sf::View*>(&RenderImage->This.GetDefaultView()));
RenderImage->CurrentView = RenderImage->DefaultView;
sfRenderImage* renderImage = new sfRenderImage;
renderImage->This.Create(width, height, depthBuffer == sfTrue);
renderImage->Target = new sfImage(const_cast<sf::Image*>(&renderImage->This.GetImage()));
renderImage->DefaultView = new sfView(const_cast<sf::View*>(&renderImage->This.GetDefaultView()));
renderImage->CurrentView = renderImage->DefaultView;
return RenderImage;
return renderImage;
}
////////////////////////////////////////////////////////////
/// Destroy an existing renderimage
////////////////////////////////////////////////////////////
void sfRenderImage_Destroy(sfRenderImage* RenderImage)
void sfRenderImage_Destroy(sfRenderImage* renderImage)
{
delete RenderImage->DefaultView;
delete RenderImage->Target;
delete RenderImage;
delete renderImage->DefaultView;
delete renderImage->Target;
delete renderImage;
}
////////////////////////////////////////////////////////////
/// Get the width of the rendering region of a renderimage
////////////////////////////////////////////////////////////
unsigned int sfRenderImage_GetWidth(sfRenderImage* RenderImage)
unsigned int sfRenderImage_GetWidth(sfRenderImage* renderImage)
{
CSFML_CALL_RETURN(RenderImage, GetWidth(), 0);
CSFML_CALL_RETURN(renderImage, GetWidth(), 0);
}
////////////////////////////////////////////////////////////
/// Get the height of the rendering region of a renderimage
////////////////////////////////////////////////////////////
unsigned int sfRenderImage_GetHeight(sfRenderImage* RenderImage)
unsigned int sfRenderImage_GetHeight(sfRenderImage* renderImage)
{
CSFML_CALL_RETURN(RenderImage, GetHeight(), 0);
CSFML_CALL_RETURN(renderImage, GetHeight(), 0);
}
////////////////////////////////////////////////////////////
/// Set a renderimage as the current target for rendering
////////////////////////////////////////////////////////////
sfBool sfRenderImage_SetActive(sfRenderImage* RenderImage, sfBool Active)
sfBool sfRenderImage_SetActive(sfRenderImage* renderImage, sfBool active)
{
CSFML_CALL_RETURN(RenderImage, SetActive(Active == sfTrue), sfFalse)
CSFML_CALL_RETURN(renderImage, SetActive(active == sfTrue), sfFalse)
}
////////////////////////////////////////////////////////////
/// Draw something on a renderimage
////////////////////////////////////////////////////////////
void sfRenderImage_DrawPostFX(sfRenderImage* RenderImage, sfPostFX* PostFX)
void sfRenderImage_DrawPostFX(sfRenderImage* renderImage, sfPostFX* postFX)
{
CSFML_CHECK(PostFX);
CSFML_CALL(RenderImage, Draw(PostFX->This));
CSFML_CHECK(postFX);
CSFML_CALL(renderImage, Draw(postFX->This));
}
void sfRenderImage_DrawShape(sfRenderImage* RenderImage, sfShape* Shape)
void sfRenderImage_DrawShape(sfRenderImage* renderImage, sfShape* shape)
{
CSFML_CHECK(Shape);
CSFML_CALL(RenderImage, Draw(Shape->This));
CSFML_CHECK(shape);
CSFML_CALL(renderImage, Draw(shape->This));
}
void sfRenderImage_DrawSprite(sfRenderImage* RenderImage, sfSprite* Sprite)
void sfRenderImage_DrawSprite(sfRenderImage* renderImage, sfSprite* sprite)
{
CSFML_CHECK(Sprite);
CSFML_CALL(RenderImage, Draw(Sprite->This));
CSFML_CHECK(sprite);
CSFML_CALL(renderImage, Draw(sprite->This));
}
void sfRenderImage_DrawString(sfRenderImage* RenderImage, sfString* String)
void sfRenderImage_DrawString(sfRenderImage* renderImage, sfString* string)
{
CSFML_CHECK(String);
CSFML_CALL(RenderImage, Draw(String->This));
CSFML_CHECK(string);
CSFML_CALL(renderImage, Draw(string->This));
}
////////////////////////////////////////////////////////////
/// Clear the renderimage with the given color
////////////////////////////////////////////////////////////
void sfRenderImage_Clear(sfRenderImage* RenderImage, sfColor Color)
void sfRenderImage_Clear(sfRenderImage* renderImage, sfColor color)
{
sf::Color SFMLColor(Color.r, Color.g, Color.b, Color.a);
sf::Color SFMLColor(color.r, color.g, color.b, color.a);
CSFML_CALL(RenderImage, Clear(SFMLColor));
CSFML_CALL(renderImage, Clear(SFMLColor));
}
////////////////////////////////////////////////////////////
/// Change the current active view of a renderimage
////////////////////////////////////////////////////////////
void sfRenderImage_SetView(sfRenderImage* RenderImage, sfView* View)
void sfRenderImage_SetView(sfRenderImage* renderImage, sfView* view)
{
CSFML_CHECK(View);
CSFML_CALL(RenderImage, SetView(*View->This));
RenderImage->CurrentView = View;
CSFML_CHECK(view);
CSFML_CALL(renderImage, SetView(*view->This));
renderImage->CurrentView = view;
}
////////////////////////////////////////////////////////////
/// Get the current active view of a renderimage
////////////////////////////////////////////////////////////
const sfView* sfRenderImage_GetView(sfRenderImage* RenderImage)
const sfView* sfRenderImage_GetView(sfRenderImage* renderImage)
{
CSFML_CHECK_RETURN(RenderImage, NULL);
CSFML_CHECK_RETURN(renderImage, NULL);
return RenderImage->CurrentView;
return renderImage->CurrentView;
}
////////////////////////////////////////////////////////////
/// Get the default view of a renderimage
////////////////////////////////////////////////////////////
sfView* sfRenderImage_GetDefaultView(sfRenderImage* RenderImage)
sfView* sfRenderImage_GetDefaultView(sfRenderImage* renderImage)
{
CSFML_CHECK_RETURN(RenderImage, NULL);
CSFML_CHECK_RETURN(renderImage, NULL);
return RenderImage->DefaultView;
return renderImage->DefaultView;
}
@ -164,20 +164,20 @@ sfView* sfRenderImage_GetDefaultView(sfRenderImage* RenderImage)
/// SFML to do internal optimizations and improve performances.
/// This parameter is false by default
////////////////////////////////////////////////////////////
void sfRenderImage_PreserveOpenGLStates(sfRenderImage* RenderImage, sfBool Preserve)
void sfRenderImage_PreserveOpenGLStates(sfRenderImage* renderImage, sfBool preserve)
{
CSFML_CALL(RenderImage, PreserveOpenGLStates(Preserve == sfTrue));
CSFML_CALL(renderImage, PreserveOpenGLStates(preserve == sfTrue));
}
////////////////////////////////////////////////////////////
/// Get the target image
////////////////////////////////////////////////////////////
sfImage* sfRenderImage_GetImage(sfRenderImage* RenderImage)
sfImage* sfRenderImage_GetImage(sfRenderImage* renderImage)
{
CSFML_CHECK_RETURN(RenderImage, NULL);
CSFML_CHECK_RETURN(renderImage, NULL);
return RenderImage->Target;
return renderImage->Target;
}

240
CSFML/src/SFML/Graphics/Shape.cpp
View File

@ -43,114 +43,114 @@ sfShape* sfShape_Create()
////////////////////////////////////////////////////////////
/// Create a new shape made of a single line
////////////////////////////////////////////////////////////
sfShape* sfShape_CreateLine(float P1X, float P1Y, float P2X, float P2Y, float Thickness, sfColor Col, float Outline, sfColor OutlineCol)
sfShape* sfShape_CreateLine(float p1x, float p1y, float p2x, float p2y, float thickness, sfColor color, float outline, sfColor outlineColor)
{
sf::Color Color(Col.r, Col.g, Col.b, Col.a);
sf::Color OutlineColor(OutlineCol.r, OutlineCol.g, OutlineCol.b, OutlineCol.a);
sf::Color SFMLColor(color.r, color.g, color.b, color.a);
sf::Color SFMLOutlineColor(outlineColor.r, outlineColor.g, outlineColor.b, outlineColor.a);
sfShape* Shape = new sfShape;
Shape->This = sf::Shape::Line(P1X, P1Y, P2X, P2Y, Thickness, Color, Outline, OutlineColor);
return Shape;
sfShape* shape = new sfShape;
shape->This = sf::Shape::Line(p1x, p1y, p2x, p2y, thickness, SFMLColor, outline, SFMLOutlineColor);
return shape;
}
////////////////////////////////////////////////////////////
/// Create a new shape made of a single rectangle
////////////////////////////////////////////////////////////
sfShape* sfShape_CreateRectangle(float P1X, float P1Y, float P2X, float P2Y, sfColor Col, float Outline, sfColor OutlineCol)
sfShape* sfShape_CreateRectangle(float p1x, float p1y, float p2x, float p2y, sfColor color, float outline, sfColor outlineColor)
{
sf::Color Color(Col.r, Col.g, Col.b, Col.a);
sf::Color OutlineColor(OutlineCol.r, OutlineCol.g, OutlineCol.b, OutlineCol.a);
sf::Color SFMLColor(color.r, color.g, color.b, color.a);
sf::Color SFMLOutlineColor(outlineColor.r, outlineColor.g, outlineColor.b, outlineColor.a);
sfShape* Shape = new sfShape;
Shape->This = sf::Shape::Rectangle(P1X, P1Y, P2X, P2Y, Color, Outline, OutlineColor);
return Shape;
sfShape* shape = new sfShape;
shape->This = sf::Shape::Rectangle(p1x, p1y, p2x, p2y, SFMLColor, outline, SFMLOutlineColor);
return shape;
}
////////////////////////////////////////////////////////////
/// Create a new shape made of a single circle
////////////////////////////////////////////////////////////
sfShape* sfShape_CreateCircle(float X, float Y, float Radius, sfColor Col, float Outline, sfColor OutlineCol)
sfShape* sfShape_CreateCircle(float x, float y, float radius, sfColor color, float outline, sfColor outlineColor)
{
sf::Color Color(Col.r, Col.g, Col.b, Col.a);
sf::Color OutlineColor(OutlineCol.r, OutlineCol.g, OutlineCol.b, OutlineCol.a);
sf::Color SFMLColor(color.r, color.g, color.b, color.a);
sf::Color SFMLOutlineColor(outlineColor.r, outlineColor.g, outlineColor.b, outlineColor.a);
sfShape* Shape = new sfShape;
Shape->This = sf::Shape::Circle(X, Y, Radius, Color, Outline, OutlineColor);
return Shape;
sfShape* shape = new sfShape;
shape->This = sf::Shape::Circle(x, y, radius, SFMLColor, outline, SFMLOutlineColor);
return shape;
}
////////////////////////////////////////////////////////////
/// Destroy an existing shape
////////////////////////////////////////////////////////////
void sfShape_Destroy(sfShape* Shape)
void sfShape_Destroy(sfShape* shape)
{
delete Shape;
delete shape;
}
////////////////////////////////////////////////////////////
/// Set the X position of a shape
////////////////////////////////////////////////////////////
void sfShape_SetX(sfShape* Shape, float X)
void sfShape_SetX(sfShape* shape, float x)
{
CSFML_CALL(Shape, SetX(X))
CSFML_CALL(shape, SetX(x))
}
////////////////////////////////////////////////////////////
/// Set the Y position of a shape
////////////////////////////////////////////////////////////
void sfShape_SetY(sfShape* Shape, float Y)
void sfShape_SetY(sfShape* shape, float y)
{
CSFML_CALL(Shape, SetY(Y))
CSFML_CALL(shape, SetY(y))
}
////////////////////////////////////////////////////////////
/// Set the position of a shape
////////////////////////////////////////////////////////////
void sfShape_SetPosition(sfShape* Shape, float X, float Y)
void sfShape_SetPosition(sfShape* shape, float x, float y)
{
CSFML_CALL(Shape, SetPosition(sf::Vector2f(X, Y)))
CSFML_CALL(shape, SetPosition(sf::Vector2f(x, y)))
}
////////////////////////////////////////////////////////////
/// Set the horizontal scale of a shape
////////////////////////////////////////////////////////////
void sfShape_SetScaleX(sfShape* Shape, float Scale)
void sfShape_SetScaleX(sfShape* shape, float scale)
{
CSFML_CALL(Shape, SetScaleX(Scale))
CSFML_CALL(shape, SetScaleX(scale))
}
////////////////////////////////////////////////////////////
/// Set the vertical scale of a shape
////////////////////////////////////////////////////////////
void sfShape_SetScaleY(sfShape* Shape, float Scale)
void sfShape_SetScaleY(sfShape* shape, float scale)
{
CSFML_CALL(Shape, SetScaleY(Scale))
CSFML_CALL(shape, SetScaleY(scale))
}
////////////////////////////////////////////////////////////
/// Set the scale of a shape
////////////////////////////////////////////////////////////
void sfShape_SetScale(sfShape* Shape, float ScaleX, float ScaleY)
void sfShape_SetScale(sfShape* shape, float scaleX, float scaleY)
{
CSFML_CALL(Shape, SetScale(sf::Vector2f(ScaleX, ScaleY)))
CSFML_CALL(shape, SetScale(sf::Vector2f(scaleX, scaleY)))
}
////////////////////////////////////////////////////////////
/// Set the orientation of a shape
////////////////////////////////////////////////////////////
void sfShape_SetRotation(sfShape* Shape, float Rotation)
void sfShape_SetRotation(sfShape* shape, float rotation)
{
CSFML_CALL(Shape, SetRotation(Rotation))
CSFML_CALL(shape, SetRotation(rotation))
}
@ -158,102 +158,102 @@ void sfShape_SetRotation(sfShape* Shape, float Rotation)
/// Set the local origin of a shape, in coordinates
/// relative to its left-top corner
////////////////////////////////////////////////////////////
void sfShape_SetOrigin(sfShape* Shape, float X, float Y)
void sfShape_SetOrigin(sfShape* shape, float x, float y)
{
CSFML_CALL(Shape, SetOrigin(sf::Vector2f(X, Y)))
CSFML_CALL(shape, SetOrigin(sf::Vector2f(x, y)))
}
////////////////////////////////////////////////////////////
/// Set the color of a shape
////////////////////////////////////////////////////////////
void sfShape_SetColor(sfShape* Shape, sfColor Color)
void sfShape_SetColor(sfShape* shape, sfColor color)
{
CSFML_CALL(Shape, SetColor(sf::Color(Color.r, Color.g, Color.b, Color.a)))
CSFML_CALL(shape, SetColor(sf::Color(color.r, color.g, color.b, color.a)))
}
////////////////////////////////////////////////////////////
/// Set the blending mode for a shape
////////////////////////////////////////////////////////////
void sfShape_SetBlendMode(sfShape* Shape, sfBlendMode Mode)
void sfShape_SetBlendMode(sfShape* shape, sfBlendMode mode)
{
CSFML_CALL(Shape, SetBlendMode(static_cast<sf::Blend::Mode>(Mode)))
CSFML_CALL(shape, SetBlendMode(static_cast<sf::Blend::Mode>(mode)))
}
////////////////////////////////////////////////////////////
/// Get the X position of a shape
////////////////////////////////////////////////////////////
float sfShape_GetX(sfShape* Shape)
float sfShape_GetX(sfShape* shape)
{
CSFML_CALL_RETURN(Shape, GetPosition().x, 0.f)
CSFML_CALL_RETURN(shape, GetPosition().x, 0.f)
}
////////////////////////////////////////////////////////////
/// Get the Y position of a shape
////////////////////////////////////////////////////////////
float sfShape_GetY(sfShape* Shape)
float sfShape_GetY(sfShape* shape)
{
CSFML_CALL_RETURN(Shape, GetPosition().y, 0.f)
CSFML_CALL_RETURN(shape, GetPosition().y, 0.f)
}
////////////////////////////////////////////////////////////
/// Get the horizontal scale of a shape
////////////////////////////////////////////////////////////
float sfShape_GetScaleX(sfShape* Shape)
float sfShape_GetScaleX(sfShape* shape)
{
CSFML_CALL_RETURN(Shape, GetScale().x, 0.f)
CSFML_CALL_RETURN(shape, GetScale().x, 0.f)
}
////////////////////////////////////////////////////////////
/// Get the vertical scale of a shape
////////////////////////////////////////////////////////////
float sfShape_GetScaleY(sfShape* Shape)
float sfShape_GetScaleY(sfShape* shape)
{
CSFML_CALL_RETURN(Shape, GetScale().y, 0.f)
CSFML_CALL_RETURN(shape, GetScale().y, 0.f)
}
////////////////////////////////////////////////////////////
/// Get the orientation of a shape
////////////////////////////////////////////////////////////
float sfShape_GetRotation(sfShape* Shape)
float sfShape_GetRotation(sfShape* shape)
{
CSFML_CALL_RETURN(Shape, GetRotation(), 0.f)
CSFML_CALL_RETURN(shape, GetRotation(), 0.f)
}
////////////////////////////////////////////////////////////
/// Get the X position of the origin a shape
////////////////////////////////////////////////////////////
float sfShape_GetOriginX(sfShape* Shape)
float sfShape_GetOriginX(sfShape* shape)
{
CSFML_CALL_RETURN(Shape, GetOrigin().x, 0.f)
CSFML_CALL_RETURN(shape, GetOrigin().x, 0.f)
}
////////////////////////////////////////////////////////////
/// Get the Y position of the origin a shape
////////////////////////////////////////////////////////////
float sfShape_GetOriginY(sfShape* Shape)
float sfShape_GetOriginY(sfShape* shape)
{
CSFML_CALL_RETURN(Shape, GetOrigin().y, 0.f)
CSFML_CALL_RETURN(shape, GetOrigin().y, 0.f)
}
////////////////////////////////////////////////////////////
/// Get the color of a shape
////////////////////////////////////////////////////////////
sfColor sfShape_GetColor(sfShape* Shape)
sfColor sfShape_GetColor(sfShape* shape)
{
sfColor Color = {0, 0, 0, 0};
CSFML_CHECK_RETURN(Shape, Color)
sfColor color = {0, 0, 0, 0};
CSFML_CHECK_RETURN(Shape, color)
sf::Color SFMLColor = Shape->This.GetColor();
sf::Color SFMLColor = shape->This.GetColor();
return sfColor_FromRGBA(SFMLColor.r, SFMLColor.g, SFMLColor.b, SFMLColor.a);
}
@ -261,38 +261,38 @@ sfColor sfShape_GetColor(sfShape* Shape)
////////////////////////////////////////////////////////////
/// Get the current blending mode of a shape
////////////////////////////////////////////////////////////
sfBlendMode sfShape_GetBlendMode(sfShape* Shape)
sfBlendMode sfShape_GetBlendMode(sfShape* shape)
{
CSFML_CHECK_RETURN(Shape, sfBlendNone)
CSFML_CHECK_RETURN(shape, sfBlendNone)
return static_cast<sfBlendMode>(Shape->This.GetBlendMode());
return static_cast<sfBlendMode>(shape->This.GetBlendMode());
}
////////////////////////////////////////////////////////////
/// Move a shape
////////////////////////////////////////////////////////////
void sfShape_Move(sfShape* Shape, float OffsetX, float OffsetY)
void sfShape_Move(sfShape* shape, float offsetX, float offsetY)
{
CSFML_CALL(Shape, Move(sf::Vector2f(OffsetX, OffsetY)))
CSFML_CALL(shape, Move(sf::Vector2f(offsetX, offsetY)))
}
////////////////////////////////////////////////////////////
/// Scale a shape
////////////////////////////////////////////////////////////
void sfShape_Scale(sfShape* Shape, float FactorX, float FactorY)
void sfShape_Scale(sfShape* shape, float factorX, float factorY)
{
CSFML_CALL(Shape, Scale(sf::Vector2f(FactorX, FactorY)))
CSFML_CALL(shape, Scale(sf::Vector2f(factorX, factorY)))
}
////////////////////////////////////////////////////////////
/// Rotate a shape
////////////////////////////////////////////////////////////
void sfShape_Rotate(sfShape* Shape, float Angle)
void sfShape_Rotate(sfShape* shape, float angle)
{
CSFML_CALL(Shape, Rotate(Angle))
CSFML_CALL(shape, Rotate(angle))
}
@ -300,13 +300,13 @@ void sfShape_Rotate(sfShape* Shape, float Angle)
/// Transform a point from global coordinates into the shape's local coordinates
/// (ie it applies the inverse of object's origin, translation, rotation and scale to the point)
////////////////////////////////////////////////////////////
void sfShape_TransformToLocal(sfShape* Shape, float PointX, float PointY, float* X, float* Y)
void sfShape_TransformToLocal(sfShape* shape, float pointX, float pointY, float* x, float* y)
{
CSFML_CHECK(Shape)
CSFML_CHECK(shape)
sf::Vector2f Point = Shape->This.TransformToLocal(sf::Vector2f(PointX, PointY));
if (X) *X = Point.x;
if (Y) *Y = Point.y;
sf::Vector2f point = shape->This.TransformToLocal(sf::Vector2f(pointX, pointY));
if (x) *x = point.x;
if (y) *y = point.y;
}
@ -314,25 +314,25 @@ void sfShape_TransformToLocal(sfShape* Shape, float PointX, float PointY, float*
/// Transform a point from the shape's local coordinates into global coordinates
/// (ie it applies the object's origin, translation, rotation and scale to the point)
////////////////////////////////////////////////////////////
void sfShape_TransformToGlobal(sfShape* Shape, float PointX, float PointY, float* X, float* Y)
void sfShape_TransformToGlobal(sfShape* shape, float pointX, float pointY, float* x, float* y)
{
CSFML_CHECK(Shape)
CSFML_CHECK(shape)
sf::Vector2f Point = Shape->This.TransformToGlobal(sf::Vector2f(PointX, PointY));
if (X) *X = Point.x;
if (Y) *Y = Point.y;
sf::Vector2f point = shape->This.TransformToGlobal(sf::Vector2f(pointX, pointY));
if (x) *x = point.x;
if (y) *y = point.y;
}
////////////////////////////////////////////////////////////
/// Add a point to a shape
////////////////////////////////////////////////////////////
void sfShape_AddPoint(sfShape* Shape, float X, float Y, sfColor Col, sfColor OutlineCol)
void sfShape_AddPoint(sfShape* shape, float x, float y, sfColor color, sfColor outlineColor)
{
sf::Color Color(Col.r, Col.g, Col.b, Col.a);
sf::Color OutlineColor(OutlineCol.r, OutlineCol.g, OutlineCol.b, OutlineCol.a);
sf::Color SFMLColor(color.r, color.g, color.b, color.a);
sf::Color SFMLOutlineColor(outlineColor.r, outlineColor.g, outlineColor.b, outlineColor.a);
CSFML_CALL(Shape, AddPoint(X, Y, Color, OutlineColor))
CSFML_CALL(shape, AddPoint(x, y, SFMLColor, SFMLOutlineColor))
}
@ -340,9 +340,9 @@ void sfShape_AddPoint(sfShape* Shape, float X, float Y, sfColor Col, sfColor Out
/// Enable or disable filling a shape.
/// Fill is enabled by default
////////////////////////////////////////////////////////////
void sfShape_EnableFill(sfShape* Shape, sfBool Enable)
void sfShape_EnableFill(sfShape* shape, sfBool enable)
{
CSFML_CALL(Shape, EnableFill(Enable == sfTrue))
CSFML_CALL(shape, EnableFill(enable == sfTrue))
}
@ -350,109 +350,109 @@ void sfShape_EnableFill(sfShape* Shape, sfBool Enable)
/// Enable or disable drawing a shape outline.
/// Outline is enabled by default
////////////////////////////////////////////////////////////
void sfShape_EnableOutline(sfShape* Shape, sfBool Enable)
void sfShape_EnableOutline(sfShape* shape, sfBool enable)
{
CSFML_CALL(Shape, EnableOutline(Enable == sfTrue))
CSFML_CALL(shape, EnableOutline(enable == sfTrue))
}
////////////////////////////////////////////////////////////
/// Change the width of a shape outline
////////////////////////////////////////////////////////////
void sfShape_SetOutlineWidth(sfShape* Shape, float Width)
void sfShape_SetOutlineWidth(sfShape* shape, float width)
{
CSFML_CALL(Shape, SetOutlineWidth(Width))
CSFML_CALL(shape, SetOutlineWidth(width))
}
////////////////////////////////////////////////////////////
/// Get the width of a shape outline
////////////////////////////////////////////////////////////
float sfShape_GetOutlineWidth(sfShape* Shape)
float sfShape_GetOutlineWidth(sfShape* shape)
{
CSFML_CALL_RETURN(Shape, GetOutlineWidth(), 0.f)
CSFML_CALL_RETURN(shape, GetOutlineWidth(), 0.f)
}
////////////////////////////////////////////////////////////
/// Get the number of points composing a shape
////////////////////////////////////////////////////////////
unsigned int sfShape_GetNbPoints(sfShape* Shape)
unsigned int sfShape_GetNbPoints(sfShape* shape)
{
CSFML_CALL_RETURN(Shape, GetNbPoints(), 0)
CSFML_CALL_RETURN(shape, GetNbPoints(), 0)
}
////////////////////////////////////////////////////////////
/// Get a point of a shape
////////////////////////////////////////////////////////////
void sfShape_GetPointPosition(sfShape* Shape, unsigned int Index, float* X, float* Y)
void sfShape_GetPointPosition(sfShape* shape, unsigned int index, float* x, float* y)
{
CSFML_CHECK(Shape)
CSFML_CHECK(shape)
sf::Vector2f Point = Shape->This.GetPointPosition(Index);
if (X) *X = Point.x;
if (Y) *Y = Point.y;
sf::Vector2f point = shape->This.GetPointPosition(index);
if (x) *x = point.x;
if (y) *y = point.y;
}
////////////////////////////////////////////////////////////
/// Get a the color of a shape's point
////////////////////////////////////////////////////////////
sfColor sfShape_GetPointColor(sfShape* Shape, unsigned int Index)
sfColor sfShape_GetPointColor(sfShape* shape, unsigned int index)
{
sfColor Color = {255, 255, 255, 255};
CSFML_CHECK_RETURN(Shape, Color)
sfColor color = {255, 255, 255, 255};
CSFML_CHECK_RETURN(Shape, color)
const sf::Color& SFMLColor = Shape->This.GetPointColor(Index);
Color.r = SFMLColor.r;
Color.g = SFMLColor.g;
Color.b = SFMLColor.b;
Color.a = SFMLColor.a;
const sf::Color& SFMLColor = shape->This.GetPointColor(index);
color.r = SFMLColor.r;
color.g = SFMLColor.g;
color.b = SFMLColor.b;
color.a = SFMLColor.a;
return Color;
return color;
}
////////////////////////////////////////////////////////////
/// Get a the outline color of a shape's point
////////////////////////////////////////////////////////////
sfColor sfShape_GetPointOutlineColor(sfShape* Shape, unsigned int Index)
sfColor sfShape_GetPointOutlineColor(sfShape* shape, unsigned int index)
{
sfColor Color = {255, 255, 255, 255};
CSFML_CHECK_RETURN(Shape, Color)
sfColor color = {255, 255, 255, 255};
CSFML_CHECK_RETURN(Shape, color)
const sf::Color& SFMLColor = Shape->This.GetPointOutlineColor(Index);
Color.r = SFMLColor.r;
Color.g = SFMLColor.g;
Color.b = SFMLColor.b;
Color.a = SFMLColor.a;
const sf::Color& SFMLColor = shape->This.GetPointOutlineColor(index);
color.r = SFMLColor.r;
color.g = SFMLColor.g;
color.b = SFMLColor.b;
color.a = SFMLColor.a;
return Color;
return color;
}
////////////////////////////////////////////////////////////
/// Set a the position of a shape's point
////////////////////////////////////////////////////////////
void sfShape_SetPointPosition(sfShape* Shape, unsigned int Index, float X, float Y)
void sfShape_SetPointPosition(sfShape* shape, unsigned int index, float x, float y)
{
CSFML_CALL(Shape, SetPointPosition(Index, X, Y));
CSFML_CALL(shape, SetPointPosition(index, x, y));
}
////////////////////////////////////////////////////////////
/// Set a the color of a shape's point
////////////////////////////////////////////////////////////
void sfShape_SetPointColor(sfShape* Shape, unsigned int Index, sfColor Color)
void sfShape_SetPointColor(sfShape* shape, unsigned int index, sfColor color)
{
CSFML_CALL(Shape, SetPointColor(Index, sf::Color(Color.r, Color.g, Color.b, Color.a)));
CSFML_CALL(shape, SetPointColor(index, sf::Color(color.r, color.g, color.b, color.a)));
}
////////////////////////////////////////////////////////////
/// Set a the outline color of a shape's point
////////////////////////////////////////////////////////////
void sfShape_SetPointOutlineColor(sfShape* Shape, unsigned int Index, sfColor Color)
void sfShape_SetPointOutlineColor(sfShape* shape, unsigned int index, sfColor color)
{
CSFML_CALL(Shape, SetPointOutlineColor(Index, sf::Color(Color.r, Color.g, Color.b, Color.a)));
CSFML_CALL(shape, SetPointOutlineColor(index, sf::Color(color.r, color.g, color.b, color.a)));
}

188
CSFML/src/SFML/Graphics/Sprite.cpp
View File

@ -37,86 +37,86 @@
////////////////////////////////////////////////////////////
sfSprite* sfSprite_Create()
{
sfSprite* Sprite = new sfSprite;
Sprite->Image = NULL;
Sprite->SubRect.Left = Sprite->This.GetSubRect().Left;
Sprite->SubRect.Top = Sprite->This.GetSubRect().Top;
Sprite->SubRect.Right = Sprite->This.GetSubRect().Right;
Sprite->SubRect.Bottom = Sprite->This.GetSubRect().Bottom;
sfSprite* sprite = new sfSprite;
sprite->Image = NULL;
sprite->SubRect.Left = sprite->This.GetSubRect().Left;
sprite->SubRect.Top = sprite->This.GetSubRect().Top;
sprite->SubRect.Right = sprite->This.GetSubRect().Right;
sprite->SubRect.Bottom = sprite->This.GetSubRect().Bottom;
return Sprite;
return sprite;
}
////////////////////////////////////////////////////////////
/// Destroy an existing sprite
////////////////////////////////////////////////////////////
void sfSprite_Destroy(sfSprite* Sprite)
void sfSprite_Destroy(sfSprite* sprite)
{
delete Sprite;
delete sprite;
}
////////////////////////////////////////////////////////////
/// Set the X position of a sprite
////////////////////////////////////////////////////////////
void sfSprite_SetX(sfSprite* Sprite, float X)
void sfSprite_SetX(sfSprite* sprite, float x)
{
CSFML_CALL(Sprite, SetX(X))
CSFML_CALL(sprite, SetX(x))
}
////////////////////////////////////////////////////////////
/// Set the Y position of a sprite
////////////////////////////////////////////////////////////
void sfSprite_SetY(sfSprite* Sprite, float Y)
void sfSprite_SetY(sfSprite* sprite, float y)
{
CSFML_CALL(Sprite, SetY(Y))
CSFML_CALL(sprite, SetY(y))
}
////////////////////////////////////////////////////////////
/// Set the position of a sprite
////////////////////////////////////////////////////////////
void sfSprite_SetPosition(sfSprite* Sprite, float X, float Y)
void sfSprite_SetPosition(sfSprite* sprite, float x, float y)
{
CSFML_CALL(Sprite, SetPosition(sf::Vector2f(X, Y)))
CSFML_CALL(sprite, SetPosition(sf::Vector2f(x, y)))
}
////////////////////////////////////////////////////////////
/// Set the horizontal scale of a sprite
////////////////////////////////////////////////////////////
void sfSprite_SetScaleX(sfSprite* Sprite, float Scale)
void sfSprite_SetScaleX(sfSprite* sprite, float scale)
{
CSFML_CALL(Sprite, SetScaleX(Scale))
CSFML_CALL(sprite, SetScaleX(scale))
}
////////////////////////////////////////////////////////////
/// Set the vertical scale of a sprite
////////////////////////////////////////////////////////////
void sfSprite_SetScaleY(sfSprite* Sprite, float Scale)
void sfSprite_SetScaleY(sfSprite* sprite, float scale)
{
CSFML_CALL(Sprite, SetScaleY(Scale))
CSFML_CALL(sprite, SetScaleY(scale))
}
////////////////////////////////////////////////////////////
/// Set the scale of a sprite
////////////////////////////////////////////////////////////
void sfSprite_SetScale(sfSprite* Sprite, float ScaleX, float ScaleY)
void sfSprite_SetScale(sfSprite* sprite, float scaleX, float scaleY)
{
CSFML_CALL(Sprite, SetScale(sf::Vector2f(ScaleX, ScaleY)))
CSFML_CALL(sprite, SetScale(sf::Vector2f(scaleX, scaleY)))
}
////////////////////////////////////////////////////////////
/// Set the orientation of a sprite
////////////////////////////////////////////////////////////
void sfSprite_SetRotation(sfSprite* Sprite, float Rotation)
void sfSprite_SetRotation(sfSprite* sprite, float rotation)
{
CSFML_CALL(Sprite, SetRotation(Rotation))
CSFML_CALL(sprite, SetRotation(rotation))
}
@ -124,102 +124,102 @@ void sfSprite_SetRotation(sfSprite* Sprite, float Rotation)
/// Set the local origin of a sprite, in coordinates
/// relative to its left-top corner
////////////////////////////////////////////////////////////
void sfSprite_SetOrigin(sfSprite* Sprite, float X, float Y)
void sfSprite_SetOrigin(sfSprite* sprite, float x, float y)
{
CSFML_CALL(Sprite, SetOrigin(sf::Vector2f(X, Y)))
CSFML_CALL(sprite, SetOrigin(sf::Vector2f(x, y)))
}
////////////////////////////////////////////////////////////
/// Set the color of a sprite
////////////////////////////////////////////////////////////
void sfSprite_SetColor(sfSprite* Sprite, sfColor Color)
void sfSprite_SetColor(sfSprite* sprite, sfColor color)
{
CSFML_CALL(Sprite, SetColor(sf::Color(Color.r, Color.g, Color.b, Color.a)))
CSFML_CALL(sprite, SetColor(sf::Color(color.r, color.g, color.b, color.a)))
}
////////////////////////////////////////////////////////////
/// Set the blending mode for a sprite
////////////////////////////////////////////////////////////
void sfSprite_SetBlendMode(sfSprite* Sprite, sfBlendMode Mode)
void sfSprite_SetBlendMode(sfSprite* sprite, sfBlendMode mode)
{
CSFML_CALL(Sprite, SetBlendMode(static_cast<sf::Blend::Mode>(Mode)))
CSFML_CALL(sprite, SetBlendMode(static_cast<sf::Blend::Mode>(mode)))
}
////////////////////////////////////////////////////////////
/// Get the X position of a sprite
////////////////////////////////////////////////////////////
float sfSprite_GetX(sfSprite* Sprite)
float sfSprite_GetX(sfSprite* sprite)
{
CSFML_CALL_RETURN(Sprite, GetPosition().x, 0.f)
CSFML_CALL_RETURN(sprite, GetPosition().x, 0.f)
}
////////////////////////////////////////////////////////////
/// Get the Y position of a sprite
////////////////////////////////////////////////////////////
float sfSprite_GetY(sfSprite* Sprite)
float sfSprite_GetY(sfSprite* sprite)
{
CSFML_CALL_RETURN(Sprite, GetPosition().y, 0.f)
CSFML_CALL_RETURN(sprite, GetPosition().y, 0.f)
}
////////////////////////////////////////////////////////////
/// Get the horizontal scale of a sprite
////////////////////////////////////////////////////////////
float sfSprite_GetScaleX(sfSprite* Sprite)
float sfSprite_GetScaleX(sfSprite* sprite)
{
CSFML_CALL_RETURN(Sprite, GetScale().x, 0.f)
CSFML_CALL_RETURN(sprite, GetScale().x, 0.f)
}
////////////////////////////////////////////////////////////
/// Get the vertical scale of a sprite
////////////////////////////////////////////////////////////
float sfSprite_GetScaleY(sfSprite* Sprite)
float sfSprite_GetScaleY(sfSprite* sprite)
{
CSFML_CALL_RETURN(Sprite, GetScale().y, 0.f)
CSFML_CALL_RETURN(sprite, GetScale().y, 0.f)
}
////////////////////////////////////////////////////////////
/// Get the orientation of a sprite
////////////////////////////////////////////////////////////
float sfSprite_GetRotation(sfSprite* Sprite)
float sfSprite_GetRotation(sfSprite* sprite)
{
CSFML_CALL_RETURN(Sprite, GetRotation(), 0.f)
CSFML_CALL_RETURN(sprite, GetRotation(), 0.f)
}
////////////////////////////////////////////////////////////
/// Get the X position of the origin a sprite
////////////////////////////////////////////////////////////
float sfSprite_GetOriginX(sfSprite* Sprite)
float sfSprite_GetOriginX(sfSprite* sprite)
{
CSFML_CALL_RETURN(Sprite, GetOrigin().x, 0.f)
CSFML_CALL_RETURN(sprite, GetOrigin().x, 0.f)
}
////////////////////////////////////////////////////////////
/// Get the Y position of the origin a sprite
////////////////////////////////////////////////////////////
float sfSprite_GetOriginY(sfSprite* Sprite)
float sfSprite_GetOriginY(sfSprite* sprite)
{
CSFML_CALL_RETURN(Sprite, GetOrigin().y, 0.f)
CSFML_CALL_RETURN(sprite, GetOrigin().y, 0.f)
}
////////////////////////////////////////////////////////////
/// Get the color of a sprite
////////////////////////////////////////////////////////////
sfColor sfSprite_GetColor(sfSprite* Sprite)
sfColor sfSprite_GetColor(sfSprite* sprite)
{
sfColor Color = {0, 0, 0, 0};
CSFML_CHECK_RETURN(Sprite, Color)
sfColor color = {0, 0, 0, 0};
CSFML_CHECK_RETURN(sprite, color)
sf::Color SFMLColor = Sprite->This.GetColor();
sf::Color SFMLColor = sprite->This.GetColor();
return sfColor_FromRGBA(SFMLColor.r, SFMLColor.g, SFMLColor.b, SFMLColor.a);
}
@ -227,38 +227,38 @@ sfColor sfSprite_GetColor(sfSprite* Sprite)
////////////////////////////////////////////////////////////
/// Get the current blending mode of a sprite
////////////////////////////////////////////////////////////
sfBlendMode sfSprite_GetBlendMode(sfSprite* Sprite)
sfBlendMode sfSprite_GetBlendMode(sfSprite* sprite)
{
CSFML_CHECK_RETURN(Sprite, sfBlendNone)
CSFML_CHECK_RETURN(sprite, sfBlendNone)
return static_cast<sfBlendMode>(Sprite->This.GetBlendMode());
return static_cast<sfBlendMode>(sprite->This.GetBlendMode());
}
////////////////////////////////////////////////////////////
/// Move a sprite
////////////////////////////////////////////////////////////
void sfSprite_Move(sfSprite* Sprite, float OffsetX, float OffsetY)
void sfSprite_Move(sfSprite* sprite, float offsetX, float offsetY)
{
CSFML_CALL(Sprite, Move(sf::Vector2f(OffsetX, OffsetY)))
CSFML_CALL(sprite, Move(sf::Vector2f(offsetX, offsetY)))
}
////////////////////////////////////////////////////////////
/// Scale a sprite
////////////////////////////////////////////////////////////
void sfSprite_Scale(sfSprite* Sprite, float FactorX, float FactorY)
void sfSprite_Scale(sfSprite* sprite, float factorX, float factorY)
{
CSFML_CALL(Sprite, Scale(sf::Vector2f(FactorX, FactorY)))
CSFML_CALL(sprite, Scale(sf::Vector2f(factorX, factorY)))
}
////////////////////////////////////////////////////////////
/// Rotate a sprite
////////////////////////////////////////////////////////////
void sfSprite_Rotate(sfSprite* Sprite, float Angle)
void sfSprite_Rotate(sfSprite* sprite, float angle)
{
CSFML_CALL(Sprite, Rotate(Angle))
CSFML_CALL(sprite, Rotate(angle))
}
@ -266,13 +266,13 @@ void sfSprite_Rotate(sfSprite* Sprite, float Angle)
/// Transform a point from global coordinates into the sprite's local coordinates
/// (ie it applies the inverse of object's origin, translation, rotation and scale to the point)
////////////////////////////////////////////////////////////
void sfSprite_TransformToLocal(sfSprite* Sprite, float PointX, float PointY, float* X, float* Y)
void sfSprite_TransformToLocal(sfSprite* sprite, float pointX, float pointY, float* x, float* y)
{
CSFML_CHECK(Sprite)
CSFML_CHECK(sprite)
sf::Vector2f Point = Sprite->This.TransformToLocal(sf::Vector2f(PointX, PointY));
if (X) *X = Point.x;
if (Y) *Y = Point.y;
sf::Vector2f point = sprite->This.TransformToLocal(sf::Vector2f(pointX, pointY));
if (x) *x = point.x;
if (y) *y = point.y;
}
@ -280,25 +280,25 @@ void sfSprite_TransformToLocal(sfSprite* Sprite, float PointX, float PointY, flo
/// Transform a point from the sprite's local coordinates into global coordinates
/// (ie it applies the object's origin, translation, rotation and scale to the point)
////////////////////////////////////////////////////////////
void sfSprite_TransformToGlobal(sfSprite* Sprite, float PointX, float PointY, float* X, float* Y)
void sfSprite_TransformToGlobal(sfSprite* sprite, float pointX, float pointY, float* x, float* y)
{
CSFML_CHECK(Sprite)
CSFML_CHECK(sprite)
sf::Vector2f Point = Sprite->This.TransformToGlobal(sf::Vector2f(PointX, PointY));
if (X) *X = Point.x;
if (Y) *Y = Point.y;
sf::Vector2f point = sprite->This.TransformToGlobal(sf::Vector2f(pointX, pointY));
if (x) *x = point.x;
if (y) *y = point.y;
}
////////////////////////////////////////////////////////////
/// Change the image of a sprite
////////////////////////////////////////////////////////////
void sfSprite_SetImage(sfSprite* Sprite, sfImage* Image)
void sfSprite_SetImage(sfSprite* sprite, sfImage* image)
{
if (Image)
if (image)
{
CSFML_CALL(Sprite, SetImage(*Image->This))
Sprite->Image = Image;
CSFML_CALL(sprite, SetImage(*image->This))
sprite->Image = image;
}
}
@ -306,89 +306,89 @@ void sfSprite_SetImage(sfSprite* Sprite, sfImage* Image)
////////////////////////////////////////////////////////////
/// Set the sub-rectangle of a sprite inside the source image
////////////////////////////////////////////////////////////
void sfSprite_SetSubRect(sfSprite* Sprite, sfIntRect SubRect)
void sfSprite_SetSubRect(sfSprite* sprite, sfIntRect rectangle)
{
CSFML_CALL(Sprite, SetSubRect(sf::IntRect(SubRect.Left, SubRect.Top, SubRect.Right, SubRect.Bottom)))
Sprite->SubRect = SubRect;
CSFML_CALL(sprite, SetSubRect(sf::IntRect(rectangle.Left, rectangle.Top, rectangle.Right, rectangle.Bottom)))
sprite->SubRect = rectangle;
}
////////////////////////////////////////////////////////////
/// Resize a sprite (by changing its scale factors)
////////////////////////////////////////////////////////////
void sfSprite_Resize(sfSprite* Sprite, float Width, float Height)
void sfSprite_Resize(sfSprite* sprite, float width, float height)
{
CSFML_CALL(Sprite, Resize(sf::Vector2f(Width, Height)))
CSFML_CALL(sprite, Resize(sf::Vector2f(width, height)))
}
////////////////////////////////////////////////////////////
/// Flip a sprite horizontally
////////////////////////////////////////////////////////////
void sfSprite_FlipX(sfSprite* Sprite, sfBool Flipped)
void sfSprite_FlipX(sfSprite* sprite, sfBool flipped)
{
CSFML_CALL(Sprite, FlipX(Flipped == sfTrue))
CSFML_CALL(sprite, FlipX(flipped == sfTrue))
}
////////////////////////////////////////////////////////////
/// Flip a sprite vertically
////////////////////////////////////////////////////////////
void sfSprite_FlipY(sfSprite* Sprite, sfBool Flipped)
void sfSprite_FlipY(sfSprite* sprite, sfBool flipped)
{
CSFML_CALL(Sprite, FlipY(Flipped == sfTrue))
CSFML_CALL(sprite, FlipY(flipped == sfTrue))
}
////////////////////////////////////////////////////////////
/// Get the source image of a sprite
////////////////////////////////////////////////////////////
sfImage* sfSprite_GetImage(sfSprite* Sprite)
sfImage* sfSprite_GetImage(sfSprite* sprite)
{
CSFML_CHECK_RETURN(Sprite, NULL)
CSFML_CHECK_RETURN(sprite, NULL)
return Sprite->Image;
return sprite->Image;
}
////////////////////////////////////////////////////////////
/// Get the sub-rectangle of a sprite inside the source image
////////////////////////////////////////////////////////////
sfIntRect sfSprite_GetSubRect(sfSprite* Sprite)
sfIntRect sfSprite_GetSubRect(sfSprite* sprite)
{
sfIntRect Rect = {0, 0, 0, 0};
CSFML_CHECK_RETURN(Sprite, Rect)
sfIntRect rect = {0, 0, 0, 0};
CSFML_CHECK_RETURN(sprite, rect)
return Sprite->SubRect;
return sprite->SubRect;
}
////////////////////////////////////////////////////////////
/// Get a sprite width
////////////////////////////////////////////////////////////
float sfSprite_GetWidth(sfSprite* Sprite)
float sfSprite_GetWidth(sfSprite* sprite)
{
CSFML_CALL_RETURN(Sprite, GetSize().x, 0.f)
CSFML_CALL_RETURN(sprite, GetSize().x, 0.f)
}
////////////////////////////////////////////////////////////
/// Get a sprite height
////////////////////////////////////////////////////////////
float sfSprite_GetHeight(sfSprite* Sprite)
float sfSprite_GetHeight(sfSprite* sprite)
{
CSFML_CALL_RETURN(Sprite, GetSize().y, 0.f)
CSFML_CALL_RETURN(sprite, GetSize().y, 0.f)
}
////////////////////////////////////////////////////////////
/// Get the color of a given pixel in a sprite
////////////////////////////////////////////////////////////
sfColor sfSprite_GetPixel(sfSprite* Sprite, unsigned int X, unsigned int Y)
sfColor sfSprite_GetPixel(sfSprite* sprite, unsigned int x, unsigned int y)
{
sfColor Color = {0, 0, 0, 0};
CSFML_CHECK_RETURN(Sprite, Color)
sfColor color = {0, 0, 0, 0};
CSFML_CHECK_RETURN(sprite, color)
sf::Color SFMLColor = Sprite->This.GetPixel(X, Y);
sf::Color SFMLColor = sprite->This.GetPixel(x, y);
return sfColor_FromRGBA(SFMLColor.r, SFMLColor.g, SFMLColor.b, SFMLColor.a);
}

206
CSFML/src/SFML/Graphics/String.cpp
View File

@ -37,82 +37,82 @@
////////////////////////////////////////////////////////////
sfString* sfString_Create()
{
sfString* String = new sfString;
String->Font = sfFont_GetDefaultFont();
sfString* string = new sfString;
string->Font = sfFont_GetDefaultFont();
return String;
return string;
}
////////////////////////////////////////////////////////////
/// Destroy an existing string
////////////////////////////////////////////////////////////
void sfString_Destroy(sfString* String)
void sfString_Destroy(sfString* string)
{
delete String;
delete string;
}
////////////////////////////////////////////////////////////
/// Set the X position of a string
////////////////////////////////////////////////////////////
void sfString_SetX(sfString* String, float X)
void sfString_SetX(sfString* string, float x)
{
CSFML_CALL(String, SetX(X))
CSFML_CALL(string, SetX(x))
}
////////////////////////////////////////////////////////////
/// Set the Y position of a string
////////////////////////////////////////////////////////////
void sfString_SetY(sfString* String, float Y)
void sfString_SetY(sfString* string, float y)
{
CSFML_CALL(String, SetY(Y))
CSFML_CALL(string, SetY(y))
}
////////////////////////////////////////////////////////////
/// Set the position of a string
////////////////////////////////////////////////////////////
void sfString_SetPosition(sfString* String, float X, float Y)
void sfString_SetPosition(sfString* string, float x, float y)
{
CSFML_CALL(String, SetPosition(sf::Vector2f(X, Y)))
CSFML_CALL(string, SetPosition(sf::Vector2f(x, y)))
}
////////////////////////////////////////////////////////////
/// Set the horizontal scale of a string
////////////////////////////////////////////////////////////
void sfString_SetScaleX(sfString* String, float Scale)
void sfString_SetScaleX(sfString* string, float scale)
{
CSFML_CALL(String, SetScaleX(Scale))
CSFML_CALL(string, SetScaleX(scale))
}
////////////////////////////////////////////////////////////
/// Set the vertical scale of a string
////////////////////////////////////////////////////////////
void sfString_SetScaleY(sfString* String, float Scale)
void sfString_SetScaleY(sfString* string, float scale)
{
CSFML_CALL(String, SetScaleY(Scale))
CSFML_CALL(string, SetScaleY(scale))
}
////////////////////////////////////////////////////////////
/// Set the scale of a string
////////////////////////////////////////////////////////////
void sfString_SetScale(sfString* String, float ScaleX, float ScaleY)
void sfString_SetScale(sfString* string, float scaleX, float scaleY)
{
CSFML_CALL(String, SetScale(sf::Vector2f(ScaleX, ScaleY)))
CSFML_CALL(string, SetScale(sf::Vector2f(scaleX, scaleY)))
}
////////////////////////////////////////////////////////////
/// Set the orientation of a string
////////////////////////////////////////////////////////////
void sfString_SetRotation(sfString* String, float Rotation)
void sfString_SetRotation(sfString* string, float rotation)
{
CSFML_CALL(String, SetRotation(Rotation))
CSFML_CALL(string, SetRotation(rotation))
}
@ -120,102 +120,102 @@ void sfString_SetRotation(sfString* String, float Rotation)
/// Set the local origin of a string, in coordinates
/// relative to its left-top corner
////////////////////////////////////////////////////////////
void sfString_SetOrigin(sfString* String, float X, float Y)
void sfString_SetOrigin(sfString* string, float x, float y)
{
CSFML_CALL(String, SetOrigin(sf::Vector2f(X, Y)))
CSFML_CALL(string, SetOrigin(sf::Vector2f(x, y)))
}
////////////////////////////////////////////////////////////
/// Set the color of a string
////////////////////////////////////////////////////////////
void sfString_SetColor(sfString* String, sfColor Color)
void sfString_SetColor(sfString* string, sfColor color)
{
CSFML_CALL(String, SetColor(sf::Color(Color.r, Color.g, Color.b, Color.a)))
CSFML_CALL(string, SetColor(sf::Color(color.r, color.g, color.b, color.a)))
}
////////////////////////////////////////////////////////////
/// Set the blending mode for a string
////////////////////////////////////////////////////////////
void sfString_SetBlendMode(sfString* String, sfBlendMode Mode)
void sfString_SetBlendMode(sfString* string, sfBlendMode mode)
{
CSFML_CALL(String, SetBlendMode(static_cast<sf::Blend::Mode>(Mode)))
CSFML_CALL(string, SetBlendMode(static_cast<sf::Blend::Mode>(mode)))
}
////////////////////////////////////////////////////////////
/// Get the X position of a string
////////////////////////////////////////////////////////////
float sfString_GetX(sfString* String)
float sfString_GetX(sfString* string)
{
CSFML_CALL_RETURN(String, GetPosition().x, 0.f)
CSFML_CALL_RETURN(string, GetPosition().x, 0.f)
}
////////////////////////////////////////////////////////////
/// Get the Y position of a string
////////////////////////////////////////////////////////////
float sfString_GetY(sfString* String)
float sfString_GetY(sfString* string)
{
CSFML_CALL_RETURN(String, GetPosition().y, 0.f)
CSFML_CALL_RETURN(string, GetPosition().y, 0.f)
}
////////////////////////////////////////////////////////////
/// Get the horizontal scale of a string
////////////////////////////////////////////////////////////
float sfString_GetScaleX(sfString* String)
float sfString_GetScaleX(sfString* string)
{
CSFML_CALL_RETURN(String, GetScale().x, 0.f)
CSFML_CALL_RETURN(string, GetScale().x, 0.f)
}
////////////////////////////////////////////////////////////
/// Get the vertical scale of a string
////////////////////////////////////////////////////////////
float sfString_GetScaleY(sfString* String)
float sfString_GetScaleY(sfString* string)
{
CSFML_CALL_RETURN(String, GetScale().y, 0.f)
CSFML_CALL_RETURN(string, GetScale().y, 0.f)
}
////////////////////////////////////////////////////////////
/// Get the orientation of a string
////////////////////////////////////////////////////////////
float sfString_GetRotation(sfString* String)
float sfString_GetRotation(sfString* string)
{
CSFML_CALL_RETURN(String, GetRotation(), 0.f)
CSFML_CALL_RETURN(string, GetRotation(), 0.f)
}
////////////////////////////////////////////////////////////
/// Get the X position of the origin a string
////////////////////////////////////////////////////////////
float sfString_GetOriginX(sfString* String)
float sfString_GetOriginX(sfString* string)
{
CSFML_CALL_RETURN(String, GetOrigin().x, 0.f)
CSFML_CALL_RETURN(string, GetOrigin().x, 0.f)
}
////////////////////////////////////////////////////////////
/// Get the top Y of the origin of a string
////////////////////////////////////////////////////////////
float sfString_GetOriginY(sfString* String)
float sfString_GetOriginY(sfString* string)
{
CSFML_CALL_RETURN(String, GetOrigin().y, 0.f)
CSFML_CALL_RETURN(string, GetOrigin().y, 0.f)
}
////////////////////////////////////////////////////////////
/// Get the color of a string
////////////////////////////////////////////////////////////
sfColor sfString_GetColor(sfString* String)
sfColor sfString_GetColor(sfString* string)
{
sfColor Color = {0, 0, 0, 0};
CSFML_CHECK_RETURN(String, Color)
sfColor color = {0, 0, 0, 0};
CSFML_CHECK_RETURN(string, color)
sf::Color SFMLColor = String->This.GetColor();
sf::Color SFMLColor = string->This.GetColor();
return sfColor_FromRGBA(SFMLColor.r, SFMLColor.g, SFMLColor.b, SFMLColor.a);
}
@ -223,38 +223,38 @@ sfColor sfString_GetColor(sfString* String)
////////////////////////////////////////////////////////////
/// Get the current blending mode of a string
////////////////////////////////////////////////////////////
sfBlendMode sfString_GetBlendMode(sfString* String)
sfBlendMode sfString_GetBlendMode(sfString* string)
{
CSFML_CHECK_RETURN(String, sfBlendNone)
CSFML_CHECK_RETURN(string, sfBlendNone)
return static_cast<sfBlendMode>(String->This.GetBlendMode());
return static_cast<sfBlendMode>(string->This.GetBlendMode());
}
////////////////////////////////////////////////////////////
/// Move a string
////////////////////////////////////////////////////////////
void sfString_Move(sfString* String, float OffsetX, float OffsetY)
void sfString_Move(sfString* string, float offsetX, float offsetY)
{
CSFML_CALL(String, Move(sf::Vector2f(OffsetX, OffsetY)))
CSFML_CALL(string, Move(sf::Vector2f(offsetX, offsetY)))
}
////////////////////////////////////////////////////////////
/// Scale a string
////////////////////////////////////////////////////////////
void sfString_Scale(sfString* String, float FactorX, float FactorY)
void sfString_Scale(sfString* string, float factorX, float factorY)
{
CSFML_CALL(String, Scale(sf::Vector2f(FactorX, FactorY)))
CSFML_CALL(string, Scale(sf::Vector2f(factorX, factorY)))
}
////////////////////////////////////////////////////////////
/// Rotate a string
////////////////////////////////////////////////////////////
void sfString_Rotate(sfString* String, float Angle)
void sfString_Rotate(sfString* string, float angle)
{
CSFML_CALL(String, Rotate(Angle))
CSFML_CALL(string, Rotate(angle))
}
@ -262,13 +262,13 @@ void sfString_Rotate(sfString* String, float Angle)
/// Transform a point from global coordinates into the string's local coordinates
/// (ie it applies the inverse of object's origin, translation, rotation and scale to the point)
////////////////////////////////////////////////////////////
void sfString_TransformToLocal(sfString* String, float PointX, float PointY, float* X, float* Y)
void sfString_TransformToLocal(sfString* string, float pointX, float pointY, float* x, float* y)
{
CSFML_CHECK(String)
CSFML_CHECK(string)
sf::Vector2f Point = String->This.TransformToLocal(sf::Vector2f(PointX, PointY));
if (X) *X = Point.x;
if (Y) *Y = Point.y;
sf::Vector2f point = string->This.TransformToLocal(sf::Vector2f(pointX, pointY));
if (x) *x = point.x;
if (y) *y = point.y;
}
@ -276,115 +276,115 @@ void sfString_TransformToLocal(sfString* String, float PointX, float PointY, flo
/// Transform a point from the string's local coordinates into global coordinates
/// (ie it applies the object's origin, translation, rotation and scale to the point)
////////////////////////////////////////////////////////////
void sfString_TransformToGlobal(sfString* String, float PointX, float PointY, float* X, float* Y)
void sfString_TransformToGlobal(sfString* string, float pointX, float pointY, float* x, float* y)
{
CSFML_CHECK(String)
CSFML_CHECK(string)
sf::Vector2f Point = String->This.TransformToGlobal(sf::Vector2f(PointX, PointY));
if (X) *X = Point.x;
if (Y) *Y = Point.y;
sf::Vector2f point = string->This.TransformToGlobal(sf::Vector2f(pointX, pointY));
if (x) *x = point.x;
if (y) *y = point.y;
}
////////////////////////////////////////////////////////////
/// Set the text of a string (from a multibyte string)
////////////////////////////////////////////////////////////
void sfString_SetText(sfString* String, const char* Text)
void sfString_SetText(sfString* string, const char* text)
{
CSFML_CALL(String, SetText(Text))
CSFML_CALL(string, SetText(text))
}
////////////////////////////////////////////////////////////
/// Set the text of a string (from a unicode string)
////////////////////////////////////////////////////////////
void sfString_SetUnicodeText(sfString* String, const sfUint32* Text)
void sfString_SetUnicodeText(sfString* string, const sfUint32* text)
{
sf::Unicode::UTF32String UTF32Text = Text;
CSFML_CALL(String, SetText(UTF32Text))
sf::Unicode::UTF32String UTF32Text = text;
CSFML_CALL(string, SetText(UTF32Text))
}
////////////////////////////////////////////////////////////
/// Set the font of a string
////////////////////////////////////////////////////////////
void sfString_SetFont(sfString* String, sfFont* Font)
void sfString_SetFont(sfString* string, sfFont* font)
{
CSFML_CHECK(Font);
CSFML_CHECK(font);
CSFML_CALL(String, SetFont(Font->This))
String->Font = Font;
CSFML_CALL(string, SetFont(font->This))
string->Font = font;
}
////////////////////////////////////////////////////////////
/// Set the size of a string
////////////////////////////////////////////////////////////
void sfString_SetSize(sfString* String, float Size)
void sfString_SetSize(sfString* string, float size)
{
CSFML_CALL(String, SetSize(Size))
CSFML_CALL(string, SetSize(size))
}
////////////////////////////////////////////////////////////
/// Set the style of a string
////////////////////////////////////////////////////////////
void sfString_SetStyle(sfString* String, unsigned long Style)
void sfString_SetStyle(sfString* string, unsigned long style)
{
CSFML_CALL(String, SetStyle(Style))
CSFML_CALL(string, SetStyle(style))
}
////////////////////////////////////////////////////////////
/// Get the text of a string (returns a unicode string)
////////////////////////////////////////////////////////////
const sfUint32* sfString_GetUnicodeText(sfString* String)
const sfUint32* sfString_GetUnicodeText(sfString* string)
{
CSFML_CHECK_RETURN(String, NULL)
CSFML_CHECK_RETURN(string, NULL)
return static_cast<const sf::Unicode::UTF32String&>(String->This.GetText()).c_str();
return static_cast<const sf::Unicode::UTF32String&>(string->This.GetText()).c_str();
}
////////////////////////////////////////////////////////////
/// Get the text of a string (returns an ANSI string)
////////////////////////////////////////////////////////////
const char* sfString_GetText(sfString* String)
const char* sfString_GetText(sfString* string)
{
CSFML_CHECK_RETURN(String, NULL)
CSFML_CHECK_RETURN(string, NULL)
String->Text = String->This.GetText();
string->Text = string->This.GetText();
return String->Text.c_str();
return string->Text.c_str();
}
////////////////////////////////////////////////////////////
/// Get the font used by a string
////////////////////////////////////////////////////////////
sfFont* sfString_GetFont(sfString* String)
sfFont* sfString_GetFont(sfString* string)
{
CSFML_CHECK_RETURN(String, NULL)
CSFML_CHECK_RETURN(string, NULL)
return String->Font;
return string->Font;
}
////////////////////////////////////////////////////////////
/// Get the size of the characters of a string
////////////////////////////////////////////////////////////
float sfString_GetSize(sfString* String)
float sfString_GetSize(sfString* string)
{
CSFML_CALL_RETURN(String, GetSize(), 0.f)
CSFML_CALL_RETURN(string, GetSize(), 0.f)
}
////////////////////////////////////////////////////////////
/// Get the style of a string
////////////////////////////////////////////////////////////
unsigned long sfString_GetStyle(sfString* String)
unsigned long sfString_GetStyle(sfString* string)
{
CSFML_CALL_RETURN(String, GetStyle(), 0)
CSFML_CALL_RETURN(string, GetStyle(), 0)
}
@ -393,29 +393,29 @@ unsigned long sfString_GetStyle(sfString* String)
/// in coordinates relative to the string
/// (note : translation, origin, rotation and scale are not applied)
////////////////////////////////////////////////////////////
void sfString_GetCharacterPos(sfString* String, size_t Index, float* X, float* Y)
void sfString_GetCharacterPos(sfString* string, size_t index, float* x, float* y)
{
CSFML_CHECK(String);
CSFML_CHECK(string);
sf::Vector2f Pos = String->This.GetCharacterPos(Index);
if (X) *X = Pos.x;
if (Y) *Y = Pos.y;
sf::Vector2f pos = string->This.GetCharacterPos(index);
if (x) *x = pos.x;
if (y) *y = pos.y;
}
////////////////////////////////////////////////////////////
/// Get the bounding rectangle of a string on screen
////////////////////////////////////////////////////////////
sfFloatRect sfString_GetRect(sfString* String)
sfFloatRect sfString_GetRect(sfString* string)
{
sfFloatRect Rect = {0.f, 0.f, 0.f, 0.f};
CSFML_CHECK_RETURN(String, Rect)
sfFloatRect rect = {0.f, 0.f, 0.f, 0.f};
CSFML_CHECK_RETURN(string, rect)
sf::FloatRect SFMLRect = String->This.GetRect();
String->Rect.Left = SFMLRect.Left;
String->Rect.Top = SFMLRect.Top;
String->Rect.Right = SFMLRect.Right;
String->Rect.Bottom = SFMLRect.Bottom;
sf::FloatRect SFMLRect = string->This.GetRect();
string->Rect.Left = SFMLRect.Left;
string->Rect.Top = SFMLRect.Top;
string->Rect.Right = SFMLRect.Right;
string->Rect.Bottom = SFMLRect.Bottom;
return String->Rect;
return string->Rect;
}

180
CSFML/src/SFML/Network/Ftp.cpp
View File

@ -34,113 +34,113 @@
////////////////////////////////////////////////////////////
/// Destroy an existing Ftp directory response
////////////////////////////////////////////////////////////
void sfFtpListingResponse_Destroy(sfFtpListingResponse* FtpListingResponse)
void sfFtpListingResponse_Destroy(sfFtpListingResponse* ftpListingResponse)
{
delete FtpListingResponse;
delete ftpListingResponse;
}
////////////////////////////////////////////////////////////
/// Convenience function to check if the response status code
/// means a success
////////////////////////////////////////////////////////////
sfBool sfFtpListingResponse_IsOk(sfFtpListingResponse* FtpListingResponse)
sfBool sfFtpListingResponse_IsOk(sfFtpListingResponse* ftpListingResponse)
{
CSFML_CALL_RETURN(FtpListingResponse, IsOk(), sfFalse);
CSFML_CALL_RETURN(ftpListingResponse, IsOk(), sfFalse);
}
////////////////////////////////////////////////////////////
/// Get the response status code
////////////////////////////////////////////////////////////
sfFtpStatus sfFtpListingResponse_GetStatus(sfFtpListingResponse* FtpListingResponse)
sfFtpStatus sfFtpListingResponse_GetStatus(sfFtpListingResponse* ftpListingResponse)
{
CSFML_CHECK_RETURN(FtpListingResponse, sfFtpInvalidResponse);
CSFML_CHECK_RETURN(ftpListingResponse, sfFtpInvalidResponse);
return static_cast<sfFtpStatus>(FtpListingResponse->This.GetStatus());
return static_cast<sfFtpStatus>(ftpListingResponse->This.GetStatus());
}
////////////////////////////////////////////////////////////
/// Get the full message contained in the response
////////////////////////////////////////////////////////////
const char* sfFtpListingResponse_GetMessage(sfFtpListingResponse* FtpListingResponse)
const char* sfFtpListingResponse_GetMessage(sfFtpListingResponse* ftpListingResponse)
{
CSFML_CHECK_RETURN(FtpListingResponse, NULL);
CSFML_CHECK_RETURN(ftpListingResponse, NULL);
return FtpListingResponse->This.GetMessage().c_str();
return ftpListingResponse->This.GetMessage().c_str();
}
////////////////////////////////////////////////////////////
/// Get the number of filenames in the listing
////////////////////////////////////////////////////////////
size_t sfFtpListingResponse_GetCount(sfFtpListingResponse* FtpListingResponse)
size_t sfFtpListingResponse_GetCount(sfFtpListingResponse* ftpListingResponse)
{
CSFML_CALL_RETURN(FtpListingResponse, GetCount(), 0);
CSFML_CALL_RETURN(ftpListingResponse, GetCount(), 0);
}
////////////////////////////////////////////////////////////
/// Get the Index-th filename in the directory
////////////////////////////////////////////////////////////
const char* sfFtpListingResponse_GetFilename(sfFtpListingResponse* FtpListingResponse, size_t Index)
const char* sfFtpListingResponse_GetFilename(sfFtpListingResponse* ftpListingResponse, size_t index)
{
CSFML_CHECK_RETURN(FtpListingResponse, NULL);
CSFML_CHECK_RETURN(ftpListingResponse, NULL);
return FtpListingResponse->This.GetFilename(Index).c_str();
return ftpListingResponse->This.GetFilename(index).c_str();
}
////////////////////////////////////////////////////////////
/// Destroy an existing Ftp directory response
////////////////////////////////////////////////////////////
void sfFtpDirectoryResponse_Destroy(sfFtpDirectoryResponse* FtpDirectoryResponse)
void sfFtpDirectoryResponse_Destroy(sfFtpDirectoryResponse* ftpDirectoryResponse)
{
delete FtpDirectoryResponse;
delete ftpDirectoryResponse;
}
////////////////////////////////////////////////////////////
/// Convenience function to check if the response status code
/// means a success
////////////////////////////////////////////////////////////
sfBool sfFtpDirectoryResponse_IsOk(sfFtpDirectoryResponse* FtpDirectoryResponse)
sfBool sfFtpDirectoryResponse_IsOk(sfFtpDirectoryResponse* ftpDirectoryResponse)
{
CSFML_CALL_RETURN(FtpDirectoryResponse, IsOk(), sfFalse);
CSFML_CALL_RETURN(ftpDirectoryResponse, IsOk(), sfFalse);
}
////////////////////////////////////////////////////////////
/// Get the response status code
////////////////////////////////////////////////////////////
sfFtpStatus sfFtpDirectoryResponse_GetStatus(sfFtpDirectoryResponse* FtpDirectoryResponse)
sfFtpStatus sfFtpDirectoryResponse_GetStatus(sfFtpDirectoryResponse* ftpDirectoryResponse)
{
CSFML_CHECK_RETURN(FtpDirectoryResponse, sfFtpInvalidResponse);
CSFML_CHECK_RETURN(ftpDirectoryResponse, sfFtpInvalidResponse);
return static_cast<sfFtpStatus>(FtpDirectoryResponse->This.GetStatus());
return static_cast<sfFtpStatus>(ftpDirectoryResponse->This.GetStatus());
}
////////////////////////////////////////////////////////////
/// Get the full message contained in the response
////////////////////////////////////////////////////////////
const char* sfFtpDirectoryResponse_GetMessage(sfFtpDirectoryResponse* FtpDirectoryResponse)
const char* sfFtpDirectoryResponse_GetMessage(sfFtpDirectoryResponse* ftpDirectoryResponse)
{
CSFML_CHECK_RETURN(FtpDirectoryResponse, NULL);
CSFML_CHECK_RETURN(ftpDirectoryResponse, NULL);
return FtpDirectoryResponse->This.GetMessage().c_str();
return ftpDirectoryResponse->This.GetMessage().c_str();
}
////////////////////////////////////////////////////////////
/// Get the directory returned in the response
////////////////////////////////////////////////////////////
const char* sfFtpDirectoryResponse_GetDirectory(sfFtpDirectoryResponse* FtpDirectoryResponse)
const char* sfFtpDirectoryResponse_GetDirectory(sfFtpDirectoryResponse* ftpDirectoryResponse)
{
CSFML_CHECK_RETURN(FtpDirectoryResponse, NULL);
CSFML_CHECK_RETURN(ftpDirectoryResponse, NULL);
return FtpDirectoryResponse->This.GetDirectory().c_str();
return ftpDirectoryResponse->This.GetDirectory().c_str();
}
////////////////////////////////////////////////////////////
/// Destroy an existing Ftp response
////////////////////////////////////////////////////////////
void sfFtpResponse_Destroy(sfFtpResponse* FtpResponse)
void sfFtpResponse_Destroy(sfFtpResponse* ftpResponse)
{
delete FtpResponse;
delete ftpResponse;
}
@ -148,31 +148,31 @@ void sfFtpResponse_Destroy(sfFtpResponse* FtpResponse)
/// Convenience function to check if the response status code
/// means a success
////////////////////////////////////////////////////////////
sfBool sfFtpResponse_IsOk(sfFtpResponse* FtpResponse)
sfBool sfFtpResponse_IsOk(sfFtpResponse* ftpResponse)
{
CSFML_CALL_RETURN(FtpResponse, IsOk(), sfFalse);
CSFML_CALL_RETURN(ftpResponse, IsOk(), sfFalse);
}
////////////////////////////////////////////////////////////
/// Get the response status code
////////////////////////////////////////////////////////////
sfFtpStatus sfFtpResponse_GetStatus(sfFtpResponse* FtpResponse)
sfFtpStatus sfFtpResponse_GetStatus(sfFtpResponse* ftpResponse)
{
CSFML_CHECK_RETURN(FtpResponse, sfFtpInvalidResponse);
CSFML_CHECK_RETURN(ftpResponse, sfFtpInvalidResponse);
return static_cast<sfFtpStatus>(FtpResponse->This.GetStatus());
return static_cast<sfFtpStatus>(ftpResponse->This.GetStatus());
}
////////////////////////////////////////////////////////////
/// Get the full message contained in the response
////////////////////////////////////////////////////////////
const char* sfFtpResponse_GetMessage(sfFtpResponse* FtpResponse)
const char* sfFtpResponse_GetMessage(sfFtpResponse* ftpResponse)
{
CSFML_CHECK_RETURN(FtpResponse, NULL);
CSFML_CHECK_RETURN(ftpResponse, NULL);
return FtpResponse->This.GetMessage().c_str();
return ftpResponse->This.GetMessage().c_str();
}
@ -188,77 +188,77 @@ sfFtp* sfFtp_Create()
////////////////////////////////////////////////////////////
/// Destroy an existing Ftp
////////////////////////////////////////////////////////////
void sfFtp_Destroy(sfFtp* Ftp)
void sfFtp_Destroy(sfFtp* ftp)
{
delete Ftp;
delete ftp;
}
////////////////////////////////////////////////////////////
/// Connect to the specified FTP server
////////////////////////////////////////////////////////////
sfFtpResponse* sfFtp_Connect(sfFtp* Ftp, sfIPAddress Server, unsigned short Port, float Timeout)
sfFtpResponse* sfFtp_Connect(sfFtp* ftp, sfIPAddress server, unsigned short port, float timeout)
{
CSFML_CHECK_RETURN(Ftp, NULL);
CSFML_CHECK_RETURN(ftp, NULL);
sf::IPAddress SFMLServer(Server.Address);
sf::IPAddress SFMLServer(server.Address);
return new sfFtpResponse(Ftp->This.Connect(SFMLServer, Port, Timeout));
return new sfFtpResponse(ftp->This.Connect(SFMLServer, port, timeout));
}
////////////////////////////////////////////////////////////
/// Log in using anonymous account
////////////////////////////////////////////////////////////
sfFtpResponse* sfFtp_LoginAnonymous(sfFtp* Ftp)
sfFtpResponse* sfFtp_LoginAnonymous(sfFtp* ftp)
{
CSFML_CHECK_RETURN(Ftp, NULL);
CSFML_CHECK_RETURN(ftp, NULL);
return new sfFtpResponse(Ftp->This.Login());
return new sfFtpResponse(ftp->This.Login());
}
////////////////////////////////////////////////////////////
/// Log in using a username and a password
////////////////////////////////////////////////////////////
sfFtpResponse* sfFtp_Login(sfFtp* Ftp, const char* UserName, const char* Password)
sfFtpResponse* sfFtp_Login(sfFtp* ftp, const char* userName, const char* password)
{
CSFML_CHECK_RETURN(Ftp, NULL);
CSFML_CHECK_RETURN(ftp, NULL);
return new sfFtpResponse(Ftp->This.Login(UserName ? UserName : "", Password ? Password : ""));
return new sfFtpResponse(ftp->This.Login(userName ? userName : "", password ? password : ""));
}
////////////////////////////////////////////////////////////
/// Close the connection with FTP server
////////////////////////////////////////////////////////////
sfFtpResponse* sfFtp_Disconnect(sfFtp* Ftp)
sfFtpResponse* sfFtp_Disconnect(sfFtp* ftp)
{
CSFML_CHECK_RETURN(Ftp, NULL);
CSFML_CHECK_RETURN(ftp, NULL);
return new sfFtpResponse(Ftp->This.Disconnect());
return new sfFtpResponse(ftp->This.Disconnect());
}
////////////////////////////////////////////////////////////
/// Send a null command just to prevent from being disconnected
////////////////////////////////////////////////////////////
sfFtpResponse* sfFtp_KeepAlive(sfFtp* Ftp)
sfFtpResponse* sfFtp_KeepAlive(sfFtp* ftp)
{
CSFML_CHECK_RETURN(Ftp, NULL);
CSFML_CHECK_RETURN(ftp, NULL);
return new sfFtpResponse(Ftp->This.KeepAlive());
return new sfFtpResponse(ftp->This.KeepAlive());
}
////////////////////////////////////////////////////////////
/// Get the current working directory
////////////////////////////////////////////////////////////
sfFtpDirectoryResponse* sfFtp_GetWorkingDirectory(sfFtp* Ftp)
sfFtpDirectoryResponse* sfFtp_GetWorkingDirectory(sfFtp* ftp)
{
CSFML_CHECK_RETURN(Ftp, NULL);
CSFML_CHECK_RETURN(ftp, NULL);
return new sfFtpDirectoryResponse(Ftp->This.GetWorkingDirectory());
return new sfFtpDirectoryResponse(ftp->This.GetWorkingDirectory());
}
@ -266,101 +266,101 @@ sfFtpDirectoryResponse* sfFtp_GetWorkingDirectory(sfFtp* Ftp)
/// Get the contents of the given directory
/// (subdirectories and files)
////////////////////////////////////////////////////////////
sfFtpListingResponse* sfFtp_GetDirectoryListing(sfFtp* Ftp, const char* Directory)
sfFtpListingResponse* sfFtp_GetDirectoryListing(sfFtp* ftp, const char* directory)
{
CSFML_CHECK_RETURN(Ftp, NULL);
CSFML_CHECK_RETURN(ftp, NULL);
return new sfFtpListingResponse(Ftp->This.GetDirectoryListing(Directory ? Directory : ""));
return new sfFtpListingResponse(ftp->This.GetDirectoryListing(directory ? directory : ""));
}
////////////////////////////////////////////////////////////
/// Change the current working directory
////////////////////////////////////////////////////////////
sfFtpResponse* sfFtp_ChangeDirectory(sfFtp* Ftp, const char* Directory)
sfFtpResponse* sfFtp_ChangeDirectory(sfFtp* ftp, const char* directory)
{
CSFML_CHECK_RETURN(Ftp, NULL);
CSFML_CHECK_RETURN(ftp, NULL);
return new sfFtpResponse(Ftp->This.ChangeDirectory(Directory ? Directory : ""));
return new sfFtpResponse(ftp->This.ChangeDirectory(directory ? directory : ""));
}
////////////////////////////////////////////////////////////
/// Go to the parent directory of the current one
////////////////////////////////////////////////////////////
sfFtpResponse* sfFtp_ParentDirectory(sfFtp* Ftp)
sfFtpResponse* sfFtp_ParentDirectory(sfFtp* ftp)
{
CSFML_CHECK_RETURN(Ftp, NULL);
CSFML_CHECK_RETURN(ftp, NULL);
return new sfFtpResponse(Ftp->This.ParentDirectory());
return new sfFtpResponse(ftp->This.ParentDirectory());
}
////////////////////////////////////////////////////////////
/// Create a new directory
////////////////////////////////////////////////////////////
sfFtpResponse* sfFtp_MakeDirectory(sfFtp* Ftp, const char* Name)
sfFtpResponse* sfFtp_MakeDirectory(sfFtp* ftp, const char* name)
{
CSFML_CHECK_RETURN(Ftp, NULL);
CSFML_CHECK_RETURN(ftp, NULL);
return new sfFtpResponse(Ftp->This.MakeDirectory(Name ? Name : ""));
return new sfFtpResponse(ftp->This.MakeDirectory(name ? name : ""));
}
////////////////////////////////////////////////////////////
/// Remove an existing directory
////////////////////////////////////////////////////////////
sfFtpResponse* sfFtp_DeleteDirectory(sfFtp* Ftp, const char* Name)
sfFtpResponse* sfFtp_DeleteDirectory(sfFtp* ftp, const char* name)
{
CSFML_CHECK_RETURN(Ftp, NULL);
CSFML_CHECK_RETURN(ftp, NULL);
return new sfFtpResponse(Ftp->This.DeleteDirectory(Name ? Name : ""));
return new sfFtpResponse(ftp->This.DeleteDirectory(name ? name : ""));
}
////////////////////////////////////////////////////////////
/// Rename a file
////////////////////////////////////////////////////////////
sfFtpResponse* sfFtp_RenameFile(sfFtp* Ftp, const char* File, const char* NewName)
sfFtpResponse* sfFtp_RenameFile(sfFtp* ftp, const char* file, const char* newName)
{
CSFML_CHECK_RETURN(Ftp, NULL);
CSFML_CHECK_RETURN(ftp, NULL);
return new sfFtpResponse(Ftp->This.RenameFile(File ? File : "", NewName ? NewName : ""));
return new sfFtpResponse(ftp->This.RenameFile(file ? file : "", newName ? newName : ""));
}
////////////////////////////////////////////////////////////
/// Remove an existing file
////////////////////////////////////////////////////////////
sfFtpResponse* sfFtp_DeleteFile(sfFtp* Ftp, const char* Name)
sfFtpResponse* sfFtp_DeleteFile(sfFtp* ftp, const char* name)
{
CSFML_CHECK_RETURN(Ftp, NULL);
CSFML_CHECK_RETURN(ftp, NULL);
return new sfFtpResponse(Ftp->This.DeleteFile(Name ? Name : ""));
return new sfFtpResponse(ftp->This.DeleteFile(name ? name : ""));
}
////////////////////////////////////////////////////////////
/// Download a file from the server
////////////////////////////////////////////////////////////
sfFtpResponse* sfFtp_Download(sfFtp* Ftp, const char* DistantFile, const char* DestPath, sfFtpTransferMode Mode)
sfFtpResponse* sfFtp_Download(sfFtp* ftp, const char* distantFile, const char* destPath, sfFtpTransferMode mode)
{
CSFML_CHECK_RETURN(Ftp, NULL);
CSFML_CHECK_RETURN(ftp, NULL);
return new sfFtpResponse(Ftp->This.Download(DistantFile ? DistantFile : "",
DestPath ? DestPath : "",
static_cast<sf::Ftp::TransferMode>(Mode)));
return new sfFtpResponse(ftp->This.Download(distantFile ? distantFile : "",
destPath ? destPath : "",
static_cast<sf::Ftp::TransferMode>(mode)));
}
////////////////////////////////////////////////////////////
/// Upload a file to the server
////////////////////////////////////////////////////////////
sfFtpResponse* sfFtp_Upload(sfFtp* Ftp, const char* LocalFile, const char* DestPath, sfFtpTransferMode Mode)
sfFtpResponse* sfFtp_Upload(sfFtp* ftp, const char* localFile, const char* destPath, sfFtpTransferMode mode)
{
CSFML_CHECK_RETURN(Ftp, NULL);
CSFML_CHECK_RETURN(ftp, NULL);
return new sfFtpResponse(Ftp->This.Upload(LocalFile ? LocalFile : "",
DestPath ? DestPath : "",
static_cast<sf::Ftp::TransferMode>(Mode)));
return new sfFtpResponse(ftp->This.Upload(localFile ? localFile : "",
destPath ? destPath : "",
static_cast<sf::Ftp::TransferMode>(mode)));
}

80
CSFML/src/SFML/Network/Http.cpp
View File

@ -42,20 +42,20 @@ sfHttpRequest* sfHttpRequest_Create()
////////////////////////////////////////////////////////////
/// Destroy an existing Http request
////////////////////////////////////////////////////////////
void sfHttpRequest_Destroy(sfHttpRequest* HttpRequest)
void sfHttpRequest_Destroy(sfHttpRequest* httpRequest)
{
delete HttpRequest;
delete httpRequest;
}
////////////////////////////////////////////////////////////
/// Set the value of a field; the field is added if it doesn't exist
////////////////////////////////////////////////////////////
void sfHttpRequest_SetField(sfHttpRequest* HttpRequest, const char* Field, const char* Value)
void sfHttpRequest_SetField(sfHttpRequest* httpRequest, const char* field, const char* value)
{
CSFML_CHECK(HttpRequest);
if (Field)
HttpRequest->This.SetField(Field, Value);
CSFML_CHECK(httpRequest);
if (field)
httpRequest->This.SetField(field, value);
}
@ -63,9 +63,9 @@ void sfHttpRequest_SetField(sfHttpRequest* HttpRequest, const char* Field, const
/// Set the request method.
/// This parameter is sfHttpGet by default
////////////////////////////////////////////////////////////
void sfHttpRequest_SetMethod(sfHttpRequest* HttpRequest, sfHttpMethod Method)
void sfHttpRequest_SetMethod(sfHttpRequest* httpRequest, sfHttpMethod method)
{
CSFML_CALL(HttpRequest, SetMethod(static_cast<sf::Http::Request::Method>(Method)));
CSFML_CALL(httpRequest, SetMethod(static_cast<sf::Http::Request::Method>(method)));
}
@ -73,9 +73,9 @@ void sfHttpRequest_SetMethod(sfHttpRequest* HttpRequest, sfHttpMethod Method)
/// Set the target URI of the request.
/// This parameter is "/" by default
////////////////////////////////////////////////////////////
void sfHttpRequest_SetURI(sfHttpRequest* HttpRequest, const char* URI)
void sfHttpRequest_SetURI(sfHttpRequest* httpRequest, const char* URI)
{
CSFML_CALL(HttpRequest, SetURI(URI ? URI : ""));
CSFML_CALL(httpRequest, SetURI(URI ? URI : ""));
}
@ -83,9 +83,9 @@ void sfHttpRequest_SetURI(sfHttpRequest* HttpRequest, const char* URI)
/// Set the HTTP version of the request.
/// This parameter is 1.0 by default
////////////////////////////////////////////////////////////
void sfHttpRequest_SetHttpVersion(sfHttpRequest* HttpRequest, unsigned int Major, unsigned int Minor)
void sfHttpRequest_SetHttpVersion(sfHttpRequest* httpRequest, unsigned int major, unsigned int minor)
{
CSFML_CALL(HttpRequest, SetHttpVersion(Major, Minor));
CSFML_CALL(httpRequest, SetHttpVersion(major, minor));
}
@ -94,60 +94,60 @@ void sfHttpRequest_SetHttpVersion(sfHttpRequest* HttpRequest, unsigned int Major
/// makes sense only for POST requests.
/// This parameter is empty by default
////////////////////////////////////////////////////////////
void sfHttpRequest_SetBody(sfHttpRequest* HttpRequest, const char* Body)
void sfHttpRequest_SetBody(sfHttpRequest* httpRequest, const char* body)
{
CSFML_CALL(HttpRequest, SetBody(Body ? Body : ""));
CSFML_CALL(httpRequest, SetBody(body ? body : ""));
}
////////////////////////////////////////////////////////////
/// Destroy an existing Http response
////////////////////////////////////////////////////////////
void sfHttpResponse_Destroy(sfHttpResponse* HttpResponse)
void sfHttpResponse_Destroy(sfHttpResponse* httpResponse)
{
delete HttpResponse;
delete httpResponse;
}
////////////////////////////////////////////////////////////
/// Get the value of a field; returns NULL if the field doesn't exist
////////////////////////////////////////////////////////////
const char* sfHttpResponse_GetField(sfHttpResponse* HttpResponse, const char* Field)
const char* sfHttpResponse_GetField(sfHttpResponse* httpResponse, const char* field)
{
CSFML_CHECK_RETURN(HttpResponse, NULL);
if (!Field)
CSFML_CHECK_RETURN(httpResponse, NULL);
if (!field)
return NULL;
return HttpResponse->This.GetField(Field).c_str();
return httpResponse->This.GetField(field).c_str();
}
////////////////////////////////////////////////////////////
/// Get the status of a response
////////////////////////////////////////////////////////////
sfHttpStatus sfHttpResponse_GetStatus(sfHttpResponse* HttpResponse)
sfHttpStatus sfHttpResponse_GetStatus(sfHttpResponse* httpResponse)
{
CSFML_CHECK_RETURN(HttpResponse, sfHttpInvalidResponse);
CSFML_CHECK_RETURN(httpResponse, sfHttpInvalidResponse);
return static_cast<sfHttpStatus>(HttpResponse->This.GetStatus());
return static_cast<sfHttpStatus>(httpResponse->This.GetStatus());
}
////////////////////////////////////////////////////////////
/// Get the major HTTP version of a response
////////////////////////////////////////////////////////////
unsigned int sfHttpResponse_GetMajorVersion(sfHttpResponse* HttpResponse)
unsigned int sfHttpResponse_GetMajorVersion(sfHttpResponse* httpResponse)
{
CSFML_CALL_RETURN(HttpResponse, GetMajorHttpVersion(), 0);
CSFML_CALL_RETURN(httpResponse, GetMajorHttpVersion(), 0);
}
////////////////////////////////////////////////////////////
/// Get the minor HTTP version of a response
////////////////////////////////////////////////////////////
unsigned int sfHttpResponse_GetMinorVersion(sfHttpResponse* HttpResponse)
unsigned int sfHttpResponse_GetMinorVersion(sfHttpResponse* httpResponse)
{
CSFML_CALL_RETURN(HttpResponse, GetMinorHttpVersion(), 0);
CSFML_CALL_RETURN(httpResponse, GetMinorHttpVersion(), 0);
}
@ -158,11 +158,11 @@ unsigned int sfHttpResponse_GetMinorVersion(sfHttpResponse* HttpResponse)
/// - nothing (for HEAD requests)
/// - an error message (in case of an error)
////////////////////////////////////////////////////////////
const char* sfHttpResponse_GetBody(sfHttpResponse* HttpResponse)
const char* sfHttpResponse_GetBody(sfHttpResponse* httpResponse)
{
CSFML_CHECK_RETURN(HttpResponse, NULL);
CSFML_CHECK_RETURN(httpResponse, NULL);
return HttpResponse->This.GetBody().c_str();
return httpResponse->This.GetBody().c_str();
}
@ -178,18 +178,18 @@ sfHttp* sfHttp_Create()
////////////////////////////////////////////////////////////
/// Destroy an existing Http object
////////////////////////////////////////////////////////////
void sfHttp_Destroy(sfHttp* Http)
void sfHttp_Destroy(sfHttp* http)
{
delete Http;
delete http;
}
////////////////////////////////////////////////////////////
/// Set the target host of a Http server
////////////////////////////////////////////////////////////
void sfHttp_SetHost(sfHttp* Http, const char* Host, unsigned short Port)
void sfHttp_SetHost(sfHttp* http, const char* host, unsigned short port)
{
CSFML_CALL(Http, SetHost(Host ? Host : "", Port));
CSFML_CALL(http, SetHost(host ? host : "", port));
}
@ -201,13 +201,13 @@ void sfHttp_SetHost(sfHttp* Http, const char* Host, unsigned short Port)
/// not return instantly; use a thread if you don't want to block your
/// application.
////////////////////////////////////////////////////////////
sfHttpResponse* sfHttp_SendRequest(sfHttp* Http, sfHttpRequest* Request, float Timeout)
sfHttpResponse* sfHttp_SendRequest(sfHttp* http, sfHttpRequest* request, float timeout)
{
CSFML_CHECK_RETURN(Http, NULL);
CSFML_CHECK_RETURN(Request, NULL);
CSFML_CHECK_RETURN(http, NULL);
CSFML_CHECK_RETURN(request, NULL);
sfHttpResponse* Response = new sfHttpResponse;
Response->This = Http->This.SendRequest(Request->This, Timeout);
sfHttpResponse* response = new sfHttpResponse;
response->This = http->This.SendRequest(request->This, timeout);
return Response;
return response;
}

42
CSFML/src/SFML/Network/IPAddress.cpp
View File

@ -35,20 +35,20 @@ namespace
////////////////////////////////////////////////////////////
/// Helper function for converting a SFML address to a CSFML one
////////////////////////////////////////////////////////////
sfIPAddress FromSFMLAddress(sf::IPAddress Address)
sfIPAddress FromSFMLAddress(sf::IPAddress address)
{
sfIPAddress Result;
strncpy(Result.Address, Address.ToString().c_str(), 16);
sfIPAddress result;
strncpy(result.Address, address.ToString().c_str(), 16);
return Result;
return result;
}
////////////////////////////////////////////////////////////
/// Helper function for converting a CSFML address to a SFML one
////////////////////////////////////////////////////////////
sf::IPAddress ToSFMLAddress(sfIPAddress Address)
sf::IPAddress ToSFMLAddress(sfIPAddress address)
{
return sf::IPAddress(Address.Address);
return sf::IPAddress(address.Address);
}
}
@ -56,55 +56,55 @@ namespace
////////////////////////////////////////////////////////////
/// Construct an address from a string
////////////////////////////////////////////////////////////
sfIPAddress sfIPAddress_FromString(const char* String)
sfIPAddress sfIPAddress_FromString(const char* string)
{
return FromSFMLAddress(sf::IPAddress(String));
return FromSFMLAddress(sf::IPAddress(string));
}
////////////////////////////////////////////////////////////
/// Construct an address from 4 bytes
////////////////////////////////////////////////////////////
sfIPAddress sfIPAddress_FromBytes(sfUint8 Byte0, sfUint8 Byte1, sfUint8 Byte2, sfUint8 Byte3)
sfIPAddress sfIPAddress_FromBytes(sfUint8 byte0, sfUint8 byte1, sfUint8 byte2, sfUint8 byte3)
{
return FromSFMLAddress(sf::IPAddress(Byte0, Byte1, Byte2, Byte3));
return FromSFMLAddress(sf::IPAddress(byte0, byte1, byte2, byte3));
}
////////////////////////////////////////////////////////////
/// Construct the address from a 32-bits integer
////////////////////////////////////////////////////////////
sfIPAddress sfIPAddress_FromInteger(sfUint32 Address)
sfIPAddress sfIPAddress_FromInteger(sfUint32 address)
{
return FromSFMLAddress(sf::IPAddress(Address));
return FromSFMLAddress(sf::IPAddress(address));
}
////////////////////////////////////////////////////////////
/// Tell if an address is a valid one
////////////////////////////////////////////////////////////
sfBool sfIPAddress_IsValid(sfIPAddress Address)
sfBool sfIPAddress_IsValid(sfIPAddress address)
{
return ToSFMLAddress(Address).IsValid() ? sfTrue : sfFalse;
return ToSFMLAddress(address).IsValid() ? sfTrue : sfFalse;
}
////////////////////////////////////////////////////////////
/// Get a string representation of an address
////////////////////////////////////////////////////////////
void sfIPAddress_ToString(sfIPAddress Address, char* String)
void sfIPAddress_ToString(sfIPAddress address, char* string)
{
if (String)
strcpy(String, Address.Address);
if (string)
strcpy(string, address.Address);
}
////////////////////////////////////////////////////////////
/// Get an integer representation of the address
////////////////////////////////////////////////////////////
sfUint32 sfIPAddress_ToInteger(sfIPAddress Address)
sfUint32 sfIPAddress_ToInteger(sfIPAddress address)
{
return ToSFMLAddress(Address).ToInteger();
return ToSFMLAddress(address).ToInteger();
}
@ -123,9 +123,9 @@ sfIPAddress sfIPAddress_GetLocalAddress()
/// distant website ; as a consequence, this function may be
/// very slow -- use it as few as possible !
////////////////////////////////////////////////////////////
sfIPAddress sfIPAddress_GetPublicAddress(float Timeout)
sfIPAddress sfIPAddress_GetPublicAddress(float timeout)
{
return FromSFMLAddress(sf::IPAddress::GetPublicAddress(Timeout));
return FromSFMLAddress(sf::IPAddress::GetPublicAddress(timeout));
}

112
CSFML/src/SFML/Network/Packet.cpp
View File

@ -36,24 +36,24 @@ namespace
/// Helper function to read a variable from a packet
////////////////////////////////////////////////////////////
template <typename T>
T PacketRead(sfPacket* Packet, T Default = 0)
T PacketRead(sfPacket* packet, T def = 0)
{
CSFML_CHECK_RETURN(Packet, Default);
CSFML_CHECK_RETURN(packet, def);
T Value;
Packet->This >> Value;
return Value;
T value;
packet->This >> value;
return value;
}
////////////////////////////////////////////////////////////
/// Helper function to write a variable to a packet
////////////////////////////////////////////////////////////
template <typename T>
void PacketWrite(sfPacket* Packet, T Value)
void PacketWrite(sfPacket* packet, T value)
{
CSFML_CHECK(Packet);
CSFML_CHECK(packet);
Packet->This << Value;
packet->This << value;
}
}
@ -70,27 +70,27 @@ sfPacket* sfPacket_Create()
////////////////////////////////////////////////////////////
/// Destroy an existing packet
////////////////////////////////////////////////////////////
void sfPacket_Destroy(sfPacket* Packet)
void sfPacket_Destroy(sfPacket* packet)
{
delete Packet;
delete packet;
}
////////////////////////////////////////////////////////////
/// Append data to the end of a packet
////////////////////////////////////////////////////////////
void sfPacket_Append(sfPacket* Packet, void* Data, size_t SizeInBytes)
void sfPacket_Append(sfPacket* packet, void* data, size_t sizeInBytes)
{
CSFML_CALL(Packet, Append(Data, SizeInBytes));
CSFML_CALL(packet, Append(data, sizeInBytes));
}
////////////////////////////////////////////////////////////
/// Clear all the data of a packet
///////////////////////////////////////////////////////////
void sfPacket_Clear(sfPacket* Packet)
void sfPacket_Clear(sfPacket* packet)
{
CSFML_CALL(Packet, Clear());
CSFML_CALL(packet, Clear());
}
@ -99,36 +99,36 @@ void sfPacket_Clear(sfPacket* Packet)
/// Warning : the returned pointer may be invalid after you
/// append data to the packet
////////////////////////////////////////////////////////////
const char* sfPacket_GetData(sfPacket* Packet)
const char* sfPacket_GetData(sfPacket* packet)
{
CSFML_CALL_RETURN(Packet, GetData(), NULL);
CSFML_CALL_RETURN(packet, GetData(), NULL);
}
////////////////////////////////////////////////////////////
/// Get the size of the data contained in a packet
////////////////////////////////////////////////////////////
size_t sfPacket_GetDataSize(sfPacket* Packet)
size_t sfPacket_GetDataSize(sfPacket* packet)
{
CSFML_CALL_RETURN(Packet, GetDataSize(), 0);
CSFML_CALL_RETURN(packet, GetDataSize(), 0);
}
////////////////////////////////////////////////////////////
/// Tell if the reading position has reached the end of the packet
////////////////////////////////////////////////////////////
sfBool sfPacket_EndOfPacket(sfPacket* Packet)
sfBool sfPacket_EndOfPacket(sfPacket* packet)
{
CSFML_CALL_RETURN(Packet, EndOfPacket(), sfFalse);
CSFML_CALL_RETURN(packet, EndOfPacket(), sfFalse);
}
////////////////////////////////////////////////////////////
/// Check if a packet is in a valid reading state
////////////////////////////////////////////////////////////
sfBool sfPacket_CanRead(sfPacket* Packet)
sfBool sfPacket_CanRead(sfPacket* packet)
{
CSFML_CALL_RETURN(Packet, operator bool(), sfFalse);
CSFML_CALL_RETURN(packet, operator bool(), sfFalse);
}
@ -138,30 +138,30 @@ sfBool sfPacket_CanRead(sfPacket* Packet)
/// \param Packet : Packet to read
///
////////////////////////////////////////////////////////////
sfBool sfPacket_ReadBool(sfPacket* Packet) {return PacketRead<sfUint8>(Packet);}
sfInt8 sfPacket_ReadInt8(sfPacket* Packet) {return PacketRead<sfInt8>(Packet);}
sfUint8 sfPacket_ReadUint8(sfPacket* Packet) {return PacketRead<sfUint8>(Packet);}
sfInt16 sfPacket_ReadInt16(sfPacket* Packet) {return PacketRead<sfInt16>(Packet);}
sfUint16 sfPacket_ReadUint16(sfPacket* Packet) {return PacketRead<sfUint16>(Packet);}
sfInt32 sfPacket_ReadInt32(sfPacket* Packet) {return PacketRead<sfInt32>(Packet);}
sfUint32 sfPacket_ReadUint32(sfPacket* Packet) {return PacketRead<sfUint32>(Packet);}
float sfPacket_ReadFloat(sfPacket* Packet) {return PacketRead<float>(Packet);}
double sfPacket_ReadDouble(sfPacket* Packet) {return PacketRead<double>(Packet);}
sfBool sfPacket_ReadBool(sfPacket* packet) {return PacketRead<sfUint8>(packet);}
sfInt8 sfPacket_ReadInt8(sfPacket* packet) {return PacketRead<sfInt8>(packet);}
sfUint8 sfPacket_ReadUint8(sfPacket* packet) {return PacketRead<sfUint8>(packet);}
sfInt16 sfPacket_ReadInt16(sfPacket* packet) {return PacketRead<sfInt16>(packet);}
sfUint16 sfPacket_ReadUint16(sfPacket* packet) {return PacketRead<sfUint16>(packet);}
sfInt32 sfPacket_ReadInt32(sfPacket* packet) {return PacketRead<sfInt32>(packet);}
sfUint32 sfPacket_ReadUint32(sfPacket* packet) {return PacketRead<sfUint32>(packet);}
float sfPacket_ReadFloat(sfPacket* packet) {return PacketRead<float>(packet);}
double sfPacket_ReadDouble(sfPacket* packet) {return PacketRead<double>(packet);}
void sfPacket_ReadString(sfPacket* Packet, char* String)
void sfPacket_ReadString(sfPacket* packet, char* string)
{
CSFML_CHECK(Packet);
CSFML_CHECK(packet);
if (String)
Packet->This >> String;
if (string)
packet->This >> string;
}
void sfPacket_ReadWideString(sfPacket* Packet, wchar_t* String)
void sfPacket_ReadWideString(sfPacket* packet, wchar_t* string)
{
CSFML_CHECK(Packet);
CSFML_CHECK(packet);
if (String)
Packet->This >> String;
if (string)
packet->This >> string;
}
@ -171,28 +171,28 @@ void sfPacket_ReadWideString(sfPacket* Packet, wchar_t* String)
/// \param Packet : Packet to write
///
////////////////////////////////////////////////////////////
void sfPacket_WriteBool(sfPacket* Packet, sfBool Value) {PacketWrite(Packet, static_cast<sfUint8>(Value));}
void sfPacket_WriteInt8(sfPacket* Packet, sfInt8 Value) {PacketWrite(Packet, Value);}
void sfPacket_WriteUint8(sfPacket* Packet, sfUint8 Value) {PacketWrite(Packet, Value);}
void sfPacket_WriteInt16(sfPacket* Packet, sfInt16 Value) {PacketWrite(Packet, Value);}
void sfPacket_WriteUint16(sfPacket* Packet, sfUint16 Value) {PacketWrite(Packet, Value);}
void sfPacket_WriteInt32(sfPacket* Packet, sfInt32 Value) {PacketWrite(Packet, Value);}
void sfPacket_WriteUint32(sfPacket* Packet, sfUint32 Value) {PacketWrite(Packet, Value);}
void sfPacket_WriteFloat(sfPacket* Packet, float Value) {PacketWrite(Packet, Value);}
void sfPacket_WriteDouble(sfPacket* Packet, double Value) {PacketWrite(Packet, Value);}
void sfPacket_WriteBool(sfPacket* packet, sfBool value) {PacketWrite(packet, static_cast<sfUint8>(value));}
void sfPacket_WriteInt8(sfPacket* packet, sfInt8 value) {PacketWrite(packet, value);}
void sfPacket_WriteUint8(sfPacket* packet, sfUint8 value) {PacketWrite(packet, value);}
void sfPacket_WriteInt16(sfPacket* packet, sfInt16 value) {PacketWrite(packet, value);}
void sfPacket_WriteUint16(sfPacket* packet, sfUint16 value) {PacketWrite(packet, value);}
void sfPacket_WriteInt32(sfPacket* packet, sfInt32 value) {PacketWrite(packet, value);}
void sfPacket_WriteUint32(sfPacket* packet, sfUint32 value) {PacketWrite(packet, value);}
void sfPacket_WriteFloat(sfPacket* packet, float value) {PacketWrite(packet, value);}
void sfPacket_WriteDouble(sfPacket* packet, double value) {PacketWrite(packet, value);}
void sfPacket_WriteString(sfPacket* Packet, const char* String)
void sfPacket_WriteString(sfPacket* packet, const char* string)
{
CSFML_CHECK(Packet);
CSFML_CHECK(packet);
if (String)
Packet->This << String;
if (string)
packet->This << string;
}
void sfPacket_WriteWideString(sfPacket* Packet, const wchar_t* String)
void sfPacket_WriteWideString(sfPacket* packet, const wchar_t* string)
{
CSFML_CHECK(Packet);
CSFML_CHECK(packet);
if (String)
Packet->This << String;
if (string)
packet->This << string;
}

32
CSFML/src/SFML/Network/Selector.cpp
View File

@ -40,37 +40,37 @@ sfSelectorUDP* sfSelectorUDP_Create() {return new sfSelectorUDP;}
////////////////////////////////////////////////////////////
/// Destroy an existing selector
////////////////////////////////////////////////////////////
void sfSelectorTCP_Destroy(sfSelectorTCP* Selector) {delete Selector;}
void sfSelectorUDP_Destroy(sfSelectorUDP* Selector) {delete Selector;}
void sfSelectorTCP_Destroy(sfSelectorTCP* selector) {delete selector;}
void sfSelectorUDP_Destroy(sfSelectorUDP* selector) {delete selector;}
////////////////////////////////////////////////////////////
/// Add a socket to watch to a selector
////////////////////////////////////////////////////////////
void sfSelectorTCP_Add(sfSelectorTCP* Selector, sfSocketTCP* Socket) {CSFML_CALL(Selector, Add(Socket->This)); Selector->Sockets[Socket->This] = Socket;}
void sfSelectorUDP_Add(sfSelectorUDP* Selector, sfSocketUDP* Socket) {CSFML_CALL(Selector, Add(Socket->This)); Selector->Sockets[Socket->This] = Socket;}
void sfSelectorTCP_Add(sfSelectorTCP* selector, sfSocketTCP* socket) {CSFML_CALL(selector, Add(socket->This)); selector->Sockets[socket->This] = socket;}
void sfSelectorUDP_Add(sfSelectorUDP* selector, sfSocketUDP* socket) {CSFML_CALL(selector, Add(socket->This)); selector->Sockets[socket->This] = socket;}
////////////////////////////////////////////////////////////
/// Remove a socket from a selector
////////////////////////////////////////////////////////////
void sfSelectorTCP_Remove(sfSelectorTCP* Selector, sfSocketTCP* Socket) {CSFML_CALL(Selector, Remove(Socket->This)); Selector->Sockets.erase(Socket->This);}
void sfSelectorUDP_Remove(sfSelectorUDP* Selector, sfSocketUDP* Socket) {CSFML_CALL(Selector, Remove(Socket->This)); Selector->Sockets.erase(Socket->This);}
void sfSelectorTCP_Remove(sfSelectorTCP* selector, sfSocketTCP* socket) {CSFML_CALL(selector, Remove(socket->This)); selector->Sockets.erase(socket->This);}
void sfSelectorUDP_Remove(sfSelectorUDP* selector, sfSocketUDP* socket) {CSFML_CALL(selector, Remove(socket->This)); selector->Sockets.erase(socket->This);}
////////////////////////////////////////////////////////////
/// Remove all sockets from a selector
////////////////////////////////////////////////////////////
void sfSelectorTCP_Clear(sfSelectorTCP* Selector) {CSFML_CALL(Selector, Clear()); Selector->Sockets.clear();}
void sfSelectorUDP_Clear(sfSelectorUDP* Selector) {CSFML_CALL(Selector, Clear()); Selector->Sockets.clear();}
void sfSelectorTCP_Clear(sfSelectorTCP* selector) {CSFML_CALL(selector, Clear()); selector->Sockets.clear();}
void sfSelectorUDP_Clear(sfSelectorUDP* selector) {CSFML_CALL(selector, Clear()); selector->Sockets.clear();}
////////////////////////////////////////////////////////////
/// Wait and collect sockets which are ready for reading.
/// This functions will return either when at least one socket
/// is ready, or when the given time is out
////////////////////////////////////////////////////////////
unsigned int sfSelectorTCP_Wait(sfSelectorTCP* Selector, float Timeout) {CSFML_CALL_RETURN(Selector, Wait(Timeout), 0);}
unsigned int sfSelectorUDP_Wait(sfSelectorUDP* Selector, float Timeout) {CSFML_CALL_RETURN(Selector, Wait(Timeout), 0);}
unsigned int sfSelectorTCP_Wait(sfSelectorTCP* selector, float timeout) {CSFML_CALL_RETURN(selector, Wait(timeout), 0);}
unsigned int sfSelectorUDP_Wait(sfSelectorUDP* selector, float timeout) {CSFML_CALL_RETURN(selector, Wait(timeout), 0);}
////////////////////////////////////////////////////////////
@ -78,13 +78,13 @@ unsigned int sfSelectorUDP_Wait(sfSelectorUDP* Selector, float Timeout) {CSFML_C
/// ready for reading. The total number of sockets ready
/// is the integer returned by the previous call to Wait()
////////////////////////////////////////////////////////////
sfSocketTCP* sfSelectorTCP_GetSocketReady(sfSelectorTCP* Selector, unsigned int Index)
sfSocketTCP* sfSelectorTCP_GetSocketReady(sfSelectorTCP* selector, unsigned int index)
{
CSFML_CHECK_RETURN(Selector, NULL);
return Selector->Sockets[Selector->This.GetSocketReady(Index)];
CSFML_CHECK_RETURN(selector, NULL);
return selector->Sockets[selector->This.GetSocketReady(index)];
}
sfSocketUDP* sfSelectorUDP_GetSocketReady(sfSelectorUDP* Selector, unsigned int Index)
sfSocketUDP* sfSelectorUDP_GetSocketReady(sfSelectorUDP* selector, unsigned int index)
{
CSFML_CHECK_RETURN(Selector, NULL);
return Selector->Sockets[Selector->This.GetSocketReady(Index)];
CSFML_CHECK_RETURN(selector, NULL);
return selector->Sockets[selector->This.GetSocketReady(index)];
}

86
CSFML/src/SFML/Network/SocketTCP.cpp
View File

@ -45,12 +45,12 @@ sfSocketTCP* sfSocketTCP_Create()
////////////////////////////////////////////////////////////
/// Destroy an existing TCP socket
////////////////////////////////////////////////////////////
void sfSocketTCP_Destroy(sfSocketTCP* Socket)
void sfSocketTCP_Destroy(sfSocketTCP* socket)
{
if (Socket)
if (socket)
{
Socket->This.Close();
delete Socket;
socket->This.Close();
delete socket;
}
}
@ -59,31 +59,31 @@ void sfSocketTCP_Destroy(sfSocketTCP* Socket)
/// Change the blocking state of a TCP socket.
/// The default behaviour of a socket is blocking
////////////////////////////////////////////////////////////
void sfSocketTCP_SetBlocking(sfSocketTCP* Socket, sfBool Blocking)
void sfSocketTCP_SetBlocking(sfSocketTCP* socket, sfBool blocking)
{
CSFML_CALL(Socket, SetBlocking(Blocking == sfTrue));
CSFML_CALL(socket, SetBlocking(blocking == sfTrue));
}
////////////////////////////////////////////////////////////
/// Connect a TCP socket to another computer on a specified port
////////////////////////////////////////////////////////////
sfSocketStatus sfSocketTCP_Connect(sfSocketTCP* Socket, unsigned short Port, sfIPAddress HostAddress, float Timeout)
sfSocketStatus sfSocketTCP_Connect(sfSocketTCP* socket, unsigned short port, sfIPAddress host, float timeout)
{
sf::IPAddress Address(HostAddress.Address);
sf::IPAddress address(host.Address);
CSFML_CHECK_RETURN(Socket, sfSocketError);
CSFML_CHECK_RETURN(socket, sfSocketError);
return static_cast<sfSocketStatus>(Socket->This.Connect(Port, Address, Timeout));
return static_cast<sfSocketStatus>(socket->This.Connect(port, address, timeout));
}
////////////////////////////////////////////////////////////
/// Listen to a specified port for incoming data or connections
////////////////////////////////////////////////////////////
sfBool sfSocketTCP_Listen(sfSocketTCP* Socket, unsigned short Port)
sfBool sfSocketTCP_Listen(sfSocketTCP* socket, unsigned short port)
{
CSFML_CALL_RETURN(Socket, Listen(Port), sfFalse);
CSFML_CALL_RETURN(socket, Listen(port), sfFalse);
}
@ -92,25 +92,25 @@ sfBool sfSocketTCP_Listen(sfSocketTCP* Socket, unsigned short Port)
/// This function is blocking, ie. it won't return before
/// a connection has been accepted
////////////////////////////////////////////////////////////
sfSocketStatus sfSocketTCP_Accept(sfSocketTCP* Socket, sfSocketTCP** Connected, sfIPAddress* Address)
sfSocketStatus sfSocketTCP_Accept(sfSocketTCP* socket, sfSocketTCP** connected, sfIPAddress* address)
{
CSFML_CHECK_RETURN(Socket, sfSocketError);
CSFML_CHECK_RETURN(Connected, sfSocketError);
CSFML_CHECK_RETURN(socket, sfSocketError);
CSFML_CHECK_RETURN(connected, sfSocketError);
// Call SFML internal function
sf::IPAddress ClientAddress;
sf::SocketTCP Client;
sf::Socket::Status Status = Socket->This.Accept(Client, &ClientAddress);
if (Status != sf::Socket::Done)
return static_cast<sfSocketStatus>(Status);
sf::IPAddress clientAddress;
sf::SocketTCP client;
sf::Socket::Status status = socket->This.Accept(client, &clientAddress);
if (status != sf::Socket::Done)
return static_cast<sfSocketStatus>(status);
// Convert the client socket returned
*Connected = sfSocketTCP_Create();
(*Connected)->This = Client;
*connected = sfSocketTCP_Create();
(*connected)->This = client;
// Convert the address if needed
if (Address)
strncpy(Address->Address, ClientAddress.ToString().c_str(), 16);
if (address)
strncpy(address->Address, clientAddress.ToString().c_str(), 16);
return sfSocketDone;
}
@ -119,29 +119,29 @@ sfSocketStatus sfSocketTCP_Accept(sfSocketTCP* Socket, sfSocketTCP** Connected,
////////////////////////////////////////////////////////////
/// Send an array of bytes to the host (must be connected first)
////////////////////////////////////////////////////////////
sfSocketStatus sfSocketTCP_Send(sfSocketTCP* Socket, const char* Data, size_t Size)
sfSocketStatus sfSocketTCP_Send(sfSocketTCP* socket, const char* data, size_t size)
{
CSFML_CHECK_RETURN(Socket, sfSocketError);
CSFML_CHECK_RETURN(socket, sfSocketError);
return static_cast<sfSocketStatus>(Socket->This.Send(Data, Size));
return static_cast<sfSocketStatus>(socket->This.Send(data, size));
}
////////////////////////////////////////////////////////////
/// Receive an array of bytes from the host (must be connected first)
////////////////////////////////////////////////////////////
sfSocketStatus sfSocketTCP_Receive(sfSocketTCP* Socket, char* Data, size_t MaxSize, size_t* SizeReceived)
sfSocketStatus sfSocketTCP_Receive(sfSocketTCP* socket, char* data, size_t maxSize, size_t* sizeReceived)
{
CSFML_CHECK_RETURN(Socket, sfSocketError);
CSFML_CHECK_RETURN(socket, sfSocketError);
if (SizeReceived)
if (sizeReceived)
{
return static_cast<sfSocketStatus>(Socket->This.Receive(Data, MaxSize, *SizeReceived));
return static_cast<sfSocketStatus>(socket->This.Receive(data, maxSize, *sizeReceived));
}
else
{
std::size_t Size = 0;
return static_cast<sfSocketStatus>(Socket->This.Receive(Data, MaxSize, Size));
std::size_t size = 0;
return static_cast<sfSocketStatus>(socket->This.Receive(data, maxSize, size));
}
}
@ -149,24 +149,24 @@ sfSocketStatus sfSocketTCP_Receive(sfSocketTCP* Socket, char* Data, size_t MaxSi
////////////////////////////////////////////////////////////
/// Send a packet of data to the host (must be connected first)
////////////////////////////////////////////////////////////
sfSocketStatus sfSocketTCP_SendPacket(sfSocketTCP* Socket, sfPacket* Packet)
sfSocketStatus sfSocketTCP_SendPacket(sfSocketTCP* socket, sfPacket* packet)
{
CSFML_CHECK_RETURN(Socket, sfSocketError);
CSFML_CHECK_RETURN(Packet, sfSocketError);
CSFML_CHECK_RETURN(socket, sfSocketError);
CSFML_CHECK_RETURN(packet, sfSocketError);
return static_cast<sfSocketStatus>(Socket->This.Send(Packet->This));
return static_cast<sfSocketStatus>(socket->This.Send(packet->This));
}
////////////////////////////////////////////////////////////
/// Receive a packet from the host (must be connected first)
////////////////////////////////////////////////////////////
sfSocketStatus sfSocketTCP_ReceivePacket(sfSocketTCP* Socket, sfPacket* Packet)
sfSocketStatus sfSocketTCP_ReceivePacket(sfSocketTCP* socket, sfPacket* packet)
{
CSFML_CHECK_RETURN(Socket, sfSocketError);
CSFML_CHECK_RETURN(Packet, sfSocketError);
CSFML_CHECK_RETURN(socket, sfSocketError);
CSFML_CHECK_RETURN(packet, sfSocketError);
return static_cast<sfSocketStatus>(Socket->This.Receive(Packet->This));
return static_cast<sfSocketStatus>(socket->This.Receive(packet->This));
}
@ -174,7 +174,7 @@ sfSocketStatus sfSocketTCP_ReceivePacket(sfSocketTCP* Socket, sfPacket* Packet)
/// Check if a socket is in a valid state ; this function
/// can be called any time to check if the socket is OK
////////////////////////////////////////////////////////////
sfBool sfSocketTCP_IsValid(sfSocketTCP* Socket)
sfBool sfSocketTCP_IsValid(sfSocketTCP* socket)
{
CSFML_CALL_RETURN(Socket, IsValid(), sfFalse);
CSFML_CALL_RETURN(socket, IsValid(), sfFalse);
}

88
CSFML/src/SFML/Network/SocketUDP.cpp
View File

@ -45,9 +45,9 @@ sfSocketUDP* sfSocketUDP_Create()
////////////////////////////////////////////////////////////
/// Destroy an existing UDP socket
////////////////////////////////////////////////////////////
void sfSocketUDP_Destroy(sfSocketUDP* Socket)
void sfSocketUDP_Destroy(sfSocketUDP* socket)
{
delete Socket;
delete socket;
}
@ -55,41 +55,41 @@ void sfSocketUDP_Destroy(sfSocketUDP* Socket)
/// Change the blocking state of a UDP socket.
/// The default behaviour of a socket is blocking
////////////////////////////////////////////////////////////
void sfSocketUDP_SetBlocking(sfSocketUDP* Socket, sfBool Blocking)
void sfSocketUDP_SetBlocking(sfSocketUDP* socket, sfBool blocking)
{
CSFML_CALL(Socket, SetBlocking(Blocking == sfTrue));
CSFML_CALL(socket, SetBlocking(blocking == sfTrue));
}
////////////////////////////////////////////////////////////
/// Bind a socket to a specific port
////////////////////////////////////////////////////////////
sfBool sfSocketUDP_Bind(sfSocketUDP* Socket, unsigned short Port)
sfBool sfSocketUDP_Bind(sfSocketUDP* socket, unsigned short port)
{
CSFML_CALL_RETURN(Socket, Bind(Port), sfFalse);
CSFML_CALL_RETURN(socket, Bind(port), sfFalse);
}
////////////////////////////////////////////////////////////
/// Unbind a socket from its previous port, if any
////////////////////////////////////////////////////////////
sfBool sfSocketUDP_Unbind(sfSocketUDP* Socket)
sfBool sfSocketUDP_Unbind(sfSocketUDP* socket)
{
CSFML_CALL_RETURN(Socket, Unbind(), sfFalse);
CSFML_CALL_RETURN(socket, Unbind(), sfFalse);
}
////////////////////////////////////////////////////////////
/// Send an array of bytes
////////////////////////////////////////////////////////////
sfSocketStatus sfSocketUDP_Send(sfSocketUDP* Socket, const char* Data, size_t Size, sfIPAddress Address, unsigned short Port)
sfSocketStatus sfSocketUDP_Send(sfSocketUDP* socket, const char* data, size_t size, sfIPAddress address, unsigned short port)
{
CSFML_CHECK_RETURN(Socket, sfSocketError)
CSFML_CHECK_RETURN(socket, sfSocketError)
// Convert the address
sf::IPAddress Receiver(Address.Address);
sf::IPAddress receiver(address.Address);
return static_cast<sfSocketStatus>(Socket->This.Send(Data, Size, Receiver, Port));
return static_cast<sfSocketStatus>(socket->This.Send(data, size, receiver, port));
}
@ -98,27 +98,27 @@ sfSocketStatus sfSocketUDP_Send(sfSocketUDP* Socket, const char* Data, size_t Si
/// This function is blocking, ie. it won't return before some
/// bytes have been received
////////////////////////////////////////////////////////////
sfSocketStatus sfSocketUDP_Receive(sfSocketUDP* Socket, char* Data, size_t MaxSize, size_t* SizeReceived, sfIPAddress* Address, unsigned short* Port)
sfSocketStatus sfSocketUDP_Receive(sfSocketUDP* socket, char* data, size_t maxSize, size_t* sizeReceived, sfIPAddress* address, unsigned short* port)
{
CSFML_CHECK_RETURN(Socket, sfSocketError);
// Call SFML internal function
sf::IPAddress Sender;
unsigned short SenderPort;
std::size_t Received;
sf::IPAddress sender;
unsigned short senderPort;
std::size_t received;
sf::Socket::Status Status = Socket->This.Receive(Data, MaxSize, Received, Sender, SenderPort);
if (Status != sf::Socket::Done)
return static_cast<sfSocketStatus>(Status);
sf::Socket::Status status = socket->This.Receive(data, maxSize, received, sender, senderPort);
if (status != sf::Socket::Done)
return static_cast<sfSocketStatus>(status);
if (SizeReceived)
*SizeReceived = Received;
if (sizeReceived)
*sizeReceived = received;
if (Address)
strncpy(Address->Address, Sender.ToString().c_str(), 16);
if (address)
strncpy(address->Address, sender.ToString().c_str(), 16);
if (Port)
*Port = SenderPort;
if (port)
*port = senderPort;
return sfSocketDone;
}
@ -127,15 +127,15 @@ sfSocketStatus sfSocketUDP_Receive(sfSocketUDP* Socket, char* Data, size_t MaxSi
////////////////////////////////////////////////////////////
/// Send a packet of data
////////////////////////////////////////////////////////////
sfSocketStatus sfSocketUDP_SendPacket(sfSocketUDP* Socket, sfPacket* Packet, sfIPAddress Address, unsigned short Port)
sfSocketStatus sfSocketUDP_SendPacket(sfSocketUDP* socket, sfPacket* packet, sfIPAddress address, unsigned short port)
{
CSFML_CHECK_RETURN(Socket, sfSocketError);
CSFML_CHECK_RETURN(Packet, sfSocketError);
CSFML_CHECK_RETURN(socket, sfSocketError);
CSFML_CHECK_RETURN(packet, sfSocketError);
// Convert the address
sf::IPAddress Receiver(Address.Address);
sf::IPAddress receiver(address.Address);
return static_cast<sfSocketStatus>(Socket->This.Send(Packet->This, Receiver, Port));
return static_cast<sfSocketStatus>(socket->This.Send(packet->This, receiver, port));
}
@ -144,22 +144,22 @@ sfSocketStatus sfSocketUDP_SendPacket(sfSocketUDP* Socket, sfPacket* Packet, sfI
/// This function is blocking, ie. it won't return before a
/// packet is received
////////////////////////////////////////////////////////////
sfSocketStatus sfSocketUDP_ReceivePacket(sfSocketUDP* Socket, sfPacket* Packet, sfIPAddress* Address, unsigned short* Port)
sfSocketStatus sfSocketUDP_ReceivePacket(sfSocketUDP* socket, sfPacket* packet, sfIPAddress* address, unsigned short* port)
{
CSFML_CHECK_RETURN(Socket, sfSocketError);
CSFML_CHECK_RETURN(Packet, sfSocketError);
CSFML_CHECK_RETURN(socket, sfSocketError);
CSFML_CHECK_RETURN(packet, sfSocketError);
sf::IPAddress Sender;
unsigned short SenderPort;
sf::Socket::Status Status = Socket->This.Receive(Packet->This, Sender, SenderPort);
if (Status != sf::Socket::Done)
return static_cast<sfSocketStatus>(Status);
sf::IPAddress sender;
unsigned short senderPort;
sf::Socket::Status status = socket->This.Receive(packet->This, sender, senderPort);
if (status != sf::Socket::Done)
return static_cast<sfSocketStatus>(status);
if (Address)
strncpy(Address->Address, Sender.ToString().c_str(), 16);
if (address)
strncpy(address->Address, sender.ToString().c_str(), 16);
if (Port)
*Port = SenderPort;
if (port)
*port = senderPort;
return sfSocketDone;
}
@ -169,7 +169,7 @@ sfSocketStatus sfSocketUDP_ReceivePacket(sfSocketUDP* Socket, sfPacket* Packet,
/// Check if a socket is in a valid state ; this function
/// can be called any time to check if the socket is OK
////////////////////////////////////////////////////////////
sfBool sfSocketUDP_IsValid(sfSocketUDP* Socket)
sfBool sfSocketUDP_IsValid(sfSocketUDP* socket)
{
CSFML_CALL_RETURN(Socket, IsValid(), sfFalse);
CSFML_CALL_RETURN(socket, IsValid(), sfFalse);
}

12
CSFML/src/SFML/System/Clock.cpp
View File

@ -42,25 +42,25 @@ sfClock* sfClock_Create()
////////////////////////////////////////////////////////////
/// Destroy an existing clock
////////////////////////////////////////////////////////////
void sfClock_Destroy(sfClock* Clock)
void sfClock_Destroy(sfClock* clock)
{
delete Clock;
delete clock;
}
////////////////////////////////////////////////////////////
/// Get the time elapsed for a clock
////////////////////////////////////////////////////////////
float sfClock_GetTime(sfClock* Clock)
float sfClock_GetTime(sfClock* clock)
{
CSFML_CALL_RETURN(Clock, GetElapsedTime(), 0.f)
CSFML_CALL_RETURN(clock, GetElapsedTime(), 0.f)
}
////////////////////////////////////////////////////////////
/// Restart a clock
////////////////////////////////////////////////////////////
void sfClock_Reset(sfClock* Clock)
void sfClock_Reset(sfClock* clock)
{
CSFML_CALL(Clock, Reset())
CSFML_CALL(clock, Reset())
}

12
CSFML/src/SFML/System/Mutex.cpp
View File

@ -42,25 +42,25 @@ sfMutex* sfMutex_Create()
////////////////////////////////////////////////////////////
/// Destroy an existing mutex
////////////////////////////////////////////////////////////
void sfMutex_Destroy(sfMutex* Mutex)
void sfMutex_Destroy(sfMutex* mutex)
{
delete Mutex;
delete mutex;
}
////////////////////////////////////////////////////////////
/// Lock a mutex
////////////////////////////////////////////////////////////
void sfMutex_Lock(sfMutex* Mutex)
void sfMutex_Lock(sfMutex* mutex)
{
CSFML_CALL(Mutex, Lock())
CSFML_CALL(mutex, Lock())
}
////////////////////////////////////////////////////////////
/// Unlock a mutex
////////////////////////////////////////////////////////////
void sfMutex_Unlock(sfMutex* Mutex)
void sfMutex_Unlock(sfMutex* mutex)
{
CSFML_CALL(Mutex, Unlock())
CSFML_CALL(mutex, Unlock())
}

12
CSFML/src/SFML/System/Randomizer.cpp
View File

@ -34,9 +34,9 @@
/// Set the seed for the random numbers generator. Using a known seed
/// allows you to reproduce the same sequence of random numbers
////////////////////////////////////////////////////////////
void sfRandom_SetSeed(unsigned int Seed)
void sfRandom_SetSeed(unsigned int seed)
{
sf::Randomizer::SetSeed(Seed);
sf::Randomizer::SetSeed(seed);
}
@ -52,16 +52,16 @@ unsigned int sfRandom_GetSeed()
////////////////////////////////////////////////////////////
/// Get a random float number in a given range
////////////////////////////////////////////////////////////
float sfRandom_Float(float Begin, float End)
float sfRandom_Float(float begin, float end)
{
return sf::Randomizer::Random(Begin, End);
return sf::Randomizer::Random(begin, end);
}
////////////////////////////////////////////////////////////
/// Get a random integer number in a given range
////////////////////////////////////////////////////////////
int sfRandom_Int(int Begin, int End)
int sfRandom_Int(int begin, int end)
{
return sf::Randomizer::Random(Begin, End);
return sf::Randomizer::Random(begin, end);
}

20
CSFML/src/SFML/System/Thread.cpp
View File

@ -33,36 +33,36 @@
////////////////////////////////////////////////////////////
/// Construct a new thread from a function pointer
////////////////////////////////////////////////////////////
sfThread* sfThread_Create(void (*Function)(void*), void* UserData)
sfThread* sfThread_Create(void (*function)(void*), void* userData)
{
return new sfThread(Function, UserData);
return new sfThread(function, userData);
}
////////////////////////////////////////////////////////////
/// Destroy an existing thread
////////////////////////////////////////////////////////////
void sfThread_Destroy(sfThread* Thread)
void sfThread_Destroy(sfThread* thread)
{
delete Thread;
delete thread;
}
////////////////////////////////////////////////////////////
/// Run a thread
////////////////////////////////////////////////////////////
void sfThread_Launch(sfThread* Thread)
void sfThread_Launch(sfThread* thread)
{
CSFML_CALL(Thread, Launch());
CSFML_CALL(thread, Launch());
}
////////////////////////////////////////////////////////////
/// Wait until a thread finishes
////////////////////////////////////////////////////////////
void sfThread_Wait(sfThread* Thread)
void sfThread_Wait(sfThread* thread)
{
CSFML_CALL(Thread, Wait());
CSFML_CALL(thread, Wait());
}
@ -72,7 +72,7 @@ void sfThread_Wait(sfThread* Thread)
/// you should rather try to make the thread function
/// terminate by itself
////////////////////////////////////////////////////////////
void sfThread_Terminate(sfThread* Thread)
void sfThread_Terminate(sfThread* thread)
{
CSFML_CALL(Thread, Terminate());
CSFML_CALL(thread, Terminate());
}

8
CSFML/src/SFML/Window/Context.cpp
View File

@ -42,16 +42,16 @@ sfContext* sfContext_Create()
////////////////////////////////////////////////////////////
/// Destroy an existing context
////////////////////////////////////////////////////////////
void sfContext_Destroy(sfContext* Context)
void sfContext_Destroy(sfContext* context)
{
delete Context;
delete context;
}
////////////////////////////////////////////////////////////
/// Activate or deactivate a context
////////////////////////////////////////////////////////////
void sfContext_SetActive(sfContext* Context, sfBool Active)
void sfContext_SetActive(sfContext* context, sfBool active)
{
CSFML_CALL(Context, SetActive(Active == sfTrue))
CSFML_CALL(context, SetActive(active == sfTrue))
}

24
CSFML/src/SFML/Window/Input.cpp
View File

@ -33,51 +33,51 @@
////////////////////////////////////////////////////////////
/// Get the state of a key
////////////////////////////////////////////////////////////
sfBool sfInput_IsKeyDown(sfInput* Input, sfKeyCode KeyCode)
sfBool sfInput_IsKeyDown(sfInput* input, sfKeyCode code)
{
CSFML_CALL_PTR_RETURN(Input, IsKeyDown((sf::Key::Code)KeyCode), sfFalse);
CSFML_CALL_PTR_RETURN(input, IsKeyDown((sf::Key::Code)code), sfFalse);
}
////////////////////////////////////////////////////////////
/// Get the state of a mouse button
////////////////////////////////////////////////////////////
sfBool sfInput_IsMouseButtonDown(sfInput* Input, sfMouseButton Button)
sfBool sfInput_IsMouseButtonDown(sfInput* input, sfMouseButton button)
{
CSFML_CALL_PTR_RETURN(Input, IsMouseButtonDown((sf::Mouse::Button)Button), sfFalse);
CSFML_CALL_PTR_RETURN(input, IsMouseButtonDown((sf::Mouse::Button)button), sfFalse);
}
////////////////////////////////////////////////////////////
/// Get the state of a joystick button
////////////////////////////////////////////////////////////
sfBool sfInput_IsJoystickButtonDown(sfInput* Input, unsigned int JoyId, unsigned int Button)
sfBool sfInput_IsJoystickButtonDown(sfInput* input, unsigned int joyId, unsigned int button)
{
CSFML_CALL_PTR_RETURN(Input, IsJoystickButtonDown(JoyId, Button), sfFalse);
CSFML_CALL_PTR_RETURN(input, IsJoystickButtonDown(joyId, button), sfFalse);
}
////////////////////////////////////////////////////////////
/// Get the mouse X position
////////////////////////////////////////////////////////////
int sfInput_GetMouseX(sfInput* Input)
int sfInput_GetMouseX(sfInput* input)
{
CSFML_CALL_PTR_RETURN(Input, GetMouseX(), 0);
CSFML_CALL_PTR_RETURN(input, GetMouseX(), 0);
}
////////////////////////////////////////////////////////////
/// Get the mouse Y position
////////////////////////////////////////////////////////////
int sfInput_GetMouseY(sfInput* Input)
int sfInput_GetMouseY(sfInput* input)
{
CSFML_CALL_PTR_RETURN(Input, GetMouseY(), 0);
CSFML_CALL_PTR_RETURN(input, GetMouseY(), 0);
}
////////////////////////////////////////////////////////////
/// Get the joystick position on a given axis
////////////////////////////////////////////////////////////
float sfInput_GetJoystickAxis(sfInput* Input, unsigned int JoyId, sfJoyAxis Axis)
float sfInput_GetJoystickAxis(sfInput* input, unsigned int joyId, sfJoyAxis axis)
{
CSFML_CALL_PTR_RETURN(Input, GetJoystickAxis(JoyId, (sf::Joy::Axis)Axis), 0.f);
CSFML_CALL_PTR_RETURN(input, GetJoystickAxis(joyId, (sf::Joy::Axis)axis), 0.f);
}

32
CSFML/src/SFML/Window/VideoMode.cpp
View File

@ -36,13 +36,13 @@
////////////////////////////////////////////////////////////
sfVideoMode sfVideoMode_GetDesktopMode()
{
sf::VideoMode Desktop = sf::VideoMode::GetDesktopMode();
sfVideoMode Ret;
Ret.Width = Desktop.Width;
Ret.Height = Desktop.Height;
Ret.BitsPerPixel = Desktop.BitsPerPixel;
sf::VideoMode desktop = sf::VideoMode::GetDesktopMode();
sfVideoMode ret;
ret.Width = desktop.Width;
ret.Height = desktop.Height;
ret.BitsPerPixel = desktop.BitsPerPixel;
return Ret;
return ret;
}
@ -51,15 +51,15 @@ sfVideoMode sfVideoMode_GetDesktopMode()
/// Index must be in range [0, GetModesCount()[
/// Modes are sorted from best to worst
////////////////////////////////////////////////////////////
sfVideoMode sfVideoMode_GetMode(size_t Index)
sfVideoMode sfVideoMode_GetMode(size_t index)
{
sf::VideoMode Mode = sf::VideoMode::GetMode(Index);
sfVideoMode Ret;
Ret.Width = Mode.Width;
Ret.Height = Mode.Height;
Ret.BitsPerPixel = Mode.BitsPerPixel;
sf::VideoMode mode = sf::VideoMode::GetMode(index);
sfVideoMode ret;
ret.Width = mode.Width;
ret.Height = mode.Height;
ret.BitsPerPixel = mode.BitsPerPixel;
return Ret;
return ret;
}
@ -75,8 +75,8 @@ size_t sfVideoMode_GetModesCount()
////////////////////////////////////////////////////////////
/// Tell whether or not a video mode is supported
////////////////////////////////////////////////////////////
sfBool sfVideoMode_IsValid(sfVideoMode Mode)
sfBool sfVideoMode_IsValid(sfVideoMode mode)
{
sf::VideoMode VideoMode(Mode.Width, Mode.Height, Mode.BitsPerPixel);
return VideoMode.IsValid() ? sfTrue : sfFalse;
sf::VideoMode videoMode(mode.Width, mode.Height, mode.BitsPerPixel);
return videoMode.IsValid() ? sfTrue : sfFalse;
}

173
CSFML/src/SFML/Window/Window.cpp
View File

@ -33,161 +33,161 @@
////////////////////////////////////////////////////////////
/// Construct a new window
////////////////////////////////////////////////////////////
sfWindow* sfWindow_Create(sfVideoMode Mode, const char* Title, unsigned long Style, sfContextSettings Params)
sfWindow* sfWindow_Create(sfVideoMode mode, const char* title, unsigned long style, sfContextSettings settings)
{
// Convert video mode
sf::VideoMode VideoMode(Mode.Width, Mode.Height, Mode.BitsPerPixel);
sf::VideoMode videoMode(mode.Width, mode.Height, mode.BitsPerPixel);
// Create the window
sfWindow* Window = new sfWindow;
sf::ContextSettings Settings(Params.DepthBits, Params.StencilBits, Params.AntialiasingLevel);
Window->This.Create(VideoMode, Title, Style, Settings);
Window->Input.This = &Window->This.GetInput();
sfWindow* window = new sfWindow;
sf::ContextSettings params(settings.DepthBits, settings.StencilBits, settings.AntialiasingLevel);
window->This.Create(videoMode, title, style, params);
window->Input.This = &window->This.GetInput();
return Window;
return window;
}
////////////////////////////////////////////////////////////
/// Construct a window from an existing control
////////////////////////////////////////////////////////////
sfWindow* sfWindow_CreateFromHandle(sfWindowHandle Handle, sfContextSettings Params)
sfWindow* sfWindow_CreateFromHandle(sfWindowHandle handle, sfContextSettings settings)
{
sfWindow* Window = new sfWindow;
sf::ContextSettings Settings(Params.DepthBits, Params.StencilBits, Params.AntialiasingLevel);
Window->This.Create(Handle, Settings);
Window->Input.This = &Window->This.GetInput();
sfWindow* window = new sfWindow;
sf::ContextSettings params(settings.DepthBits, settings.StencilBits, settings.AntialiasingLevel);
window->This.Create(handle, params);
window->Input.This = &window->This.GetInput();
return Window;
return window;
}
////////////////////////////////////////////////////////////
/// Destroy an existing window
////////////////////////////////////////////////////////////
void sfWindow_Destroy(sfWindow* Window)
void sfWindow_Destroy(sfWindow* window)
{
delete Window;
delete window;
}
////////////////////////////////////////////////////////////
/// Close a window (but doesn't destroy the internal data)
////////////////////////////////////////////////////////////
void sfWindow_Close(sfWindow* Window)
void sfWindow_Close(sfWindow* window)
{
CSFML_CALL(Window, Close());
CSFML_CALL(window, Close());
}
////////////////////////////////////////////////////////////
/// Tell whether or not a window is opened
////////////////////////////////////////////////////////////
sfBool sfWindow_IsOpened(sfWindow* Window)
sfBool sfWindow_IsOpened(sfWindow* window)
{
CSFML_CALL_RETURN(Window, IsOpened(), sfFalse);
CSFML_CALL_RETURN(window, IsOpened(), sfFalse);
}
////////////////////////////////////////////////////////////
/// Get the width of the rendering region of a window
////////////////////////////////////////////////////////////
unsigned int sfWindow_GetWidth(sfWindow* Window)
unsigned int sfWindow_GetWidth(sfWindow* window)
{
CSFML_CALL_RETURN(Window, GetWidth(), 0)
CSFML_CALL_RETURN(window, GetWidth(), 0)
}
////////////////////////////////////////////////////////////
/// Get the height of the rendering region of a window
////////////////////////////////////////////////////////////
unsigned int sfWindow_GetHeight(sfWindow* Window)
unsigned int sfWindow_GetHeight(sfWindow* window)
{
CSFML_CALL_RETURN(Window, GetHeight(), 0)
CSFML_CALL_RETURN(window, GetHeight(), 0)
}
////////////////////////////////////////////////////////////
/// Get the creation settings of a window
////////////////////////////////////////////////////////////
sfContextSettings sfWindow_GetSettings(sfWindow* Window)
sfContextSettings sfWindow_GetSettings(sfWindow* window)
{
sfContextSettings Settings = {0, 0, 0};
CSFML_CHECK_RETURN(Window, Settings);
sfContextSettings settings = {0, 0, 0};
CSFML_CHECK_RETURN(window, settings);
const sf::ContextSettings& Params = Window->This.GetSettings();
Settings.DepthBits = Params.DepthBits;
Settings.StencilBits = Params.StencilBits;
Settings.AntialiasingLevel = Params.AntialiasingLevel;
const sf::ContextSettings& params = window->This.GetSettings();
settings.DepthBits = params.DepthBits;
settings.StencilBits = params.StencilBits;
settings.AntialiasingLevel = params.AntialiasingLevel;
return Settings;
return settings;
}
////////////////////////////////////////////////////////////
/// Get the event on top of events stack of a window, if any, and pop it
////////////////////////////////////////////////////////////
sfBool sfWindow_GetEvent(sfWindow* Window, sfEvent* Event)
sfBool sfWindow_GetEvent(sfWindow* window, sfEvent* event)
{
CSFML_CHECK_RETURN(Window, sfFalse);
CSFML_CHECK_RETURN(Event, sfFalse);
CSFML_CHECK_RETURN(window, sfFalse);
CSFML_CHECK_RETURN(event, sfFalse);
// Get the event
sf::Event SFMLEvent;
sfBool Ret = Window->This.GetEvent(SFMLEvent);
sfBool ret = window->This.GetEvent(SFMLEvent);
// No event, return
if (!Ret)
if (!ret)
return sfFalse;
// Convert its type
Event->Type = static_cast<sfEventType>(SFMLEvent.Type);
event->Type = static_cast<sfEventType>(SFMLEvent.Type);
// Fill its fields
switch (Event->Type)
switch (event->Type)
{
case sfEvtResized :
Event->Size.Width = SFMLEvent.Size.Width;
Event->Size.Height = SFMLEvent.Size.Height;
event->Size.Width = SFMLEvent.Size.Width;
event->Size.Height = SFMLEvent.Size.Height;
break;
case sfEvtTextEntered :
Event->Text.Unicode = SFMLEvent.Text.Unicode;
event->Text.Unicode = SFMLEvent.Text.Unicode;
break;
case sfEvtKeyReleased :
case sfEvtKeyPressed :
Event->Key.Code = static_cast<sfKeyCode>(SFMLEvent.Key.Code);
Event->Key.Alt = SFMLEvent.Key.Alt ? sfTrue : sfFalse;
Event->Key.Control = SFMLEvent.Key.Control ? sfTrue : sfFalse;
Event->Key.Shift = SFMLEvent.Key.Shift ? sfTrue : sfFalse;
event->Key.Code = static_cast<sfKeyCode>(SFMLEvent.Key.Code);
event->Key.Alt = SFMLEvent.Key.Alt ? sfTrue : sfFalse;
event->Key.Control = SFMLEvent.Key.Control ? sfTrue : sfFalse;
event->Key.Shift = SFMLEvent.Key.Shift ? sfTrue : sfFalse;
break;
case sfEvtMouseWheelMoved :
Event->MouseWheel.Delta = SFMLEvent.MouseWheel.Delta;
event->MouseWheel.Delta = SFMLEvent.MouseWheel.Delta;
break;
case sfEvtMouseButtonPressed :
case sfEvtMouseButtonReleased :
Event->MouseButton.Button = static_cast<sfMouseButton>(SFMLEvent.MouseButton.Button);
Event->MouseButton.X = SFMLEvent.MouseButton.X;
Event->MouseButton.Y = SFMLEvent.MouseButton.Y;
event->MouseButton.Button = static_cast<sfMouseButton>(SFMLEvent.MouseButton.Button);
event->MouseButton.X = SFMLEvent.MouseButton.X;
event->MouseButton.Y = SFMLEvent.MouseButton.Y;
break;
case sfEvtMouseMoved :
Event->MouseMove.X = SFMLEvent.MouseMove.X;
Event->MouseMove.Y = SFMLEvent.MouseMove.Y;
event->MouseMove.X = SFMLEvent.MouseMove.X;
event->MouseMove.Y = SFMLEvent.MouseMove.Y;
break;
case sfEvtJoyButtonPressed :
case sfEvtJoyButtonReleased :
Event->JoyButton.JoystickId = SFMLEvent.JoyButton.JoystickId;
Event->JoyButton.Button = SFMLEvent.JoyButton.Button;
event->JoyButton.JoystickId = SFMLEvent.JoyButton.JoystickId;
event->JoyButton.Button = SFMLEvent.JoyButton.Button;
break;
case sfEvtJoyMoved :
Event->JoyMove.JoystickId = SFMLEvent.JoyMove.JoystickId;
Event->JoyMove.Axis = static_cast<sfJoyAxis>(SFMLEvent.JoyMove.Axis);
Event->JoyMove.Position = SFMLEvent.JoyMove.Position;
event->JoyMove.JoystickId = SFMLEvent.JoyMove.JoystickId;
event->JoyMove.Axis = static_cast<sfJoyAxis>(SFMLEvent.JoyMove.Axis);
event->JoyMove.Position = SFMLEvent.JoyMove.Position;
break;
default :
@ -201,27 +201,27 @@ sfBool sfWindow_GetEvent(sfWindow* Window, sfEvent* Event)
////////////////////////////////////////////////////////////
/// Enable / disable vertical synchronization on a window
////////////////////////////////////////////////////////////
void sfWindow_UseVerticalSync(sfWindow* Window, sfBool Enabled)
void sfWindow_UseVerticalSync(sfWindow* window, sfBool enabled)
{
CSFML_CALL(Window, UseVerticalSync(Enabled == sfTrue))
CSFML_CALL(window, UseVerticalSync(enabled == sfTrue))
}
////////////////////////////////////////////////////////////
/// Show or hide the mouse cursor on a window
////////////////////////////////////////////////////////////
void sfWindow_ShowMouseCursor(sfWindow* Window, sfBool Show)
void sfWindow_ShowMouseCursor(sfWindow* window, sfBool show)
{
CSFML_CALL(Window, ShowMouseCursor(Show == sfTrue))
CSFML_CALL(window, ShowMouseCursor(show == sfTrue))
}
////////////////////////////////////////////////////////////
/// Change the position of the mouse cursor on a window
////////////////////////////////////////////////////////////
void sfWindow_SetCursorPosition(sfWindow* Window, unsigned int Left, unsigned int Top)
void sfWindow_SetCursorPosition(sfWindow* window, unsigned int left, unsigned int top)
{
CSFML_CALL(Window, SetCursorPosition(Left, Top))
CSFML_CALL(window, SetCursorPosition(left, top))
}
@ -229,27 +229,27 @@ void sfWindow_SetCursorPosition(sfWindow* Window, unsigned int Left, unsigned in
/// Change the position of a window on screen.
/// Only works for top-level windows
////////////////////////////////////////////////////////////
void sfWindow_SetPosition(sfWindow* Window, int Left, int Top)
void sfWindow_SetPosition(sfWindow* window, int left, int top)
{
CSFML_CALL(Window, SetPosition(Left, Top))
CSFML_CALL(window, SetPosition(left, top))
}
////////////////////////////////////////////////////////////
/// Change the size of the rendering region of a window
////////////////////////////////////////////////////////////
void sfWindow_SetSize(sfWindow* Window, unsigned int Width, unsigned int Height)
void sfWindow_SetSize(sfWindow* window, unsigned int width, unsigned int height)
{
CSFML_CALL(Window, SetSize(Width, Height))
CSFML_CALL(window, SetSize(width, height))
}
////////////////////////////////////////////////////////////
/// Show or hide a window
////////////////////////////////////////////////////////////
void sfWindow_Show(sfWindow* Window, sfBool State)
void sfWindow_Show(sfWindow* window, sfBool show)
{
CSFML_CALL(Window, Show(State == sfTrue))
CSFML_CALL(window, Show(show == sfTrue))
}
@ -257,75 +257,72 @@ void sfWindow_Show(sfWindow* Window, sfBool State)
/// Enable or disable automatic key-repeat for keydown events.
/// Automatic key-repeat is enabled by default
////////////////////////////////////////////////////////////
void sfWindow_EnableKeyRepeat(sfWindow* Window, sfBool Enabled)
void sfWindow_EnableKeyRepeat(sfWindow* window, sfBool enabled)
{
CSFML_CALL(Window, EnableKeyRepeat(Enabled == sfTrue))
CSFML_CALL(window, EnableKeyRepeat(enabled == sfTrue))
}
////////////////////////////////////////////////////////////
/// Change the window's icon
////////////////////////////////////////////////////////////
void sfWindow_SetIcon(sfWindow* Window, unsigned int Width, unsigned int Height, sfUint8* Pixels)
void sfWindow_SetIcon(sfWindow* window, unsigned int width, unsigned int height, sfUint8* pixels)
{
CSFML_CALL(Window, SetIcon(Width, Height, Pixels))
CSFML_CALL(window, SetIcon(width, height, pixels))
}
////////////////////////////////////////////////////////////
/// Activate or deactivate a window as the current target for rendering
////////////////////////////////////////////////////////////
sfBool sfWindow_SetActive(sfWindow* Window, sfBool Active)
sfBool sfWindow_SetActive(sfWindow* window, sfBool active)
{
CSFML_CALL_RETURN(Window, SetActive(Active == sfTrue), sfFalse)
CSFML_CALL_RETURN(window, SetActive(active == sfTrue), sfFalse)
}
////////////////////////////////////////////////////////////
/// Display a window on screen
////////////////////////////////////////////////////////////
void sfWindow_Display(sfWindow* Window)
void sfWindow_Display(sfWindow* window)
{
CSFML_CALL(Window, Display())
CSFML_CALL(window, Display())
}
////////////////////////////////////////////////////////////
/// Get the input manager of a window
////////////////////////////////////////////////////////////
sfInput* sfWindow_GetInput(sfWindow* Window)
sfInput* sfWindow_GetInput(sfWindow* window)
{
CSFML_CHECK_RETURN(Window, NULL);
CSFML_CHECK_RETURN(window, NULL);
return &Window->Input;
return &window->Input;
}
////////////////////////////////////////////////////////////
/// Limit the framerate to a maximum fixed frequency for a window
////////////////////////////////////////////////////////////
void sfWindow_SetFramerateLimit(sfWindow* Window, unsigned int Limit)
void sfWindow_SetFramerateLimit(sfWindow* window, unsigned int limit)
{
CSFML_CALL(Window, SetFramerateLimit(Limit))
CSFML_CALL(window, SetFramerateLimit(limit))
}
////////////////////////////////////////////////////////////
/// Get time elapsed since last frame of a window
////////////////////////////////////////////////////////////
float sfWindow_GetFrameTime(sfWindow* Window)
float sfWindow_GetFrameTime(sfWindow* window)
{
CSFML_CALL_RETURN(Window, GetFrameTime(), 0.f)
CSFML_CALL_RETURN(window, GetFrameTime(), 0.f)
}
////////////////////////////////////////////////////////////
/// Change the joystick threshold, ie. the value below which
/// no move event will be generated
///
/// \param Threshold : New threshold, in range [0, 100]
///
////////////////////////////////////////////////////////////
void sfWindow_SetJoystickThreshold(sfWindow* Window, float Threshold)
void sfWindow_SetJoystickThreshold(sfWindow* window, float threshold)
{
CSFML_CALL(Window, SetJoystickThreshold(Threshold))
CSFML_CALL(window, SetJoystickThreshold(threshold))
}

20
build/vc2008/sfml-audio.vcproj
View File

@ -347,14 +347,6 @@
RelativePath="..\..\src\SFML\Audio\AudioDevice.hpp"
>
</File>
<File
RelativePath="..\..\src\SFML\Audio\AudioResource.cpp"
>
</File>
<File
RelativePath="..\..\src\SFML\Audio\AudioResource.hpp"
>
</File>
<File
RelativePath="..\..\src\SFML\Audio\Listener.cpp"
>
@ -368,7 +360,7 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Audio\Music.hpp"
RelativePath="..\..\include\SFML\Audio\Music.hpp"
>
</File>
<File
@ -380,7 +372,7 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Audio\Sound.hpp"
RelativePath="..\..\include\SFML\Audio\Sound.hpp"
>
</File>
<File
@ -388,7 +380,7 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Audio\SoundBuffer.hpp"
RelativePath="..\..\include\SFML\Audio\SoundBuffer.hpp"
>
</File>
<File
@ -396,7 +388,7 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Audio\SoundBufferRecorder.hpp"
RelativePath="..\..\include\SFML\Audio\SoundBufferRecorder.hpp"
>
</File>
<File
@ -412,7 +404,7 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Audio\SoundRecorder.hpp"
RelativePath="..\..\include\SFML\Audio\SoundRecorder.hpp"
>
</File>
<File
@ -420,7 +412,7 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Audio\SoundStream.hpp"
RelativePath="..\..\include\SFML\Audio\SoundStream.hpp"
>
</File>
</Files>

12
build/vc2008/sfml-main.vcproj
View File

@ -147,16 +147,10 @@
<References>
</References>
<Files>
<Filter
Name="Sources Files"
Filter="cpp;c;cc;cxx;def;odl;idl;hp"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
<File
RelativePath="..\..\src\SFML\Main\SFML_Main.cpp"
>
<File
RelativePath="..\..\src\SFML\Main\SFML_Main.cpp"
>
</File>
</Filter>
</File>
</Files>
<Globals>
</Globals>

20
build/vc2008/sfml-network.vcproj
View File

@ -343,7 +343,7 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Network\Win32\SocketHelper.hpp"
RelativePath="..\..\include\SFML\Network\Win32\SocketHelper.hpp"
>
</File>
</Filter>
@ -368,7 +368,7 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Network\IPAddress.hpp"
RelativePath="..\..\include\SFML\Network\IPAddress.hpp"
>
</File>
<File
@ -376,15 +376,15 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Network\Packet.hpp"
RelativePath="..\..\include\SFML\Network\Packet.hpp"
>
</File>
<File
RelativePath="..\..\src\SFML\Network\Selector.hpp"
RelativePath="..\..\include\SFML\Network\Selector.hpp"
>
</File>
<File
RelativePath="..\..\src\SFML\Network\Selector.inl"
RelativePath="..\..\include\SFML\Network\Selector.inl"
>
</File>
<File
@ -396,7 +396,11 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Network\SocketHelper.hpp"
RelativePath="..\..\include\SFML\Network\SocketHelper.hpp"
>
</File>
<File
RelativePath="..\..\include\SFML\Network\Sockets.hpp"
>
</File>
<File
@ -404,7 +408,7 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Network\SocketTCP.hpp"
RelativePath="..\..\include\SFML\Network\SocketTCP.hpp"
>
</File>
<File
@ -412,7 +416,7 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Network\SocketUDP.hpp"
RelativePath="..\..\include\SFML\Network\SocketUDP.hpp"
>
</File>
</Files>

30
build/vc2008/sfml-system.vcproj
View File

@ -372,7 +372,7 @@
>
</File>
<File
RelativePath="..\..\src\SFML\System\Clock.hpp"
RelativePath="..\..\include\SFML\System\Clock.hpp"
>
</File>
<File
@ -380,7 +380,7 @@
>
</File>
<File
RelativePath="..\..\src\SFML\System\Lock.hpp"
RelativePath="..\..\include\SFML\System\Lock.hpp"
>
</File>
<File
@ -388,11 +388,11 @@
>
</File>
<File
RelativePath="..\..\src\SFML\System\Mutex.hpp"
RelativePath="..\..\include\SFML\System\Mutex.hpp"
>
</File>
<File
RelativePath="..\..\src\SFML\System\NonCopyable.hpp"
RelativePath="..\..\include\SFML\System\NonCopyable.hpp"
>
</File>
<File
@ -404,7 +404,7 @@
>
</File>
<File
RelativePath="..\..\src\SFML\System\Randomizer.hpp"
RelativePath="..\..\include\SFML\System\Randomizer.hpp"
>
</File>
<File
@ -424,7 +424,7 @@
>
</File>
<File
RelativePath="..\..\src\SFML\System\Sleep.hpp"
RelativePath="..\..\include\SFML\System\Sleep.hpp"
>
</File>
<File
@ -432,7 +432,7 @@
>
</File>
<File
RelativePath="..\..\src\SFML\System\Thread.hpp"
RelativePath="..\..\include\SFML\System\Thread.hpp"
>
</File>
<File
@ -463,6 +463,22 @@
RelativePath="..\..\include\SFML\System\Unicode.inl"
>
</File>
<File
RelativePath="..\..\include\SFML\System\Vector2.hpp"
>
</File>
<File
RelativePath="..\..\include\SFML\System\Vector2.inl"
>
</File>
<File
RelativePath="..\..\include\SFML\System\Vector3.hpp"
>
</File>
<File
RelativePath="..\..\include\SFML\System\Vector3.inl"
>
</File>
</Files>
<Globals>
</Globals>

14
build/vc2008/sfml-window.vcproj
View File

@ -428,7 +428,7 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Window\Event.hpp"
RelativePath="..\..\include\SFML\Window\Event.hpp"
>
</File>
<File
@ -436,7 +436,7 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Window\Input.hpp"
RelativePath="..\..\include\SFML\Window\Input.hpp"
>
</File>
<File
@ -448,7 +448,7 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Window\VideoMode.hpp"
RelativePath="..\..\include\SFML\Window\VideoMode.hpp"
>
</File>
<File
@ -460,11 +460,11 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Window\Window.hpp"
RelativePath="..\..\include\SFML\Window\Window.hpp"
>
</File>
<File
RelativePath="..\..\src\SFML\Window\WindowHandle.hpp"
RelativePath="..\..\include\SFML\Window\WindowHandle.hpp"
>
</File>
<File
@ -476,11 +476,11 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Window\WindowListener.hpp"
RelativePath="..\..\include\SFML\Window\WindowListener.hpp"
>
</File>
<File
RelativePath="..\..\src\SFML\Window\WindowStyle.hpp"
RelativePath="..\..\include\SFML\Window\WindowStyle.hpp"
>
</File>
</Files>

BIN
dotnet/extlibs/csfml-audio.dll
View File

Binary file not shown.

BIN
dotnet/extlibs/csfml-graphics.dll
View File

Binary file not shown.

BIN
dotnet/extlibs/csfml-window.dll
View File

Binary file not shown.

4
dotnet/samples/opengl/sample-opengl.csproj
View File

@ -2,7 +2,7 @@
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>8.0.50727</ProductVersion>
<ProductVersion>9.0.21022</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{160AE11E-138A-4B77-9642-EA74F9A79B4D}</ProjectGuid>
<OutputType>WinExe</OutputType>
@ -21,7 +21,7 @@
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<OutputPath>..\bin\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>

4
dotnet/samples/post-fx/sample-postfx.csproj
View File

@ -2,7 +2,7 @@
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>8.0.50727</ProductVersion>
<ProductVersion>9.0.21022</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{9D4738F7-34EA-433A-A765-AF85A52A174D}</ProjectGuid>
<OutputType>WinExe</OutputType>
@ -19,7 +19,7 @@
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<OutputPath>..\bin\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>

4
dotnet/samples/sound/sample-sound.csproj
View File

@ -2,7 +2,7 @@
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>8.0.50727</ProductVersion>
<ProductVersion>9.0.21022</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{16E177F3-A0FF-4091-8521-562E0EBAA3AB}</ProjectGuid>
<OutputType>Exe</OutputType>
@ -21,7 +21,7 @@
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<OutputPath>..\bin\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>

4
dotnet/samples/sound_capture/sample-soundcapture.csproj
View File

@ -2,7 +2,7 @@
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>8.0.50727</ProductVersion>
<ProductVersion>9.0.21022</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{F2F48990-F81E-41BA-AD01-168F6178C807}</ProjectGuid>
<OutputType>Exe</OutputType>
@ -21,7 +21,7 @@
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<OutputPath>..\bin\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>

5
dotnet/samples/window/sample-window.csproj
View File

@ -2,7 +2,7 @@
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>8.0.50727</ProductVersion>
<ProductVersion>9.0.21022</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{C1FBB9AF-B69A-4D06-9BDC-EAC7606296FF}</ProjectGuid>
<OutputType>WinExe</OutputType>
@ -19,10 +19,11 @@
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<OutputPath>..\bin\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<AllowUnsafeBlocks>false</AllowUnsafeBlocks>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>

67
include/SFML/Audio/AudioResource.hpp
View File

@ -1,67 +0,0 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
////////////////////////////////////////////////////////////
#ifndef SFML_AUDIORESOURCE_HPP
#define SFML_AUDIORESOURCE_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Config.hpp>
namespace sf
{
////////////////////////////////////////////////////////////
/// Abstract base class for every class that owns a
/// device-dependant resource -- allow them to initialize / shutdown
/// even when the audio context is not created
////////////////////////////////////////////////////////////
class SFML_API AudioResource
{
protected :
////////////////////////////////////////////////////////////
/// Default constructor
///
////////////////////////////////////////////////////////////
AudioResource();
////////////////////////////////////////////////////////////
/// Copy constructor
///
////////////////////////////////////////////////////////////
AudioResource(const AudioResource&);
////////////////////////////////////////////////////////////
/// Destructor
///
////////////////////////////////////////////////////////////
virtual ~AudioResource();
};
} // namespace sf
#endif // SFML_AUDIORESOURCE_HPP

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

@ -47,10 +47,10 @@ public :
/// Change the global volume of all the sounds.
/// The default volume is 100
///
/// \param Volume : New global volume, in the range [0, 100]
/// \param volume : New global volume, in the range [0, 100]
///
////////////////////////////////////////////////////////////
static void SetGlobalVolume(float Volume);
static void SetGlobalVolume(float volume);
////////////////////////////////////////////////////////////
/// Get the current value of the global volume of all the sounds
@ -64,19 +64,19 @@ public :
/// Change the position of the listener (take 3 values).
/// The default position is (0, 0, 0)
///
/// \param X, Y, Z : Position of the listener in the world
/// \param x, y, z : Position of the listener in the world
///
////////////////////////////////////////////////////////////
static void SetPosition(float X, float Y, float Z);
static void SetPosition(float x, float y, float z);
////////////////////////////////////////////////////////////
/// Change the position of the listener (take a 3D vector).
/// The default position is (0, 0, 0)
///
/// \param Position : Position of the listener in the world
/// \param position : Position of the listener in the world
///
////////////////////////////////////////////////////////////
static void SetPosition(const Vector3f& Position);
static void SetPosition(const Vector3f& position);
////////////////////////////////////////////////////////////
/// Get the current position of the listener
@ -91,20 +91,20 @@ public :
/// he must look at) (take 3 values).
/// The default target is (0, 0, -1)
///
/// \param X, Y, Z : Position of the point the listener must look at
/// \param x, y, z : Position of the point the listener must look at
///
////////////////////////////////////////////////////////////
static void SetTarget(float X, float Y, float Z);
static void SetTarget(float x, float y, float z);
////////////////////////////////////////////////////////////
/// Change the orientation of the listener (the point
/// he must look at) (take a 3D vector).
/// The default target is (0, 0, -1)
///
/// \param Target : Position of the point the listener must look at
/// \param target : Position of the point the listener must look at
///
////////////////////////////////////////////////////////////
static void SetTarget(const Vector3f& Target);
static void SetTarget(const Vector3f& target);
////////////////////////////////////////////////////////////
/// Get the current orientation of the listener (the point

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

@ -52,11 +52,11 @@ public :
////////////////////////////////////////////////////////////
/// Construct the music with a buffer size
///
/// \param BufferSize : Size of the internal buffer, expressed in number of samples
/// \param bufferSize : Size of the internal buffer, expressed in number of samples
/// (ie. size taken by the music in memory) (44100 by default)
///
////////////////////////////////////////////////////////////
Music(std::size_t BufferSize = 44100);
Music(std::size_t bufferSize = 44100);
////////////////////////////////////////////////////////////
/// Destructor
@ -67,23 +67,23 @@ public :
////////////////////////////////////////////////////////////
/// Open a music file (doesn't play it -- call Play() for that)
///
/// \param Filename : Path of the music file to open
/// \param filename : Path of the music file to open
///
/// \return True if loading has been successful
///
////////////////////////////////////////////////////////////
bool OpenFromFile(const std::string& Filename);
bool OpenFromFile(const std::string& filename);
////////////////////////////////////////////////////////////
/// Open a music file from memory (doesn't play it -- call Play() for that)
///
/// \param Data : Pointer to the file data in memory
/// \param SizeInBytes : Size of the data to load, in bytes
/// \param data : Pointer to the file data in memory
/// \param sizeInBytes : Size of the data to load, in bytes
///
/// \return True if loading has been successful
///
////////////////////////////////////////////////////////////
bool OpenFromMemory(const char* Data, std::size_t SizeInBytes);
bool OpenFromMemory(const char* data, std::size_t sizeInBytes);
////////////////////////////////////////////////////////////
/// Get the music duration
@ -99,13 +99,13 @@ private :
/// /see SoundStream::OnGetData
///
////////////////////////////////////////////////////////////
virtual bool OnGetData(Chunk& Data);
virtual bool OnGetData(Chunk& data);
////////////////////////////////////////////////////////////
/// /see SoundStream::OnSeek
///
////////////////////////////////////////////////////////////
virtual void OnSeek(float TimeOffset);
virtual void OnSeek(float timeOffset);
////////////////////////////////////////////////////////////
// Member data

62
include/SFML/Audio/Sound.hpp
View File

@ -28,9 +28,9 @@
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Config.hpp>
#include <SFML/System/Resource.hpp>
#include <SFML/System/Vector3.hpp>
#include <SFML/Audio/AudioResource.hpp>
#include <cstdlib>
@ -42,7 +42,7 @@ class SoundBuffer;
/// Sound defines the properties of a sound such as position,
/// volume, pitch, etc.
////////////////////////////////////////////////////////////
class SFML_API Sound : public AudioResource
class SFML_API Sound
{
public :
@ -65,22 +65,22 @@ public :
////////////////////////////////////////////////////////////
/// Construct the sound from its parameters
///
/// \param Buffer : Sound buffer to play (NULL by default)
/// \param Loop : Loop flag (false by default)
/// \param Pitch : Value of the pitch (1 by default)
/// \param Volume : Volume (100 by default)
/// \param Position : Position (0, 0, 0 by default)
/// \param buffer : Sound buffer to play (NULL by default)
/// \param loop : Loop flag (false by default)
/// \param pitch : Value of the pitch (1 by default)
/// \param volume : Volume (100 by default)
/// \param position : Position (0, 0, 0 by default)
///
////////////////////////////////////////////////////////////
Sound(const SoundBuffer& Buffer, bool Loop = false, float Pitch = 1.f, float Volume = 100.f, const Vector3f& Position = Vector3f(0, 0, 0));
Sound(const SoundBuffer& buffer, bool loop = false, float pitch = 1.f, float volume = 100.f, const Vector3f& position = Vector3f(0, 0, 0));
////////////////////////////////////////////////////////////
/// Copy constructor
///
/// \param Copy : Instance to copy
/// \param copy : Instance to copy
///
////////////////////////////////////////////////////////////
Sound(const Sound& Copy);
Sound(const Sound& copy);
////////////////////////////////////////////////////////////
/// Destructor
@ -109,93 +109,93 @@ public :
////////////////////////////////////////////////////////////
/// Set the source buffer
///
/// \param Buffer : New sound buffer to bind to the sound
/// \param buffer : New sound buffer to bind to the sound
///
////////////////////////////////////////////////////////////
void SetBuffer(const SoundBuffer& Buffer);
void SetBuffer(const SoundBuffer& buffer);
////////////////////////////////////////////////////////////
/// Set the sound loop state.
/// This parameter is disabled by default
///
/// \param Loop : True to play in loop, false to play once
/// \param loop : True to play in loop, false to play once
///
////////////////////////////////////////////////////////////
void SetLoop(bool Loop);
void SetLoop(bool loop);
////////////////////////////////////////////////////////////
/// Set the sound pitch.
/// The default pitch is 1
///
/// \param Pitch : New pitch
/// \param pitch : New pitch
///
////////////////////////////////////////////////////////////
void SetPitch(float Pitch);
void SetPitch(float pitch);
////////////////////////////////////////////////////////////
/// Set the sound volume.
/// The default volume is 100
///
/// \param Volume : Volume (in range [0, 100])
/// \param volume : Volume (in range [0, 100])
///
////////////////////////////////////////////////////////////
void SetVolume(float Volume);
void SetVolume(float volume);
////////////////////////////////////////////////////////////
/// Set the sound position (take 3 values).
/// The default position is (0, 0, 0)
///
/// \param X, Y, Z : Position of the sound in the world
/// \param x, y, z : Position of the sound in the world
///
////////////////////////////////////////////////////////////
void SetPosition(float X, float Y, float Z);
void SetPosition(float x, float y, float z);
////////////////////////////////////////////////////////////
/// Set the sound position (take a 3D vector).
/// The default position is (0, 0, 0)
///
/// \param Position : Position of the sound in the world
/// \param position : Position of the sound in the world
///
////////////////////////////////////////////////////////////
void SetPosition(const Vector3f& Position);
void SetPosition(const Vector3f& position);
////////////////////////////////////////////////////////////
/// Make the sound's position relative to the listener's
/// position, or absolute.
/// The default value is false (absolute)
///
/// \param Relative : True to set the position relative, false to set it absolute
/// \param relative : True to set the position relative, false to set it absolute
///
////////////////////////////////////////////////////////////
void SetRelativeToListener(bool Relative);
void SetRelativeToListener(bool relative);
////////////////////////////////////////////////////////////
/// Set the minimum distance - closer than this distance,
/// the listener will hear the sound at its maximum volume.
/// The default minimum distance is 1.0
///
/// \param MinDistance : New minimum distance for the sound
/// \param distance : New minimum distance for the sound
///
////////////////////////////////////////////////////////////
void SetMinDistance(float MinDistance);
void SetMinDistance(float distance);
////////////////////////////////////////////////////////////
/// Set the attenuation factor - the higher the attenuation, the
/// more the sound will be attenuated with distance from listener.
/// The default attenuation factor 1.0
///
/// \param Attenuation : New attenuation factor for the sound
/// \param attenuation : New attenuation factor for the sound
///
////////////////////////////////////////////////////////////
void SetAttenuation(float Attenuation);
void SetAttenuation(float attenuation);
////////////////////////////////////////////////////////////
/// Set the current playing position of the sound
///
/// \param TimeOffset : New playing position, expressed in seconds
/// \param timeOffset : New playing position, expressed in seconds
///
////////////////////////////////////////////////////////////
void SetPlayingOffset(float TimeOffset);
void SetPlayingOffset(float timeOffset);
////////////////////////////////////////////////////////////
/// Get the source buffer
@ -286,7 +286,7 @@ public :
/// \return Reference to the sound
///
////////////////////////////////////////////////////////////
Sound& operator =(const Sound& Other);
Sound& operator =(const Sound& other);
private :

42
include/SFML/Audio/SoundBuffer.hpp
View File

@ -28,8 +28,8 @@
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Config.hpp>
#include <SFML/System/Resource.hpp>
#include <SFML/Audio/AudioResource.hpp>
#include <string>
#include <vector>
@ -40,7 +40,7 @@ namespace sf
/// SoundBuffer is the low-level for loading and manipulating
/// sound buffers
////////////////////////////////////////////////////////////
class SFML_API SoundBuffer : public AudioResource, public Resource<SoundBuffer>
class SFML_API SoundBuffer : public Resource<SoundBuffer>
{
public :
@ -53,10 +53,10 @@ public :
////////////////////////////////////////////////////////////
/// Copy constructor
///
/// \param Copy : Instance to copy
/// \param copy : Instance to copy
///
////////////////////////////////////////////////////////////
SoundBuffer(const SoundBuffer& Copy);
SoundBuffer(const SoundBuffer& copy);
////////////////////////////////////////////////////////////
/// Destructor
@ -67,47 +67,47 @@ public :
////////////////////////////////////////////////////////////
/// Load the sound buffer from a file
///
/// \param Filename : Path of the sound file to load
/// \param filename : Path of the sound file to load
///
/// \return True if loading has been successful
///
////////////////////////////////////////////////////////////
bool LoadFromFile(const std::string& Filename);
bool LoadFromFile(const std::string& filename);
////////////////////////////////////////////////////////////
/// Load the sound buffer from a file in memory
///
/// \param Data : Pointer to the file data in memory
/// \param SizeInBytes : Size of the data to load, in bytes
/// \param data : Pointer to the file data in memory
/// \param sizeInBytes : Size of the data to load, in bytes
///
/// \return True if loading has been successful
///
////////////////////////////////////////////////////////////
bool LoadFromMemory(const char* Data, std::size_t SizeInBytes);
bool LoadFromMemory(const char* data, std::size_t sizeInBytes);
////////////////////////////////////////////////////////////
/// Load the sound buffer from an array of samples - assumed format for
/// samples is 16 bits signed integer
///
/// \param Samples : Pointer to the samples in memory
/// \param SamplesCount : Number of samples pointed by Samples
/// \param ChannelsCount : Number of channels (1 = mono, 2 = stereo, ...)
/// \param SampleRate : Frequency (number of samples to play per second)
/// \param samples : Pointer to the samples in memory
/// \param samplesCount : Number of samples pointed by Samples
/// \param channelsCount : Number of channels (1 = mono, 2 = stereo, ...)
/// \param sampleRate : Frequency (number of samples to play per second)
///
/// \return True if loading has been successful
///
////////////////////////////////////////////////////////////
bool LoadFromSamples(const Int16* Samples, std::size_t SamplesCount, unsigned int ChannelsCount, unsigned int SampleRate);
bool LoadFromSamples(const Int16* samples, std::size_t samplesCount, unsigned int channelsCount, unsigned int sampleRate);
////////////////////////////////////////////////////////////
/// Save the sound buffer to a file
///
/// \param Filename : Path of the sound file to write
/// \param filename : Path of the sound file to write
///
/// \return True if saving has been successful
///
////////////////////////////////////////////////////////////
bool SaveToFile(const std::string& Filename) const;
bool SaveToFile(const std::string& filename) const;
////////////////////////////////////////////////////////////
/// Return the sound samples
@ -152,12 +152,12 @@ public :
////////////////////////////////////////////////////////////
/// Assignment operator
///
/// \param Other : Instance to assign
/// \param other : Instance to assign
///
/// \return Reference to the sound buffer
///
////////////////////////////////////////////////////////////
SoundBuffer& operator =(const SoundBuffer& Other);
SoundBuffer& operator =(const SoundBuffer& other);
private :
@ -166,13 +166,13 @@ private :
////////////////////////////////////////////////////////////
/// Update the internal buffer with the audio samples
///
/// \param ChannelsCount : Number of channels
/// \param SampleRate : Sample rate
/// \param channelsCount : Number of channels
/// \param sampleRate : Sample rate
///
/// \return True on success
///
////////////////////////////////////////////////////////////
bool Update(unsigned int ChannelsCount, unsigned int SampleRate);
bool Update(unsigned int channelsCount, unsigned int sampleRate);
////////////////////////////////////////////////////////////
// Member data

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

@ -63,7 +63,7 @@ private :
/// /see SoundBuffer::OnProcessSamples
///
////////////////////////////////////////////////////////////
virtual bool OnProcessSamples(const Int16* Samples, std::size_t SamplesCount);
virtual bool OnProcessSamples(const Int16* samples, std::size_t samplesCount);
////////////////////////////////////////////////////////////
/// /see SoundBuffer::OnStop

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

@ -52,11 +52,11 @@ public :
/// Start the capture.
/// Warning : only one capture can happen at the same time
///
/// \param SampleRate : Sound frequency (the more samples, the higher the quality)
/// \param sampleRate : Sound frequency (the more samples, the higher the quality)
/// (44100 by default = CD quality)
///
////////////////////////////////////////////////////////////
void Start(unsigned int SampleRate = 44100);
void Start(unsigned int sampleRate = 44100);
////////////////////////////////////////////////////////////
/// Stop the capture
@ -102,13 +102,13 @@ private :
////////////////////////////////////////////////////////////
/// Process a new chunk of recorded samples
///
/// \param Samples : Pointer to the new chunk of recorded samples
/// \param SamplesCount : Number of samples pointed by Samples
/// \param samples : Pointer to the new chunk of recorded samples
/// \param samplesCount : Number of samples pointed by Samples
///
/// \return False to stop recording audio data, true to continue
///
////////////////////////////////////////////////////////////
virtual bool OnProcessSamples(const Int16* Samples, std::size_t SamplesCount) = 0;
virtual bool OnProcessSamples(const Int16* samples, std::size_t samplesCount) = 0;
////////////////////////////////////////////////////////////
/// Stop recording audio data

26
include/SFML/Audio/SoundStream.hpp
View File

@ -117,10 +117,10 @@ public :
////////////////////////////////////////////////////////////
/// Set the current playing position of the stream
///
/// \param TimeOffset : New playing position, expressed in seconds
/// \param timeOffset : New playing position, expressed in seconds
///
////////////////////////////////////////////////////////////
void SetPlayingOffset(float TimeOffset);
void SetPlayingOffset(float timeOffset);
////////////////////////////////////////////////////////////
/// Get the current playing position of the stream
@ -134,10 +134,10 @@ public :
/// Set the stream loop state.
/// This parameter is disabled by default
///
/// \param Loop : True to play in loop, false to play once
/// \param loop : True to play in loop, false to play once
///
////////////////////////////////////////////////////////////
void SetLoop(bool Loop);
void SetLoop(bool loop);
////////////////////////////////////////////////////////////
/// Tell whether or not the stream is looping
@ -158,11 +158,11 @@ protected :
////////////////////////////////////////////////////////////
/// Set the audio stream parameters, you must call it before Play()
///
/// \param ChannelsCount : Number of channels
/// \param SampleRate : Sample rate
/// \param channelsCount : Number of channels
/// \param sampleRate : Sample rate
///
////////////////////////////////////////////////////////////
void Initialize(unsigned int ChannelsCount, unsigned int SampleRate);
void Initialize(unsigned int channelsCount, unsigned int sampleRate);
private :
@ -175,31 +175,31 @@ private :
////////////////////////////////////////////////////////////
/// Called each time new audio data is needed to feed the stream
///
/// \param Data : New chunk of data to stream
/// \param data : New chunk of data to stream
///
/// \return True to continue playback, false to stop
///
////////////////////////////////////////////////////////////
virtual bool OnGetData(Chunk& Data) = 0;
virtual bool OnGetData(Chunk& data) = 0;
////////////////////////////////////////////////////////////
/// Called to move the current reading position
///
/// \param TimeOffset : New read position, expressed in seconds
/// \param timeOffset : New read position, expressed in seconds
///
////////////////////////////////////////////////////////////
virtual void OnSeek(float TimeOffset) = 0;
virtual void OnSeek(float timeOffset) = 0;
////////////////////////////////////////////////////////////
/// Fill a new buffer with audio data, and push it to the
/// playing queue
///
/// \param Buffer : Buffer to fill
/// \param buffer : Buffer to fill
///
/// \return True if the derived class has requested to stop
///
////////////////////////////////////////////////////////////
bool FillAndPushBuffer(unsigned int Buffer);
bool FillAndPushBuffer(unsigned int buffer);
////////////////////////////////////////////////////////////
/// Fill the buffers queue with all available buffers

106
include/SFML/Graphics/Color.hpp
View File

@ -50,53 +50,13 @@ public :
////////////////////////////////////////////////////////////
/// Construct the color from its 4 RGBA components
///
/// \param R : Red component (0 .. 255)
/// \param G : Green component (0 .. 255)
/// \param B : Blue component (0 .. 255)
/// \param A : Alpha component (0 .. 255) (255 by default)
/// \param red : Red component (0 .. 255)
/// \param green : Green component (0 .. 255)
/// \param blue : Blue component (0 .. 255)
/// \param alpha : Alpha (opacity) component (0 .. 255) (255 by default)
///
////////////////////////////////////////////////////////////
Color(Uint8 R, Uint8 G, Uint8 B, Uint8 A = 255);
////////////////////////////////////////////////////////////
/// Operator += overload to add a color
///
/// \param Other : Color to add
///
/// \return Component-wise saturated addition of the two colors
///
////////////////////////////////////////////////////////////
Color& operator +=(const Color& Other);
////////////////////////////////////////////////////////////
/// Operator *= overload to modulate a color
///
/// \param Other : Color to modulate
///
/// \return Component-wise multiplication of the two colors
///
////////////////////////////////////////////////////////////
Color& operator *=(const Color& Other);
////////////////////////////////////////////////////////////
/// Compare two colors (for equality)
///
/// \param Other : Color to compare
///
/// \return True if colors are equal
///
////////////////////////////////////////////////////////////
bool operator ==(const Color& Other) const;
////////////////////////////////////////////////////////////
/// Compare two colors (for difference)
///
/// \param Other : Color to compare
///
/// \return True if colors are different
///
////////////////////////////////////////////////////////////
bool operator !=(const Color& Other) const;
Color(Uint8 red, Uint8 green, Uint8 blue, Uint8 alpha = 255);
////////////////////////////////////////////////////////////
// Static member data
@ -119,27 +79,71 @@ public :
Uint8 a; ///< Alpha (transparency) component
};
////////////////////////////////////////////////////////////
/// Compare two colors (for equality)
///
/// \param left : Left operand
/// \param right : Right operand
///
/// \return True if colors are equal
///
////////////////////////////////////////////////////////////
bool operator ==(const Color& left, const Color& right);
////////////////////////////////////////////////////////////
/// Compare two colors (for difference)
///
/// \param left : Left operand
/// \param right : Right operand
///
/// \return True if colors are different
///
////////////////////////////////////////////////////////////
bool operator !=(const Color& left, const Color& right);
////////////////////////////////////////////////////////////
/// Operator + overload to add two colors
///
/// \param Color1 : First color
/// \param Color2 : Second color
/// \param left : Left operand
/// \param right : Right operand
///
/// \return Component-wise saturated addition of the two colors
///
////////////////////////////////////////////////////////////
SFML_API Color operator +(const Color& Color1, const Color& Color2);
SFML_API Color operator +(const Color& left, const Color& right);
////////////////////////////////////////////////////////////
/// Operator * overload to modulate two colors
///
/// \param Color1 : First color
/// \param Color2 : Second color
/// \param left : Left operand
/// \param right : Right operand
///
/// \return Component-wise multiplication of the two colors
///
////////////////////////////////////////////////////////////
SFML_API Color operator *(const Color& Color1, const Color& Color2);
SFML_API Color operator *(const Color& left, const Color& right);
////////////////////////////////////////////////////////////
/// Operator += overload to add a color
///
/// \param left : Left operand
/// \param right : Right operand
///
/// \return Component-wise saturated addition of the two colors
///
////////////////////////////////////////////////////////////
Color& operator +=(Color& left, const Color& right);
////////////////////////////////////////////////////////////
/// Operator *= overload to modulate a color
///
/// \param left : Left operand
/// \param right : Right operand
///
/// \return Component-wise multiplication of the two colors
///
////////////////////////////////////////////////////////////
Color& operator *=(Color& left, const Color& right);
} // namespace sf

102
include/SFML/Graphics/Drawable.hpp
View File

@ -62,13 +62,13 @@ public :
////////////////////////////////////////////////////////////
/// Default constructor
///
/// \param Position : Position of the object (0, 0 by default)
/// \param Scale : Scale factor (1, 1 by default)
/// \param Rotation : Orientation, in degrees (0 by default)
/// \param Col : Color of the object (white by default)
/// \param position : Position of the object ((0, 0) by default)
/// \param scale : Scale factor ((1, 1) by default)
/// \param rotation : Orientation, in degrees (0 by default)
/// \param color : Color of the object (white by default)
///
////////////////////////////////////////////////////////////
Drawable(const Vector2f& Position = Vector2f(0, 0), const Vector2f& Scale = Vector2f(1, 1), float Rotation = 0.f, const Color& Col = Color(255, 255, 255, 255));
Drawable(const Vector2f& position = Vector2f(0, 0), const Vector2f& scale = Vector2f(1, 1), float rotation = 0.f, const Color& color = Color(255, 255, 255));
////////////////////////////////////////////////////////////
/// Virtual destructor
@ -79,44 +79,44 @@ public :
////////////////////////////////////////////////////////////
/// Set the position of the object (take 2 values)
///
/// \param X : New X coordinate
/// \param Y : New Y coordinate
/// \param x : New X coordinate
/// \param y : New Y coordinate
///
////////////////////////////////////////////////////////////
void SetPosition(float X, float Y);
void SetPosition(float x, float y);
////////////////////////////////////////////////////////////
/// Set the position of the object (take a 2D vector)
///
/// \param Position : New position
/// \param position : New position
///
////////////////////////////////////////////////////////////
void SetPosition(const Vector2f& Position);
void SetPosition(const Vector2f& position);
////////////////////////////////////////////////////////////
/// Set the X position of the object
///
/// \param X : New X coordinate
/// \param x : New X coordinate
///
////////////////////////////////////////////////////////////
void SetX(float X);
void SetX(float x);
////////////////////////////////////////////////////////////
/// Set the Y position of the object
///
/// \param Y : New Y coordinate
/// \param y : New Y coordinate
///
////////////////////////////////////////////////////////////
void SetY(float Y);
void SetY(float y);
////////////////////////////////////////////////////////////
/// Set the scale of the object (take 2 values)
///
/// \param ScaleX : New horizontal scale (must be strictly positive)
/// \param ScaleY : New vertical scale (must be strictly positive)
/// \param factorX : New horizontal scale (must be strictly positive)
/// \param factorY : New vertical scale (must be strictly positive)
///
////////////////////////////////////////////////////////////
void SetScale(float ScaleX, float ScaleY);
void SetScale(float factorX, float factorY);
////////////////////////////////////////////////////////////
/// Set the scale of the object (take a 2D vector)
@ -124,70 +124,70 @@ public :
/// \param Scale : New scale (both values must be strictly positive)
///
////////////////////////////////////////////////////////////
void SetScale(const Vector2f& Scale);
void SetScale(const Vector2f& scale);
////////////////////////////////////////////////////////////
/// Set the X scale factor of the object
///
/// \param X : New X scale factor
/// \param factor : New X scale factor
///
////////////////////////////////////////////////////////////
void SetScaleX(float FactorX);
void SetScaleX(float factor);
////////////////////////////////////////////////////////////
/// Set the Y scale factor of the object
///
/// \param Y : New Y scale factor
/// \param factor : New Y scale factor
///
////////////////////////////////////////////////////////////
void SetScaleY(float FactorY);
void SetScaleY(float factor);
////////////////////////////////////////////////////////////
/// Set the local origin of the object, in coordinates relative to the
/// top-left of the object (take 2 values).
/// The default origin is (0, 0)
///
/// \param OriginX : X coordinate of the origin
/// \param OriginY : Y coordinate of the origin
/// \param x : X coordinate of the origin
/// \param y : Y coordinate of the origin
///
////////////////////////////////////////////////////////////
void SetOrigin(float OriginX, float OriginY);
void SetOrigin(float x, float y);
////////////////////////////////////////////////////////////
/// Set the local origin of the object, in coordinates relative to the
/// top-left of the object (take a 2D vector).
/// The default origin is (0, 0)
///
/// \param Origin : New origin
/// \param origin : New origin
///
////////////////////////////////////////////////////////////
void SetOrigin(const Vector2f& Origin);
void SetOrigin(const Vector2f& origin);
////////////////////////////////////////////////////////////
/// Set the orientation of the object
///
/// \param Rotation : Angle of rotation, in degrees
/// \param angle : Angle of rotation, in degrees
///
////////////////////////////////////////////////////////////
void SetRotation(float Rotation);
void SetRotation(float angle);
////////////////////////////////////////////////////////////
/// Set the color of the object.
/// The default color is white
///
/// \param Col : New color
/// \param color : New color
///
////////////////////////////////////////////////////////////
void SetColor(const Color& Col);
void SetColor(const Color& color);
////////////////////////////////////////////////////////////
/// Set the blending mode for the object.
/// The default blend mode is Blend::Alpha
///
/// \param Mode : New blending mode
/// \param mode : New blending mode
///
////////////////////////////////////////////////////////////
void SetBlendMode(Blend::Mode Mode);
void SetBlendMode(Blend::Mode mode);
////////////////////////////////////////////////////////////
/// Get the position of the object
@ -241,36 +241,36 @@ public :
////////////////////////////////////////////////////////////
/// Move the object of a given offset (take 2 values)
///
/// \param OffsetX : X offset
/// \param OffsetY : Y offset
/// \param offsetX : X offset
/// \param offsetY : Y offset
///
////////////////////////////////////////////////////////////
void Move(float OffsetX, float OffsetY);
void Move(float offsetX, float offsetY);
////////////////////////////////////////////////////////////
/// Move the object of a given offset (take a 2D vector)
///
/// \param Offset : Amount of units to move the object of
/// \param offset : Amount of units to move the object of
///
////////////////////////////////////////////////////////////
void Move(const Vector2f& Offset);
void Move(const Vector2f& offset);
////////////////////////////////////////////////////////////
/// Scale the object (take 2 values)
///
/// \param FactorX : Scaling factor on X (must be strictly positive)
/// \param FactorY : Scaling factor on Y (must be strictly positive)
/// \param factorX : Scaling factor on X (must be strictly positive)
/// \param factorY : Scaling factor on Y (must be strictly positive)
///
////////////////////////////////////////////////////////////
void Scale(float FactorX, float FactorY);
void Scale(float factorX, float factorY);
////////////////////////////////////////////////////////////
/// Scale the object (take a 2D vector)
///
/// \param Factor : Scaling factors (both values must be strictly positive)
/// \param factor : Scaling factors (both values must be strictly positive)
///
////////////////////////////////////////////////////////////
void Scale(const Vector2f& Factor);
void Scale(const Vector2f& factor);
////////////////////////////////////////////////////////////
/// Rotate the object
@ -284,23 +284,23 @@ public :
/// Transform a point from global coordinates into local coordinates
/// (ie it applies the inverse of object's origin, translation, rotation and scale to the point)
///
/// \param Point : Point to transform
/// \param point : Point to transform
///
/// \return Transformed point
///
////////////////////////////////////////////////////////////
sf::Vector2f TransformToLocal(const sf::Vector2f& Point) const;
sf::Vector2f TransformToLocal(const sf::Vector2f& point) const;
////////////////////////////////////////////////////////////
/// Transform a point from local coordinates into global coordinates
/// (ie it applies the object's origin, translation, rotation and scale to the point)
///
/// \param Point : Point to transform
/// \param point : Point to transform
///
/// \return Transformed point
///
////////////////////////////////////////////////////////////
sf::Vector2f TransformToGlobal(const sf::Vector2f& Point) const;
sf::Vector2f TransformToGlobal(const sf::Vector2f& point) const;
protected :
@ -327,18 +327,18 @@ private :
////////////////////////////////////////////////////////////
/// Draw the object into the specified window
///
/// \param Target : Target into which render the object
/// \param target : Target into which render the object
///
////////////////////////////////////////////////////////////
void Draw(RenderTarget& Target) const;
void Draw(RenderTarget& target) const;
////////////////////////////////////////////////////////////
/// Render the specific geometry of the object
///
/// \param Target : Target into which render the object
/// \param target : Target into which render the object
///
////////////////////////////////////////////////////////////
virtual void Render(RenderTarget& Target) const = 0;
virtual void Render(RenderTarget& target) const = 0;
////////////////////////////////////////////////////////////
// Member data

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

@ -64,27 +64,27 @@ public :
////////////////////////////////////////////////////////////
/// Load the font from a file
///
/// \param Filename : Font file to load
/// \param CharSize : Size of characters in bitmap - the bigger, the higher quality (30 by default)
/// \param Charset : Characters set to generate (by default, contains the ISO-8859-1 printable characters)
/// \param filename : Font file to load
/// \param charSize : Size of characters in bitmap - the bigger, the higher quality (30 by default)
/// \param charset : Characters set to generate (by default, contains the ISO-8859-1 printable characters)
///
/// \return True if loading was successful
///
////////////////////////////////////////////////////////////
bool LoadFromFile(const std::string& Filename, unsigned int CharSize = 30, const Unicode::Text& Charset = ourDefaultCharset);
bool LoadFromFile(const std::string& filename, unsigned int charSize = 30, const Unicode::Text& charset = ourDefaultCharset);
////////////////////////////////////////////////////////////
/// Load the font from a file in memory
///
/// \param Data : Pointer to the data to load
/// \param SizeInBytes : Size of the data, in bytes
/// \param CharSize : Size of characters in bitmap - the bigger, the higher quality (30 by default)
/// \param Charset : Characters set to generate (by default, contains the ISO-8859-1 printable characters)
/// \param data : Pointer to the data to load
/// \param sizeInBytes : Size of the data, in bytes
/// \param charSize : Size of characters in bitmap - the bigger, the higher quality (30 by default)
/// \param charset : Characters set to generate (by default, contains the ISO-8859-1 printable characters)
///
/// \return True if loading was successful
///
////////////////////////////////////////////////////////////
bool LoadFromMemory(const char* Data, std::size_t SizeInBytes, unsigned int CharSize = 30, const Unicode::Text& Charset = ourDefaultCharset);
bool LoadFromMemory(const char* data, std::size_t sizeInBytes, unsigned int charSize = 30, const Unicode::Text& charset = ourDefaultCharset);
////////////////////////////////////////////////////////////
/// Get the base size of characters in the font;
@ -99,12 +99,12 @@ public :
/// Get the description of a glyph (character)
/// given by its unicode value
///
/// \param CodePoint : Unicode value of the character to get
/// \param codePoint : Unicode value of the character to get
///
/// \return Glyph's visual settings, or an invalid glyph if character not found
///
////////////////////////////////////////////////////////////
const Glyph& GetGlyph(Uint32 CodePoint) const;
const Glyph& GetGlyph(Uint32 codePoint) const;
////////////////////////////////////////////////////////////
/// Get the image containing the rendered characters (glyphs)

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

@ -57,30 +57,30 @@ public :
////////////////////////////////////////////////////////////
/// Copy constructor
///
/// \param Copy : instance to copy
/// \param copy : instance to copy
///
////////////////////////////////////////////////////////////
Image(const Image& Copy);
Image(const Image& copy);
////////////////////////////////////////////////////////////
/// Construct an empty image
///
/// \param Width : Image width
/// \param Height : Image height
/// \param Col : Image color (black by default)
/// \param width : Image width
/// \param height : Image height
/// \param color : Image color (black by default)
///
////////////////////////////////////////////////////////////
Image(unsigned int Width, unsigned int Height, const Color& Col = Color(0, 0, 0, 255));
Image(unsigned int width, unsigned int height, const Color& color = Color(0, 0, 0));
////////////////////////////////////////////////////////////
/// Construct the image from pixels in memory
///
/// \param Width : Image width
/// \param Height : Image height
/// \param Data : Pointer to the pixels in memory (assumed format is RGBA)
/// \param width : Image width
/// \param height : Image height
/// \param pixels : Pointer to the pixels in memory (assumed format is RGBA)
///
////////////////////////////////////////////////////////////
Image(unsigned int Width, unsigned int Height, const Uint8* Data);
Image(unsigned int width, unsigned int height, const Uint8* pixels);
////////////////////////////////////////////////////////////
/// Destructor
@ -96,108 +96,108 @@ public :
/// \return True if loading was successful
///
////////////////////////////////////////////////////////////
bool LoadFromFile(const std::string& Filename);
bool LoadFromFile(const std::string& filename);
////////////////////////////////////////////////////////////
/// Load the image from a file in memory
///
/// \param Data : Pointer to the file data in memory
/// \param SizeInBytes : Size of the data to load, in bytes
/// \param data : Pointer to the file data in memory
/// \param sizeInBytes : Size of the data to load, in bytes
///
/// \return True if loading was successful
///
////////////////////////////////////////////////////////////
bool LoadFromMemory(const char* Data, std::size_t SizeInBytes);
bool LoadFromMemory(const char* data, std::size_t sizeInBytes);
////////////////////////////////////////////////////////////
/// Load the image directly from an array of pixels
///
/// \param Width : Image width
/// \param Height : Image height
/// \param Data : Pointer to the pixels in memory (assumed format is RGBA)
/// \param width : Image width
/// \param height : Image height
/// \param pixels : Pointer to the pixels in memory (assumed format is RGBA)
///
/// \return True if loading was successful
///
////////////////////////////////////////////////////////////
bool LoadFromPixels(unsigned int Width, unsigned int Height, const Uint8* Data);
bool LoadFromPixels(unsigned int width, unsigned int height, const Uint8* pixels);
////////////////////////////////////////////////////////////
/// Save the content of the image to a file
///
/// \param Filename : Path of the file to save (overwritten if already exist)
/// \param filename : Path of the file to save (overwritten if already exist)
///
/// \return True if saving was successful
///
////////////////////////////////////////////////////////////
bool SaveToFile(const std::string& Filename) const;
bool SaveToFile(const std::string& filename) const;
////////////////////////////////////////////////////////////
/// Create an empty image
///
/// \param Width : Image width
/// \param Height : Image height
/// \param Col : Image color (black by default)
/// \param width : Image width
/// \param height : Image height
/// \param color : Image color (black by default)
///
/// \return True if creation was successful
///
////////////////////////////////////////////////////////////
bool Create(unsigned int Width, unsigned int Height, Color Col = Color(0, 0, 0, 255));
bool Create(unsigned int width, unsigned int height, const Color& color = Color(0, 0, 0));
////////////////////////////////////////////////////////////
/// Create transparency mask from a specified colorkey
///
/// \param ColorKey : Color to become transparent
/// \param Alpha : Alpha value to use for transparent pixels (0 by default)
/// \param transparentColor : Color to become transparent
/// \param alpha : Alpha value to assign to transparent pixels (0 by default)
///
////////////////////////////////////////////////////////////
void CreateMaskFromColor(Color ColorKey, Uint8 Alpha = 0);
void CreateMaskFromColor(const Color& transparentColor, Uint8 alpha = 0);
////////////////////////////////////////////////////////////
/// Copy pixels from another image onto this one.
/// This function does a slow pixel copy and should only
/// be used at initialization time
///
/// \param Source : Source image to copy
/// \param DestX : X coordinate of the destination position
/// \param DestY : Y coordinate of the destination position
/// \param SourceRect : Sub-rectangle of the source image to copy (empty by default - entire image)
/// \param ApplyAlpha : Should the copy take in account the source transparency? (false by default)
/// \param source : Source image to copy
/// \param destX : X coordinate of the destination position
/// \param destY : Y coordinate of the destination position
/// \param sourceRect : Sub-rectangle of the source image to copy (empty by default - entire image)
/// \param applyAlpha : Should the copy take in account the source transparency? (false by default)
///
////////////////////////////////////////////////////////////
void Copy(const Image& Source, unsigned int DestX, unsigned int DestY, const IntRect& SourceRect = IntRect(0, 0, 0, 0), bool ApplyAlpha = false);
void Copy(const Image& source, unsigned int destX, unsigned int destY, const IntRect& sourceRect = IntRect(0, 0, 0, 0), bool applyAlpha = false);
////////////////////////////////////////////////////////////
/// Create the image from the current contents of the
/// given window
///
/// \param Window : Window to capture
/// \param SourceRect : Sub-rectangle of the screen to copy (empty by default - entire image)
/// \param window : Window to capture
/// \param sourceRect : Sub-rectangle of the screen to copy (empty by default - entire image)
///
/// \return True if copy was successful
///
////////////////////////////////////////////////////////////
bool CopyScreen(RenderWindow& Window, const IntRect& SourceRect = IntRect(0, 0, 0, 0));
bool CopyScreen(RenderWindow& window, const IntRect& sourceRect = IntRect(0, 0, 0, 0));
////////////////////////////////////////////////////////////
/// Change the color of a pixel
///
/// \param X : X coordinate of pixel in the image
/// \param Y : Y coordinate of pixel in the image
/// \param Col : New color for pixel (X, Y)
/// \param x : X coordinate of pixel in the image
/// \param y : Y coordinate of pixel in the image
/// \param color : New color for pixel (x, y)
///
////////////////////////////////////////////////////////////
void SetPixel(unsigned int X, unsigned int Y, const Color& Col);
void SetPixel(unsigned int x, unsigned int y, const Color& color);
////////////////////////////////////////////////////////////
/// Get a pixel from the image
///
/// \param X : X coordinate of pixel in the image
/// \param Y : Y coordinate of pixel in the image
/// \param x : X coordinate of pixel in the image
/// \param y : Y coordinate of pixel in the image
///
/// \return Color of pixel (X, Y)
/// \return Color of pixel (x, y)
///
////////////////////////////////////////////////////////////
const Color& GetPixel(unsigned int X, unsigned int Y) const;
const Color& GetPixel(unsigned int x, unsigned int y) const;
////////////////////////////////////////////////////////////
/// Get a read-only pointer to the array of pixels (RGBA 8 bits integers components)
@ -219,10 +219,10 @@ public :
/// Enable or disable image smooth filter.
/// This parameter is enabled by default
///
/// \param Smooth : True to enable smoothing filter, false to disable it
/// \param smooth : True to enable smoothing filter, false to disable it
///
////////////////////////////////////////////////////////////
void SetSmooth(bool Smooth);
void SetSmooth(bool smooth);
////////////////////////////////////////////////////////////
/// Return the width of the image
@ -252,33 +252,33 @@ public :
/// Convert a subrect expressed in pixels, into float
/// texture coordinates
///
/// \param Rect : Sub-rectangle of image to convert
/// \param Adjust : Pass true to apply the half-texel adjustment
/// \param rectangle : Sub-rectangle of image to convert
/// \param adjust : Pass true to apply the half-texel adjustment (true by default)
///
/// \return Texture coordinates corresponding to the sub-rectangle
///
////////////////////////////////////////////////////////////
FloatRect GetTexCoords(const IntRect& Rect, bool Adjust = true) const;
FloatRect GetTexCoords(const IntRect& rectangle, bool adjust = true) const;
////////////////////////////////////////////////////////////
/// Get a valid texture size according to hardware support
///
/// \param Size : Size to convert
/// \param Size : size to convert
///
/// \return Valid nearest size (greater than or equal to specified size)
///
////////////////////////////////////////////////////////////
static unsigned int GetValidTextureSize(unsigned int Size);
static unsigned int GetValidTextureSize(unsigned int size);
////////////////////////////////////////////////////////////
/// Assignment operator
///
/// \param Other : instance to assign
/// \param other : instance to assign
///
/// \return Reference to the image
///
////////////////////////////////////////////////////////////
Image& operator =(const Image& Other);
Image& operator =(const Image& other);
private :
@ -309,10 +309,10 @@ private :
/// its content.
/// For internal use only (see RenderImage class).
///
/// \param Source : RenderImage that will update the image
/// \param source : RenderImage that will update the image
///
////////////////////////////////////////////////////////////
void ExternalUpdate(RenderImage& Source);
void ExternalUpdate(RenderImage& source);
////////////////////////////////////////////////////////////
/// Reset the image attributes

42
include/SFML/Graphics/Matrix3.hpp
View File

@ -61,33 +61,33 @@ public :
////////////////////////////////////////////////////////////
/// Build a matrix from a set of transformations
///
/// \param Center : Origin for the transformations
/// \param Translation : Translation offset
/// \param Rotation : Rotation angle in degrees
/// \param Scale : Scaling factors
/// \param origin : Origin for the transformations
/// \param translation : Translation offset
/// \param rotation : Rotation angle in degrees
/// \param scale : Scaling factors
///
////////////////////////////////////////////////////////////
void SetFromTransformations(const Vector2f& Center, const Vector2f& Translation, float Rotation, const Vector2f& Scale);
void SetFromTransformations(const Vector2f& origin, const Vector2f& translation, float rotation, const Vector2f& scale);
////////////////////////////////////////////////////////////
/// Build a matrix from a projection
///
/// \param Center : Center of the view
/// \param Size : Size of the view
/// \param Rotation : Angle of rotation of the view rectangle, in degrees
/// \param center : Center of the view
/// \param size : Size of the view
/// \param rotation : Angle of rotation of the view rectangle, in degrees
///
////////////////////////////////////////////////////////////
void SetFromProjection(const Vector2f& Center, const Vector2f& Size, float Rotation);
void SetFromProjection(const Vector2f& center, const Vector2f& size, float rotation);
////////////////////////////////////////////////////////////
/// Transform a point by the matrix
///
/// \param Point : Point to transform
/// \param point : Point to transform
///
/// \return Transformed point
///
////////////////////////////////////////////////////////////
Vector2f Transform(const Vector2f& Point) const;
Vector2f Transform(const Vector2f& point) const;
////////////////////////////////////////////////////////////
/// Return the inverse of the matrix
@ -109,34 +109,34 @@ public :
////////////////////////////////////////////////////////////
/// Operator () overloads to access the matrix elements
///
/// \param Row : Element row (0 based)
/// \param Col : Element column (0 based)
/// \param row : Element row (0 based)
/// \param column : Element column (0 based)
///
/// \return Matrix element (Row, Col)
///
////////////////////////////////////////////////////////////
float operator ()(unsigned int Row, unsigned int Col) const;
float& operator ()(unsigned int Row, unsigned int Col);
float operator ()(unsigned int row, unsigned int column) const;
float& operator ()(unsigned int row, unsigned int column);
////////////////////////////////////////////////////////////
/// Operator * overload to multiply two matrices
///
/// \param Mat : Matrix to multiply
/// \param right : Matrix to multiply
///
/// \return this * Mat
/// \return this * right
///
////////////////////////////////////////////////////////////
Matrix3 operator *(const Matrix3& Mat) const;
Matrix3 operator *(const Matrix3& right) const;
////////////////////////////////////////////////////////////
/// Operator *= overload to multiply-assign two matrices
///
/// \param Mat : Matrix to multiply
/// \param right : Matrix to multiply
///
/// \return this * Mat
/// \return this * right
///
////////////////////////////////////////////////////////////
Matrix3& operator *=(const Matrix3& Mat);
Matrix3& operator *=(const Matrix3& right);
////////////////////////////////////////////////////////////
// Static member data

112
include/SFML/Graphics/Matrix3.inl
View File

@ -52,22 +52,22 @@ inline Matrix3::Matrix3(float a00, float a01, float a02,
////////////////////////////////////////////////////////////
/// Build a matrix from a set of transformations
////////////////////////////////////////////////////////////
inline void Matrix3::SetFromTransformations(const Vector2f& Center, const Vector2f& Translation, float Rotation, const Vector2f& Scale)
inline void Matrix3::SetFromTransformations(const Vector2f& origin, const Vector2f& translation, float rotation, const Vector2f& scale)
{
// Combine the transformations
float Angle = Rotation * 3.141592654f / 180.f;
float Cos = static_cast<float>(cos(Angle));
float Sin = static_cast<float>(sin(Angle));
float SxCos = Scale.x * Cos;
float SyCos = Scale.y * Cos;
float SxSin = Scale.x * Sin;
float SySin = Scale.y * Sin;
float Tx = -Center.x * SxCos - Center.y * SySin + Translation.x;
float Ty = Center.x * SxSin - Center.y * SyCos + Translation.y;
float angle = rotation * 3.141592654f / 180.f;
float cosine = static_cast<float>(cos(angle));
float sine = static_cast<float>(sin(angle));
float sxCos = scale.x * cosine;
float syCos = scale.y * cosine;
float sxSin = scale.x * sine;
float sySin = scale.y * sine;
float tx = -origin.x * sxCos - origin.y * sySin + translation.x;
float ty = origin.x * sxSin - origin.y * syCos + translation.y;
// Rebuild the matrix
myData[0] = SxCos; myData[4] = SySin; myData[8] = 0.f; myData[12] = Tx;
myData[1] = -SxSin; myData[5] = SyCos; myData[9] = 0.f; myData[13] = Ty;
myData[0] = sxCos; myData[4] = sySin; myData[8] = 0.f; myData[12] = tx;
myData[1] = -sxSin; myData[5] = syCos; myData[9] = 0.f; myData[13] = ty;
myData[2] = 0.f; myData[6] = 0.f; myData[10] = 1.f; myData[14] = 0.f;
myData[3] = 0.f; myData[7] = 0.f; myData[11] = 0.f; myData[15] = 1.f;
}
@ -76,36 +76,36 @@ inline void Matrix3::SetFromTransformations(const Vector2f& Center, const Vector
////////////////////////////////////////////////////////////
/// Build a matrix from a projection
////////////////////////////////////////////////////////////
inline void Matrix3::SetFromProjection(const Vector2f& Center, const Vector2f& Size, float Rotation)
inline void Matrix3::SetFromProjection(const Vector2f& center, const Vector2f& size, float rotation)
{
// Rotation components
float Angle = Rotation * 3.141592654f / 180.f;
float Cos = static_cast<float>(cos(Angle));
float Sin = static_cast<float>(sin(Angle));
float Tx = -Center.x * Cos - Center.y * Sin + Center.x;
float Ty = Center.x * Sin - Center.y * Cos + Center.y;
float angle = rotation * 3.141592654f / 180.f;
float cosine = static_cast<float>(cos(angle));
float sine = static_cast<float>(sin(angle));
float tx = -center.x * cosine - center.y * sine + center.x;
float ty = center.x * sine - center.y * cosine + center.y;
// Projection components
float A = 2.f / Size.x;
float B = -2.f / Size.y;
float C = -A * Center.x;
float D = -B * Center.y;
float a = 2.f / size.x;
float b = -2.f / size.y;
float c = -a * center.x;
float d = -b * center.y;
// Rebuild the projection matrix
myData[0] = A * Cos; myData[4] = A * Sin; myData[8] = 0.f; myData[12] = A * Tx + C;
myData[1] = -B * Sin; myData[5] = B * Cos; myData[9] = 0.f; myData[13] = B * Ty + D;
myData[2] = 0.f; myData[6] = 0.f; myData[10] = 1.f; myData[14] = 0.f;
myData[3] = 0.f; myData[7] = 0.f; myData[11] = 0.f; myData[15] = 1.f;
myData[0] = a * cosine; myData[4] = a * sine; myData[8] = 0.f; myData[12] = a * tx + c;
myData[1] = -b * sine; myData[5] = b * cosine; myData[9] = 0.f; myData[13] = b * ty + d;
myData[2] = 0.f; myData[6] = 0.f; myData[10] = 1.f; myData[14] = 0.f;
myData[3] = 0.f; myData[7] = 0.f; myData[11] = 0.f; myData[15] = 1.f;
}
////////////////////////////////////////////////////////////
/// Transform a point by the matrix
////////////////////////////////////////////////////////////
inline Vector2f Matrix3::Transform(const Vector2f& Point) const
inline Vector2f Matrix3::Transform(const Vector2f& point) const
{
return Vector2f(myData[0] * Point.x + myData[4] * Point.y + myData[12],
myData[1] * Point.x + myData[5] * Point.y + myData[13]);
return Vector2f(myData[0] * point.x + myData[4] * point.y + myData[12],
myData[1] * point.x + myData[5] * point.y + myData[13]);
}
@ -115,22 +115,22 @@ inline Vector2f Matrix3::Transform(const Vector2f& Point) const
inline Matrix3 Matrix3::GetInverse() const
{
// Compute the determinant
float Det = myData[0] * (myData[15] * myData[5] - myData[7] * myData[13]) -
float det = myData[0] * (myData[15] * myData[5] - myData[7] * myData[13]) -
myData[1] * (myData[15] * myData[4] - myData[7] * myData[12]) +
myData[3] * (myData[13] * myData[4] - myData[5] * myData[12]);
// Compute the inverse if determinant is not zero
if ((Det < -1E-7f) || (Det > 1E-7f))
if ((det < -1E-7f) || (det > 1E-7f))
{
return Matrix3( (myData[15] * myData[5] - myData[7] * myData[13]) / Det,
-(myData[15] * myData[4] - myData[7] * myData[12]) / Det,
(myData[13] * myData[4] - myData[5] * myData[12]) / Det,
-(myData[15] * myData[1] - myData[3] * myData[13]) / Det,
(myData[15] * myData[0] - myData[3] * myData[12]) / Det,
-(myData[13] * myData[0] - myData[1] * myData[12]) / Det,
(myData[7] * myData[1] - myData[3] * myData[5]) / Det,
-(myData[7] * myData[0] - myData[3] * myData[4]) / Det,
(myData[5] * myData[0] - myData[1] * myData[4]) / Det);
return Matrix3( (myData[15] * myData[5] - myData[7] * myData[13]) / det,
-(myData[15] * myData[4] - myData[7] * myData[12]) / det,
(myData[13] * myData[4] - myData[5] * myData[12]) / det,
-(myData[15] * myData[1] - myData[3] * myData[13]) / det,
(myData[15] * myData[0] - myData[3] * myData[12]) / det,
-(myData[13] * myData[0] - myData[1] * myData[12]) / det,
(myData[7] * myData[1] - myData[3] * myData[5]) / det,
-(myData[7] * myData[0] - myData[3] * myData[4]) / det,
(myData[5] * myData[0] - myData[1] * myData[4]) / det);
}
else
{
@ -152,9 +152,9 @@ inline const float* Matrix3::Get4x4Elements() const
////////////////////////////////////////////////////////////
/// Operator () overloads to access the matrix elements
////////////////////////////////////////////////////////////
inline float Matrix3::operator ()(unsigned int Row, unsigned int Col) const
inline float Matrix3::operator ()(unsigned int row, unsigned int column) const
{
switch (Row + Col * 3)
switch (row + column * 3)
{
case 0 : return myData[0];
case 1 : return myData[1];
@ -169,9 +169,9 @@ inline float Matrix3::operator ()(unsigned int Row, unsigned int Col) const
default : return myData[0];
}
}
inline float& Matrix3::operator ()(unsigned int Row, unsigned int Col)
inline float& Matrix3::operator ()(unsigned int row, unsigned int column)
{
switch (Row + Col * 3)
switch (row + column * 3)
{
case 0 : return myData[0];
case 1 : return myData[1];
@ -191,24 +191,24 @@ inline float& Matrix3::operator ()(unsigned int Row, unsigned int Col)
////////////////////////////////////////////////////////////
/// Operator * overload to multiply two matrices
////////////////////////////////////////////////////////////
inline Matrix3 Matrix3::operator *(const Matrix3& Mat) const
inline Matrix3 Matrix3::operator *(const Matrix3& right) const
{
return Matrix3(myData[0] * Mat.myData[0] + myData[4] * Mat.myData[1] + myData[12] * Mat.myData[3],
myData[0] * Mat.myData[4] + myData[4] * Mat.myData[5] + myData[12] * Mat.myData[7],
myData[0] * Mat.myData[12] + myData[4] * Mat.myData[13] + myData[12] * Mat.myData[15],
myData[1] * Mat.myData[0] + myData[5] * Mat.myData[1] + myData[13] * Mat.myData[3],
myData[1] * Mat.myData[4] + myData[5] * Mat.myData[5] + myData[13] * Mat.myData[7],
myData[1] * Mat.myData[12] + myData[5] * Mat.myData[13] + myData[13] * Mat.myData[15],
myData[3] * Mat.myData[0] + myData[7] * Mat.myData[1] + myData[15] * Mat.myData[3],
myData[3] * Mat.myData[4] + myData[7] * Mat.myData[5] + myData[15] * Mat.myData[7],
myData[3] * Mat.myData[12] + myData[7] * Mat.myData[13] + myData[15] * Mat.myData[15]);
return Matrix3(myData[0] * right.myData[0] + myData[4] * right.myData[1] + myData[12] * right.myData[3],
myData[0] * right.myData[4] + myData[4] * right.myData[5] + myData[12] * right.myData[7],
myData[0] * right.myData[12] + myData[4] * right.myData[13] + myData[12] * right.myData[15],
myData[1] * right.myData[0] + myData[5] * right.myData[1] + myData[13] * right.myData[3],
myData[1] * right.myData[4] + myData[5] * right.myData[5] + myData[13] * right.myData[7],
myData[1] * right.myData[12] + myData[5] * right.myData[13] + myData[13] * right.myData[15],
myData[3] * right.myData[0] + myData[7] * right.myData[1] + myData[15] * right.myData[3],
myData[3] * right.myData[4] + myData[7] * right.myData[5] + myData[15] * right.myData[7],
myData[3] * right.myData[12] + myData[7] * right.myData[13] + myData[15] * right.myData[15]);
}
////////////////////////////////////////////////////////////
/// Operator *= overload to multiply-assign two matrices
////////////////////////////////////////////////////////////
inline Matrix3& Matrix3::operator *=(const Matrix3& Mat)
inline Matrix3& Matrix3::operator *=(const Matrix3& right)
{
return *this = *this * Mat;
return *this = *this * right;
}

52
include/SFML/Graphics/PostFX.hpp
View File

@ -53,10 +53,10 @@ public :
////////////////////////////////////////////////////////////
/// Copy constructor
///
/// \param Copy : Instance to copy
/// \param copy : Instance to copy
///
////////////////////////////////////////////////////////////
PostFX(const PostFX& Copy);
PostFX(const PostFX& copy);
////////////////////////////////////////////////////////////
/// Destructor
@ -67,77 +67,77 @@ public :
////////////////////////////////////////////////////////////
/// Load the effect from a file
///
/// \param Filename : Path of the effect file to load
/// \param filename : Path of the effect file to load
///
/// \return True on success
///
////////////////////////////////////////////////////////////
bool LoadFromFile(const std::string& Filename);
bool LoadFromFile(const std::string& filename);
////////////////////////////////////////////////////////////
/// Load the effect from a text in memory
///
/// \param Effect : String containing the effect code
/// \param effect : String containing the code of the effect
///
/// \return True on success
///
////////////////////////////////////////////////////////////
bool LoadFromMemory(const std::string& Effect);
bool LoadFromMemory(const std::string& effect);
////////////////////////////////////////////////////////////
/// Change a parameter of the effect (1 float)
///
/// \param Name : Parameter name in the effect
/// \param X : Value to assign
/// \param name : Name of the parameter in the effect
/// \param x : Value to assign
///
////////////////////////////////////////////////////////////
void SetParameter(const std::string& Name, float X);
void SetParameter(const std::string& name, float x);
////////////////////////////////////////////////////////////
/// Change a parameter of the effect (2 floats)
///
/// \param Name : Parameter name in the effect
/// \param X, Y : Values to assign
/// \param name : Name of the parameter in the effect
/// \param x, y : Values to assign
///
////////////////////////////////////////////////////////////
void SetParameter(const std::string& Name, float X, float Y);
void SetParameter(const std::string& Name, float x, float y);
////////////////////////////////////////////////////////////
/// Change a parameter of the effect (3 floats)
///
/// \param Name : Parameter name in the effect
/// \param X, Y, Z : Values to assign
/// \param name : Name of the parameter in the effect
/// \param x, y, z : Values to assign
///
////////////////////////////////////////////////////////////
void SetParameter(const std::string& Name, float X, float Y, float Z);
void SetParameter(const std::string& Name, float x, float y, float z);
////////////////////////////////////////////////////////////
/// Change a parameter of the effect (4 floats)
///
/// \param Name : Parameter name in the effect
/// \param X, Y, Z, W : Values to assign
/// \param name : Name of the parameter in the effect
/// \param x, y, z, w : Values to assign
///
////////////////////////////////////////////////////////////
void SetParameter(const std::string& Name, float X, float Y, float Z, float W);
void SetParameter(const std::string& Name, float x, float y, float Z, float w);
////////////////////////////////////////////////////////////
/// Set a texture parameter
///
/// \param Name : Texture name in the effect
/// \param Texture : Image to set (pass NULL to use content of current framebuffer)
/// \param name : Name of the texture in the effect
/// \param texture : Image to set (pass NULL to use content of current framebuffer)
///
////////////////////////////////////////////////////////////
void SetTexture(const std::string& Name, const Image* Texture);
void SetTexture(const std::string& name, const Image* texture);
////////////////////////////////////////////////////////////
/// Assignment operator
///
/// \param Other : Instance to assign
/// \param other : Instance to assign
///
/// \return Reference to the post-effect
///
////////////////////////////////////////////////////////////
PostFX& operator =(const PostFX& Other);
PostFX& operator =(const PostFX& other);
////////////////////////////////////////////////////////////
/// Tell whether or not the system supports post-effects
@ -153,7 +153,7 @@ protected :
/// /see Drawable::Render
///
////////////////////////////////////////////////////////////
virtual void Render(RenderTarget& Target) const;
virtual void Render(RenderTarget& target) const;
private :
@ -161,12 +161,12 @@ private :
/// Preprocess a SFML effect file
/// to convert it to a valid GLSL fragment shader
///
/// \param File : Stream containing the code to process
/// \param file : Stream containing the code to process
///
/// \return Valid fragment shader source code
///
////////////////////////////////////////////////////////////
static std::string PreprocessEffect(std::istream& File);
static std::string PreprocessEffect(std::istream& file);
////////////////////////////////////////////////////////////
/// Create the program and attach the shaders

40
include/SFML/Graphics/Rect.hpp
View File

@ -52,13 +52,13 @@ public :
////////////////////////////////////////////////////////////
/// Construct the rectangle from its coordinates
///
/// \param LeftCoord : Left coordinate of the rectangle
/// \param TopCoord : Top coordinate of the rectangle
/// \param RightCoord : Right coordinate of the rectangle
/// \param BottomCoord : Bottom coordinate of the rectangle
/// \param left : Left coordinate of the rectangle
/// \param top : Top coordinate of the rectangle
/// \param right : Right coordinate of the rectangle
/// \param bottom : Bottom coordinate of the rectangle
///
////////////////////////////////////////////////////////////
Rect(T LeftCoord, T TopCoord, T RightCoord, T BottomCoord);
Rect(T left, T top, T right, T bottom);
////////////////////////////////////////////////////////////
/// Get the size of the rectangle
@ -79,62 +79,62 @@ public :
////////////////////////////////////////////////////////////
/// Move the whole rectangle by the given offset
///
/// \param OffsetX : Horizontal offset
/// \param OffsetY : Vertical offset
/// \param offsetX : Horizontal offset
/// \param offsetY : Vertical offset
///
////////////////////////////////////////////////////////////
void Offset(T OffsetX, T OffsetY);
void Offset(T offsetX, T offsetY);
////////////////////////////////////////////////////////////
/// Move the whole rectangle by the given offset
///
/// \param Off : Offset to apply to the current position
/// \param offset : Offset to apply to the current position
///
////////////////////////////////////////////////////////////
void Offset(const Vector2<T>& Off);
void Offset(const Vector2<T>& offset);
////////////////////////////////////////////////////////////
/// Check if a point is inside the rectangle's area
///
/// \param X : X coordinate of the point to test
/// \param Y : Y coordinate of the point to test
/// \param x : X coordinate of the point to test
/// \param y : Y coordinate of the point to test
///
/// \return True if the point is inside
///
////////////////////////////////////////////////////////////
bool Contains(T X, T Y) const;
bool Contains(T x, T y) const;
////////////////////////////////////////////////////////////
/// Check if a point is inside the rectangle's area
///
/// \param Point : Point to test
/// \param point : Point to test
///
/// \return True if the point is inside
///
////////////////////////////////////////////////////////////
bool Contains(const Vector2<T>& Point) const;
bool Contains(const Vector2<T>& point) const;
////////////////////////////////////////////////////////////
/// Check intersection between two rectangles
///
/// \param Rectangle : Rectangle to test
/// \param rectangle : Rectangle to test
///
/// \return True if rectangles overlap
///
////////////////////////////////////////////////////////////
bool Intersects(const Rect<T>& Rectangle) const;
bool Intersects(const Rect<T>& rectangle) const;
////////////////////////////////////////////////////////////
/// Check intersection between two rectangles and return the
/// resulting rectangle
///
/// \param Rectangle : Rectangle to test
/// \param OverlappingRect : Rectangle to be filled with the overlapping rect
/// \param rectangle : Rectangle to test
/// \param intersection : Rectangle to be filled with the intersection of both rectangles
///
/// \return True if rectangles overlap
///
////////////////////////////////////////////////////////////
bool Intersects(const Rect<T>& Rectangle, Rect<T>& OverlappingRect) const;
bool Intersects(const Rect<T>& rectangle, Rect<T>& intersection) const;
////////////////////////////////////////////////////////////
// Member data

60
include/SFML/Graphics/Rect.inl
View File

@ -41,11 +41,11 @@ Bottom(0)
/// Construct the color from its coordinates
////////////////////////////////////////////////////////////
template <typename T>
Rect<T>::Rect(T LeftCoord, T TopCoord, T RightCoord, T BottomCoord) :
Left (LeftCoord),
Top (TopCoord),
Right (RightCoord),
Bottom(BottomCoord)
Rect<T>::Rect(T left, T top, T right, T bottom) :
Left (left),
Top (top),
Right (right),
Bottom(bottom)
{
}
@ -75,12 +75,12 @@ Vector2<T> Rect<T>::GetCenter() const
/// Move the whole rectangle by the given offset
////////////////////////////////////////////////////////////
template <typename T>
void Rect<T>::Offset(T OffsetX, T OffsetY)
void Rect<T>::Offset(T offsetX, T offsetY)
{
Left += OffsetX;
Right += OffsetX;
Top += OffsetY;
Bottom += OffsetY;
Left += offsetX;
Right += offsetX;
Top += offsetY;
Bottom += offsetY;
}
@ -88,9 +88,9 @@ void Rect<T>::Offset(T OffsetX, T OffsetY)
/// Move the whole rectangle by the given offset
////////////////////////////////////////////////////////////
template <typename T>
void Rect<T>::Offset(const Vector2<T>& Off)
void Rect<T>::Offset(const Vector2<T>& offset)
{
Offset(Off.x, Off.y);
Offset(offset.x, offset.y);
}
@ -98,9 +98,9 @@ void Rect<T>::Offset(const Vector2<T>& Off)
/// Check if a point is inside the rectangle's area
////////////////////////////////////////////////////////////
template <typename T>
bool Rect<T>::Contains(T X, T Y) const
bool Rect<T>::Contains(T x, T y) const
{
return (X >= Left) && (X <= Right) && (Y >= Top) && (Y <= Bottom);
return (x >= Left) && (x <= Right) && (y >= Top) && (y <= Bottom);
}
@ -108,9 +108,9 @@ bool Rect<T>::Contains(T X, T Y) const
/// Check if a point is inside the rectangle's area
////////////////////////////////////////////////////////////
template <typename T>
bool Rect<T>::Contains(const Vector2<T>& Point) const
bool Rect<T>::Contains(const Vector2<T>& point) const
{
return Contains(Point.x, Point.y);
return Contains(point.x, point.y);
}
@ -118,16 +118,16 @@ bool Rect<T>::Contains(const Vector2<T>& Point) const
/// Check intersection between two rectangles
////////////////////////////////////////////////////////////
template <typename T>
bool Rect<T>::Intersects(const Rect<T>& Rectangle) const
bool Rect<T>::Intersects(const Rect<T>& rectangle) const
{
// Compute overlapping rect
Rect<T> Overlapping(std::max(Left, Rectangle.Left),
std::max(Top, Rectangle.Top),
std::min(Right, Rectangle.Right),
std::min(Bottom, Rectangle.Bottom));
Rect<T> overlapping(std::max(Left, rectangle.Left),
std::max(Top, rectangle.Top),
std::min(Right, rectangle.Right),
std::min(Bottom, rectangle.Bottom));
// If overlapping rect is valid, then there is intersection
return (Overlapping.Left < Overlapping.Right) && (Overlapping.Top < Overlapping.Bottom);
return (overlapping.Left < overlapping.Right) && (overlapping.Top < overlapping.Bottom);
}
@ -136,23 +136,23 @@ bool Rect<T>::Intersects(const Rect<T>& Rectangle) const
/// resulting rectangle
////////////////////////////////////////////////////////////
template <typename T>
bool Rect<T>::Intersects(const Rect<T>& Rectangle, Rect<T>& OverlappingRect) const
bool Rect<T>::Intersects(const Rect<T>& rectangle, Rect<T>& intersection) const
{
// Compute overlapping rect
Rect<T> Overlapping(std::max(Left, Rectangle.Left),
std::max(Top, Rectangle.Top),
std::min(Right, Rectangle.Right),
std::min(Bottom, Rectangle.Bottom));
Rect<T> overlapping(std::max(Left, rectangle.Left),
std::max(Top, rectangle.Top),
std::min(Right, rectangle.Right),
std::min(Bottom, rectangle.Bottom));
// If overlapping rect is valid, then there is intersection
if ((Overlapping.Left < Overlapping.Right) && (Overlapping.Top < Overlapping.Bottom))
if ((overlapping.Left < overlapping.Right) && (overlapping.Top < overlapping.Bottom))
{
OverlappingRect = Overlapping;
intersection = overlapping;
return true;
}
else
{
OverlappingRect = Rect<T>(0, 0, 0, 0);
intersection = Rect<T>(0, 0, 0, 0);
return false;
}
}

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

@ -63,25 +63,25 @@ public :
////////////////////////////////////////////////////////////
/// Create the render image from its dimensions
///
/// \param Width : Width of the render image
/// \param Height : Height of the render image
/// \param DepthBuffer : Do you want a depth buffer attached? (false by default)
/// \param width : Width of the render image
/// \param height : Height of the render image
/// \param depthBuffer : Do you want a depth buffer attached? (false by default)
///
/// \return True if creation has been successful
///
////////////////////////////////////////////////////////////
bool Create(unsigned int Width, unsigned int Height, bool DepthBuffer = false);
bool Create(unsigned int width, unsigned int height, bool depthBuffer = false);
////////////////////////////////////////////////////////////
/// Activate of deactivate the render-image as the current target
/// for rendering
///
/// \param Active : True to activate, false to deactivate (true by default)
/// \param active : True to activate, false to deactivate (true by default)
///
/// \return True if operation was successful, false otherwise
///
////////////////////////////////////////////////////////////
bool SetActive(bool Active = true);
bool SetActive(bool active = true);
////////////////////////////////////////////////////////////
/// Get the width of the rendering region of the image
@ -123,19 +123,19 @@ private :
/// /see RenderTarget::Activate
///
////////////////////////////////////////////////////////////
virtual bool Activate(bool Active);
virtual bool Activate(bool active);
////////////////////////////////////////////////////////////
/// Update the pixels of the target image.
/// This function is called automatically by the image when it
/// needs to update its pixels, and is only meant for internal use.
///
/// \param Target : Target image to update
/// \param target : Target image to update
///
/// \return True if the new pixels are flipped vertically
///
////////////////////////////////////////////////////////////
bool UpdateImage(Image& Target);
bool UpdateImage(Image& target);
////////////////////////////////////////////////////////////
// Member data

20
include/SFML/Graphics/RenderTarget.hpp
View File

@ -53,18 +53,18 @@ public :
////////////////////////////////////////////////////////////
/// Clear the entire target with a single color
///
/// \param FillColor : Color to use to clear the render target
/// \param color : Color to use to clear the render target
///
////////////////////////////////////////////////////////////
void Clear(const Color& FillColor = Color(0, 0, 0));
void Clear(const Color& color = Color(0, 0, 0));
////////////////////////////////////////////////////////////
/// Draw something into the target
///
/// \param Object : Object to draw
/// \param object : Object to draw
///
////////////////////////////////////////////////////////////
virtual void Draw(const Drawable& Object);
virtual void Draw(const Drawable& object);
////////////////////////////////////////////////////////////
/// Get the width of the rendering region of the target
@ -85,10 +85,10 @@ public :
////////////////////////////////////////////////////////////
/// Change the current active view.
///
/// \param NewView : New view to use (pass GetDefaultView() to set the default view)
/// \param view : New view to use (pass GetDefaultView() to set the default view)
///
////////////////////////////////////////////////////////////
void SetView(const View& NewView);
void SetView(const View& view);
////////////////////////////////////////////////////////////
/// Get the current view
@ -114,10 +114,10 @@ public :
/// SFML to do internal optimizations and improve performances.
/// This parameter is false by default
///
/// \param Preserve : True to preserve OpenGL states, false to let SFML optimize
/// \param preserve : True to preserve OpenGL states, false to let SFML optimize
///
////////////////////////////////////////////////////////////
void PreserveOpenGLStates(bool Preserve);
void PreserveOpenGLStates(bool preserve);
protected :
@ -138,12 +138,12 @@ private :
////////////////////////////////////////////////////////////
/// Activate the target for rendering
///
/// \param Active : True to activate rendering, false to deactivate
/// \param active : True to activate rendering, false to deactivate
///
/// \return True if activation succeeded
///
////////////////////////////////////////////////////////////
virtual bool Activate(bool Active) = 0;
virtual bool Activate(bool active) = 0;
////////////////////////////////////////////////////////////
/// Set the OpenGL render states needed for the SFML rendering

Some files were not shown because too many files have changed in this diff Show More