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

Fixed linker errors in sfml-network and csfml-network

Browse Source 
Made every read-only pointer "const" in CSFML

git-svn-id: https://sfml.svn.sourceforge.net/svnroot/sfml/branches/sfml2@1290 4e206d99-4929-0410-ac5d-dfc041789085
This commit is contained in:
LaurentGom 2009-11-26 20:09:57 +00:00
parent 29ecc552c2
commit d979ca254e
62 changed files with 438 additions and 429 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CSFML/build/VC2005/csfml-network.vcproj
View File

@ -64,7 +64,7 @@
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="sfml-network-s-d.lib"
AdditionalDependencies="sfml-network-s-d.lib sfml-system-s-d.lib"
OutputFile="$(SolutionDir)..\..\lib\vc2005\$(ProjectName)-d.dll"
LinkIncremental="2"
AdditionalLibraryDirectories="$(SolutionDir)..\..\..\lib\vc2005\"
@ -149,7 +149,7 @@
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="sfml-network-s.lib"
AdditionalDependencies="sfml-network-s.lib sfml-system-s.lib"
OutputFile="$(SolutionDir)..\..\lib\vc2005\$(ProjectName).dll"
LinkIncremental="1"
AdditionalLibraryDirectories="$(SolutionDir)..\..\..\lib\vc2005\"

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

@ -65,7 +65,7 @@
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="sfml-network-s-d.lib"
AdditionalDependencies="sfml-network-s-d.lib sfml-system-s-d.lib"
OutputFile="$(SolutionDir)..\..\lib\vc2008\$(ProjectName)-d.dll"
LinkIncremental="2"
AdditionalLibraryDirectories="$(SolutionDir)..\..\..\lib\vc2008\"
@ -149,7 +149,7 @@
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="sfml-network-s.lib"
AdditionalDependencies="sfml-network-s.lib sfml-system-s.lib"
OutputFile="$(SolutionDir)..\..\lib\vc2008\$(ProjectName).dll"
LinkIncremental="1"
AdditionalLibraryDirectories="$(SolutionDir)..\..\..\lib\vc2008\"

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

@ -79,7 +79,7 @@ CSFML_API void sfMusic_SetLoop(sfMusic* music, sfBool loop);
/// \return sfTrue if the music is looping, sfFalse otherwise
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfMusic_GetLoop(sfMusic* music);
CSFML_API sfBool sfMusic_GetLoop(const sfMusic* music);
////////////////////////////////////////////////////////////
/// Get a music duration
@ -89,7 +89,7 @@ CSFML_API sfBool sfMusic_GetLoop(sfMusic* music);
/// \return Music duration, in seconds
///
////////////////////////////////////////////////////////////
CSFML_API float sfMusic_GetDuration(sfMusic* music);
CSFML_API float sfMusic_GetDuration(const sfMusic* music);
////////////////////////////////////////////////////////////
/// Start playing a music
@ -123,7 +123,7 @@ CSFML_API void sfMusic_Stop(sfMusic* music);
/// \return Number of channels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfMusic_GetChannelsCount(sfMusic* music);
CSFML_API unsigned int sfMusic_GetChannelsCount(const sfMusic* music);
////////////////////////////////////////////////////////////
/// Get the stream sample rate of a music
@ -133,7 +133,7 @@ CSFML_API unsigned int sfMusic_GetChannelsCount(sfMusic* music);
/// \return Stream frequency (number of samples per second)
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfMusic_GetSampleRate(sfMusic* music);
CSFML_API unsigned int sfMusic_GetSampleRate(const sfMusic* music);
////////////////////////////////////////////////////////////
/// Get the status of a music (stopped, paused, playing)
@ -143,7 +143,7 @@ CSFML_API unsigned int sfMusic_GetSampleRate(sfMusic* music);
/// \return Current status of the sound
///
////////////////////////////////////////////////////////////
CSFML_API sfSoundStatus sfMusic_GetStatus(sfMusic* music);
CSFML_API sfSoundStatus sfMusic_GetStatus(const sfMusic* music);
////////////////////////////////////////////////////////////
/// Get the current playing position of a music
@ -153,7 +153,7 @@ CSFML_API sfSoundStatus sfMusic_GetStatus(sfMusic* music);
/// \return Current playing position, expressed in seconds
///
////////////////////////////////////////////////////////////
CSFML_API float sfMusic_GetPlayingOffset(sfMusic* music);
CSFML_API float sfMusic_GetPlayingOffset(const sfMusic* music);
////////////////////////////////////////////////////////////
/// Set the pitch of a music
@ -234,7 +234,7 @@ CSFML_API void sfMusic_SetPlayingOffset(sfMusic* music, float timeOffset);
/// \return Pitch value
///
////////////////////////////////////////////////////////////
CSFML_API float sfMusic_GetPitch(sfMusic* music);
CSFML_API float sfMusic_GetPitch(const sfMusic* music);
////////////////////////////////////////////////////////////
/// Get the volume of a music
@ -244,7 +244,7 @@ CSFML_API float sfMusic_GetPitch(sfMusic* music);
/// \return Volume value (in range [1, 100])
///
////////////////////////////////////////////////////////////
CSFML_API float sfMusic_GetVolume(sfMusic* music);
CSFML_API float sfMusic_GetVolume(const sfMusic* music);
////////////////////////////////////////////////////////////
/// Get the position of a music
@ -255,7 +255,7 @@ CSFML_API float sfMusic_GetVolume(sfMusic* music);
/// \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(const sfMusic* music, float* x, float* y, float* z);
////////////////////////////////////////////////////////////
/// Tell if the music's position is relative to the listener's
@ -266,7 +266,7 @@ CSFML_API void sfMusic_GetPosition(sfMusic* music, float* x, float* y, float* z)
/// \return sfTrue if the position is relative, sfFalse if it's absolute
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfMusic_IsRelativeToListener(sfMusic* music);
CSFML_API sfBool sfMusic_IsRelativeToListener(const sfMusic* music);
////////////////////////////////////////////////////////////
/// Get the minimum distance of a music
@ -276,7 +276,7 @@ CSFML_API sfBool sfMusic_IsRelativeToListener(sfMusic* music);
/// \return Minimum distance for the music
///
////////////////////////////////////////////////////////////
CSFML_API float sfMusic_GetMinDistance(sfMusic* music);
CSFML_API float sfMusic_GetMinDistance(const sfMusic* music);
////////////////////////////////////////////////////////////
/// Get the attenuation factor of a music
@ -286,7 +286,7 @@ CSFML_API float sfMusic_GetMinDistance(sfMusic* music);
/// \return Attenuation factor for the a music
///
////////////////////////////////////////////////////////////
CSFML_API float sfMusic_GetAttenuation(sfMusic* music);
CSFML_API float sfMusic_GetAttenuation(const sfMusic* music);
#endif // SFML_MUSIC_H

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

@ -80,7 +80,7 @@ CSFML_API void sfSound_Stop(sfSound* sound);
/// \param buffer : Buffer to bind
///
////////////////////////////////////////////////////////////
CSFML_API void sfSound_SetBuffer(sfSound* sound, sfSoundBuffer* buffer);
CSFML_API void sfSound_SetBuffer(sfSound* sound, const sfSoundBuffer* buffer);
////////////////////////////////////////////////////////////
/// Get the sound buffer bound to a sound
@ -90,7 +90,7 @@ CSFML_API void sfSound_SetBuffer(sfSound* sound, sfSoundBuffer* buffer);
/// \return Pointer to the sound's buffer
///
////////////////////////////////////////////////////////////
CSFML_API sfSoundBuffer* sfSound_GetBuffer(sfSound* sound);
CSFML_API const sfSoundBuffer* sfSound_GetBuffer(const sfSound* sound);
////////////////////////////////////////////////////////////
/// Set a sound loop state
@ -109,7 +109,7 @@ CSFML_API void sfSound_SetLoop(sfSound* sound, sfBool loop);
/// \return sfTrue if the sound is looping, sfFalse otherwise
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfSound_GetLoop(sfSound* sound);
CSFML_API sfBool sfSound_GetLoop(const sfSound* sound);
////////////////////////////////////////////////////////////
/// Get the status of a sound (stopped, paused, playing)
@ -119,7 +119,7 @@ CSFML_API sfBool sfSound_GetLoop(sfSound* sound);
/// \return Current status of the sound
///
////////////////////////////////////////////////////////////
CSFML_API sfSoundStatus sfSound_GetStatus(sfSound* sound);
CSFML_API sfSoundStatus sfSound_GetStatus(const sfSound* sound);
////////////////////////////////////////////////////////////
/// Set the pitch of a sound
@ -200,7 +200,7 @@ CSFML_API void sfSound_SetPlayingOffset(sfSound* sound, float timeOffset);
/// \return Pitch value
///
////////////////////////////////////////////////////////////
CSFML_API float sfSound_GetPitch(sfSound* sound);
CSFML_API float sfSound_GetPitch(const sfSound* sound);
////////////////////////////////////////////////////////////
/// Get the volume of a sound
@ -210,7 +210,7 @@ CSFML_API float sfSound_GetPitch(sfSound* sound);
/// \return Volume value (in range [1, 100])
///
////////////////////////////////////////////////////////////
CSFML_API float sfSound_GetVolume(sfSound* sound);
CSFML_API float sfSound_GetVolume(const sfSound* sound);
////////////////////////////////////////////////////////////
/// Get the position of a sound
@ -221,7 +221,7 @@ CSFML_API float sfSound_GetVolume(sfSound* sound);
/// \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(const sfSound* sound, float* x, float* y, float* z);
////////////////////////////////////////////////////////////
/// Tell if the sound's position is relative to the listener's
@ -232,7 +232,7 @@ CSFML_API void sfSound_GetPosition(sfSound* sound, float* x, float* y, float* z)
/// \return sfTrue if the position is relative, sfFalse if it's absolute
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfSound_IsRelativeToListener(sfSound* sound);
CSFML_API sfBool sfSound_IsRelativeToListener(const sfSound* sound);
////////////////////////////////////////////////////////////
/// Get the minimum distance of a sound
@ -242,7 +242,7 @@ CSFML_API sfBool sfSound_IsRelativeToListener(sfSound* sound);
/// \return Minimum distance for the sound
///
////////////////////////////////////////////////////////////
CSFML_API float sfSound_GetMinDistance(sfSound* sound);
CSFML_API float sfSound_GetMinDistance(const sfSound* sound);
////////////////////////////////////////////////////////////
/// Get the attenuation factor of a sound
@ -252,7 +252,7 @@ CSFML_API float sfSound_GetMinDistance(sfSound* sound);
/// \return Attenuation factor for the sound
///
////////////////////////////////////////////////////////////
CSFML_API float sfSound_GetAttenuation(sfSound* sound);
CSFML_API float sfSound_GetAttenuation(const sfSound* sound);
////////////////////////////////////////////////////////////
/// Get the current playing position of a sound
@ -262,7 +262,7 @@ CSFML_API float sfSound_GetAttenuation(sfSound* sound);
/// \return Current playing position, expressed in seconds
///
////////////////////////////////////////////////////////////
CSFML_API float sfSound_GetPlayingOffset(sfSound* sound);
CSFML_API float sfSound_GetPlayingOffset(const sfSound* sound);
#endif // SFML_SOUND_H

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

@ -85,7 +85,7 @@ CSFML_API void sfSoundBuffer_Destroy(sfSoundBuffer* soundBuffer);
/// \return sfTrue if saving has been successful
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfSoundBuffer_SaveToFile(sfSoundBuffer* soundBuffer, const char* filename);
CSFML_API sfBool sfSoundBuffer_SaveToFile(const sfSoundBuffer* soundBuffer, const char* filename);
////////////////////////////////////////////////////////////
/// Return the samples contained in a sound buffer
@ -95,7 +95,7 @@ CSFML_API sfBool sfSoundBuffer_SaveToFile(sfSoundBuffer* soundBuffer, const char
/// \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(const sfSoundBuffer* soundBuffer);
////////////////////////////////////////////////////////////
/// Return the number of samples contained in a sound buffer
@ -105,7 +105,7 @@ CSFML_API const sfInt16* sfSoundBuffer_GetSamples(sfSoundBuffer* soundBuffer);
/// \return Number of samples
///
////////////////////////////////////////////////////////////
CSFML_API size_t sfSoundBuffer_GetSamplesCount(sfSoundBuffer* soundBuffer);
CSFML_API size_t sfSoundBuffer_GetSamplesCount(const sfSoundBuffer* soundBuffer);
////////////////////////////////////////////////////////////
/// Get the sample rate of a sound buffer
@ -115,7 +115,7 @@ CSFML_API size_t sfSoundBuffer_GetSamplesCount(sfSoundBuffer* soundBuffer);
/// \return Sound frequency (number of samples per second)
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfSoundBuffer_GetSampleRate(sfSoundBuffer* soundBuffer);
CSFML_API unsigned int sfSoundBuffer_GetSampleRate(const sfSoundBuffer* soundBuffer);
////////////////////////////////////////////////////////////
/// Return the number of channels of a sound buffer (1 = mono, 2 = stereo, ...)
@ -125,7 +125,7 @@ CSFML_API unsigned int sfSoundBuffer_GetSampleRate(sfSoundBuffer* soundBuffer);
/// \return Number of channels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfSoundBuffer_GetChannelsCount(sfSoundBuffer* soundBuffer);
CSFML_API unsigned int sfSoundBuffer_GetChannelsCount(const sfSoundBuffer* soundBuffer);
////////////////////////////////////////////////////////////
/// Get the duration of a sound buffer
@ -135,7 +135,7 @@ CSFML_API unsigned int sfSoundBuffer_GetChannelsCount(sfSoundBuffer* soundBuffer
/// \return Sound duration, in seconds
///
////////////////////////////////////////////////////////////
CSFML_API float sfSoundBuffer_GetDuration(sfSoundBuffer* soundBuffer);
CSFML_API float sfSoundBuffer_GetDuration(const sfSoundBuffer* soundBuffer);
#endif // SFML_SOUNDBUFFER_H

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

@ -74,7 +74,7 @@ CSFML_API void sfSoundBufferRecorder_Stop(sfSoundBufferRecorder* soundBufferReco
/// \return Frequency, in samples per second
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfSoundBufferRecorder_GetSampleRate(sfSoundBufferRecorder* soundBufferRecorder);
CSFML_API unsigned int sfSoundBufferRecorder_GetSampleRate(const sfSoundBufferRecorder* soundBufferRecorder);
////////////////////////////////////////////////////////////
/// Get the sound buffer containing the captured audio data
@ -85,7 +85,7 @@ CSFML_API unsigned int sfSoundBufferRecorder_GetSampleRate(sfSoundBufferRecorder
/// \return Pointer to the sound buffer (you don't need to destroy it after use)
///
////////////////////////////////////////////////////////////
CSFML_API sfSoundBuffer* sfSoundBufferRecorder_GetBuffer(sfSoundBufferRecorder* soundBufferRecorder);
CSFML_API const sfSoundBuffer* sfSoundBufferRecorder_GetBuffer(const sfSoundBufferRecorder* soundBufferRecorder);
#endif // SFML_SOUNDBUFFERRECORDER_H

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

@ -88,7 +88,7 @@ CSFML_API void sfSoundRecorder_Stop(sfSoundRecorder* soundRecorder);
/// \return Frequency, in samples per second
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfSoundRecorder_GetSampleRate(sfSoundRecorder* soundRecorder);
CSFML_API unsigned int sfSoundRecorder_GetSampleRate(const sfSoundRecorder* soundRecorder);
////////////////////////////////////////////////////////////
/// Tell if the system supports sound capture.

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

@ -105,7 +105,7 @@ CSFML_API void sfSoundStream_Stop(sfSoundStream* soundStream);
/// \return Current status of the sound stream
///
////////////////////////////////////////////////////////////
CSFML_API sfSoundStatus sfSoundStream_GetStatus(sfSoundStream* soundStream);
CSFML_API sfSoundStatus sfSoundStream_GetStatus(const sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Return the number of channels of a sound stream
@ -116,7 +116,7 @@ CSFML_API sfSoundStatus sfSoundStream_GetStatus(sfSoundStream* soundStream);
/// \return Number of channels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfSoundStream_GetChannelsCount(sfSoundStream* soundStream);
CSFML_API unsigned int sfSoundStream_GetChannelsCount(const sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Get the sample rate of a sound stream
@ -126,7 +126,7 @@ CSFML_API unsigned int sfSoundStream_GetChannelsCount(sfSoundStream* soundStream
/// \return Stream frequency (number of samples per second)
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfSoundStream_GetSampleRate(sfSoundStream* soundStream);
CSFML_API unsigned int sfSoundStream_GetSampleRate(const sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Set the pitch of a sound stream
@ -216,7 +216,7 @@ CSFML_API void sfSoundStream_SetLoop(sfSoundStream* soundStream, sfBool loop);
/// \return Pitch value
///
////////////////////////////////////////////////////////////
CSFML_API float sfSoundStream_GetPitch(sfSoundStream* soundStream);
CSFML_API float sfSoundStream_GetPitch(const sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Get the volume of a sound stream
@ -226,7 +226,7 @@ CSFML_API float sfSoundStream_GetPitch(sfSoundStream* soundStream);
/// \return Volume value (in range [1, 100])
///
////////////////////////////////////////////////////////////
CSFML_API float sfSoundStream_GetVolume(sfSoundStream* soundStream);
CSFML_API float sfSoundStream_GetVolume(const sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Get the position of a sound stream
@ -237,7 +237,7 @@ CSFML_API float sfSoundStream_GetVolume(sfSoundStream* soundStream);
/// \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(const sfSoundStream* soundStream, float* x, float* y, float* z);
////////////////////////////////////////////////////////////
/// Tell if the sound stream's position is relative to the listener's
@ -248,7 +248,7 @@ CSFML_API void sfSoundStream_GetPosition(sfSoundStream* soundStream, float* x, f
/// \return sfTrue if the position is relative, sfFalse if it's absolute
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfSoundStream_IsRelativeToListener(sfSoundStream* soundStream);
CSFML_API sfBool sfSoundStream_IsRelativeToListener(const sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Get the minimum distance of a sound stream
@ -258,7 +258,7 @@ CSFML_API sfBool sfSoundStream_IsRelativeToListener(sfSoundStream* soundStream);
/// \return Minimum distance for the sound stream
///
////////////////////////////////////////////////////////////
CSFML_API float sfSoundStream_GetMinDistance(sfSoundStream* soundStream);
CSFML_API float sfSoundStream_GetMinDistance(const sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Get the attenuation factor of a sound stream
@ -268,7 +268,7 @@ CSFML_API float sfSoundStream_GetMinDistance(sfSoundStream* soundStream);
/// \return Attenuation factor for the sound stream
///
////////////////////////////////////////////////////////////
CSFML_API float sfSoundStream_GetAttenuation(sfSoundStream* soundStream);
CSFML_API float sfSoundStream_GetAttenuation(const sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Tell whether or not a stream is looping
@ -278,7 +278,7 @@ CSFML_API float sfSoundStream_GetAttenuation(sfSoundStream* soundStream);
/// \return sfTrue if the stream is looping, sfFalse otherwise
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfSoundStream_GetLoop(sfSoundStream* soundStream);
CSFML_API sfBool sfSoundStream_GetLoop(const sfSoundStream* soundStream);
////////////////////////////////////////////////////////////
/// Get the current playing position of a sound stream
@ -288,7 +288,7 @@ CSFML_API sfBool sfSoundStream_GetLoop(sfSoundStream* soundStream);
/// \return Current playing position, expressed in seconds
///
////////////////////////////////////////////////////////////
CSFML_API float sfSoundStream_GetPlayingOffset(sfSoundStream* soundStream);
CSFML_API float sfSoundStream_GetPlayingOffset(const sfSoundStream* soundStream);
#endif // SFML_SOUNDSTREAM_H

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

@ -82,7 +82,7 @@ CSFML_API void sfFont_Destroy(sfFont* font);
/// \return Base size of characters
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfFont_GetCharacterSize(sfFont* font);
CSFML_API unsigned int sfFont_GetCharacterSize(const sfFont* font);
////////////////////////////////////////////////////////////
/// Get the built-in default font (Arial)
@ -90,7 +90,7 @@ CSFML_API unsigned int sfFont_GetCharacterSize(sfFont* font);
/// \return Pointer to the default font
///
////////////////////////////////////////////////////////////
CSFML_API sfFont* sfFont_GetDefaultFont();
CSFML_API const sfFont* sfFont_GetDefaultFont();
#endif // SFML_IMAGE_H

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

@ -104,7 +104,7 @@ CSFML_API void sfImage_Destroy(sfImage* image);
/// \return sfTrue if saving was successful
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfImage_SaveToFile(sfImage* image, const char* filename);
CSFML_API sfBool sfImage_SaveToFile(const sfImage* image, const char* filename);
////////////////////////////////////////////////////////////
/// Create a transparency mask for an image from a specified colorkey
@ -128,7 +128,7 @@ CSFML_API void sfImage_CreateMaskFromColor(sfImage* image, sfColor colorKey, sfU
/// \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, const sfImage* source, unsigned int destX, unsigned int destY, sfIntRect sourceRect);
////////////////////////////////////////////////////////////
/// Create the image from the current contents of the
@ -165,7 +165,7 @@ CSFML_API void sfImage_SetPixel(sfImage* image, unsigned int x, unsigned int y,
/// \return Color of pixel (x, y)
///
////////////////////////////////////////////////////////////
CSFML_API sfColor sfImage_GetPixel(sfImage* image, unsigned int x, unsigned int y);
CSFML_API sfColor sfImage_GetPixel(const 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)
@ -177,7 +177,7 @@ CSFML_API sfColor sfImage_GetPixel(sfImage* image, unsigned int x, unsigned int
/// \return Pointer to the array of pixels
///
////////////////////////////////////////////////////////////
CSFML_API const sfUint8* sfImage_GetPixelsPtr(sfImage* image);
CSFML_API const sfUint8* sfImage_GetPixelsPtr(const sfImage* image);
////////////////////////////////////////////////////////////
/// Bind the image for rendering
@ -185,7 +185,7 @@ CSFML_API const sfUint8* sfImage_GetPixelsPtr(sfImage* image);
/// \param image : Image to bind
///
////////////////////////////////////////////////////////////
CSFML_API void sfImage_Bind(sfImage* image);
CSFML_API void sfImage_Bind(const sfImage* image);
////////////////////////////////////////////////////////////
/// Enable or disable image smooth filter
@ -204,7 +204,7 @@ CSFML_API void sfImage_SetSmooth(sfImage* image, sfBool smooth);
/// \return Width in pixels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfImage_GetWidth(sfImage* image);
CSFML_API unsigned int sfImage_GetWidth(const sfImage* image);
////////////////////////////////////////////////////////////
/// Return the height of the image
@ -214,7 +214,7 @@ CSFML_API unsigned int sfImage_GetWidth(sfImage* image);
/// \return Height in pixels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfImage_GetHeight(sfImage* image);
CSFML_API unsigned int sfImage_GetHeight(const sfImage* image);
////////////////////////////////////////////////////////////
/// Tells whether the smoothing filter is enabled or not on an image
@ -224,7 +224,7 @@ CSFML_API unsigned int sfImage_GetHeight(sfImage* image);
/// \return sfTrue if the smoothing filter is enabled
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfImage_IsSmooth(sfImage* image);
CSFML_API sfBool sfImage_IsSmooth(const sfImage* image);
#endif // SFML_IMAGE_H

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

@ -73,8 +73,8 @@ CSFML_API void sfIntRect_Offset(sfIntRect* rect, int offsetX, int offsetY);
/// \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(const sfFloatRect* rect, float x, float y);
CSFML_API sfBool sfIntRect_Contains(const sfIntRect* rect, int x, int y);
////////////////////////////////////////////////////////////
/// Check intersection between two rectangles
@ -86,8 +86,8 @@ CSFML_API sfBool sfIntRect_Contains(sfIntRect* rect, int x, int y);
/// \return sfTrue if rectangles overlap
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfFloatRect_Intersects(sfFloatRect* rect1, sfFloatRect* rect2, sfFloatRect* intersection);
CSFML_API sfBool sfIntRect_Intersects(sfIntRect* rect1, sfIntRect* rect2, sfIntRect* intersection);
CSFML_API sfBool sfFloatRect_Intersects(const sfFloatRect* rect1, const sfFloatRect* rect2, sfFloatRect* intersection);
CSFML_API sfBool sfIntRect_Intersects(const sfIntRect* rect1, const sfIntRect* rect2, sfIntRect* intersection);
#endif // SFML_RECT_H

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

@ -60,7 +60,7 @@ CSFML_API void sfRenderImage_Destroy(sfRenderImage* renderImage);
/// \return Width in pixels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfRenderImage_GetWidth(sfRenderImage* renderImage);
CSFML_API unsigned int sfRenderImage_GetWidth(const sfRenderImage* renderImage);
////////////////////////////////////////////////////////////
/// Get the height of the rendering region of a renderimage
@ -70,7 +70,7 @@ CSFML_API unsigned int sfRenderImage_GetWidth(sfRenderImage* renderImage);
/// \return Height in pixels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfRenderImage_GetHeight(sfRenderImage* renderImage);
CSFML_API unsigned int sfRenderImage_GetHeight(const sfRenderImage* renderImage);
////////////////////////////////////////////////////////////
/// Activate or deactivate a renderimage as the current target for rendering
@ -116,9 +116,9 @@ CSFML_API void sfRenderImage_Display(sfRenderImage* renderImage);
/// \param sprite / text / shape : Object to draw
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderImage_DrawSprite(sfRenderImage* renderImage, sfSprite* sprite);
CSFML_API void sfRenderImage_DrawShape (sfRenderImage* renderImage, sfShape* shape);
CSFML_API void sfRenderImage_DrawText (sfRenderImage* renderImage, sfText* text);
CSFML_API void sfRenderImage_DrawSprite(sfRenderImage* renderImage, const sfSprite* sprite);
CSFML_API void sfRenderImage_DrawShape (sfRenderImage* renderImage, const sfShape* shape);
CSFML_API void sfRenderImage_DrawText (sfRenderImage* renderImage, const sfText* text);
////////////////////////////////////////////////////////////
/// Draw something on a renderimage with a shader
@ -128,9 +128,9 @@ CSFML_API void sfRenderImage_DrawText (sfRenderImage* renderImage, sfText* te
/// \param shader : Shader to use
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderImage_DrawSpriteWithShader(sfRenderImage* renderImage, sfSprite* sprite, sfShader* shader);
CSFML_API void sfRenderImage_DrawShapeWithShader (sfRenderImage* renderImage, sfShape* shape, sfShader* shader);
CSFML_API void sfRenderImage_DrawTextWithShader (sfRenderImage* renderImage, sfText* text, sfShader* shader);
CSFML_API void sfRenderImage_DrawSpriteWithShader(sfRenderImage* renderImage, const sfSprite* sprite, const sfShader* shader);
CSFML_API void sfRenderImage_DrawShapeWithShader (sfRenderImage* renderImage, const sfShape* shape, const sfShader* shader);
CSFML_API void sfRenderImage_DrawTextWithShader (sfRenderImage* renderImage, const sfText* text, const sfShader* shader);
////////////////////////////////////////////////////////////
/// Clear the renderimage with the given color
@ -148,7 +148,7 @@ CSFML_API void sfRenderImage_Clear(sfRenderImage* renderImage, sfColor color);
/// \param view : Pointer to the new view
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderImage_SetView(sfRenderImage* renderImage, sfView* view);
CSFML_API void sfRenderImage_SetView(sfRenderImage* renderImage, const sfView* view);
////////////////////////////////////////////////////////////
/// Get the current active view of a renderimage
@ -158,7 +158,7 @@ CSFML_API void sfRenderImage_SetView(sfRenderImage* renderImage, sfView* view);
/// \return Current active view
///
////////////////////////////////////////////////////////////
CSFML_API const sfView* sfRenderImage_GetView(sfRenderImage* renderImage);
CSFML_API const sfView* sfRenderImage_GetView(const sfRenderImage* renderImage);
////////////////////////////////////////////////////////////
/// Get the default view of a renderimage
@ -179,7 +179,7 @@ CSFML_API sfView* sfRenderImage_GetDefaultView(sfRenderImage* renderImage);
/// \return Viewport rectangle, expressed in pixels in the current target
///
////////////////////////////////////////////////////////////
CSFML_API sfIntRect sfRenderImage_GetViewport(sfRenderImage* renderImage, sfView* view);
CSFML_API sfIntRect sfRenderImage_GetViewport(const sfRenderImage* renderImage, const sfView* view);
////////////////////////////////////////////////////////////
/// Convert a point in image coordinates into view coordinates
@ -192,7 +192,7 @@ CSFML_API sfIntRect sfRenderImage_GetViewport(sfRenderImage* renderImage, sfView
/// \param targetView : Target view to convert the point to (pass NULL to use the current view)
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderImage_ConvertCoords(sfRenderImage* renderImage, unsigned int windowX, unsigned int windowY, float* viewX, float* viewY, sfView* targetView);
CSFML_API void sfRenderImage_ConvertCoords(const sfRenderImage* renderImage, unsigned int windowX, unsigned int windowY, float* viewX, float* viewY, const sfView* targetView);
////////////////////////////////////////////////////////////
/// Get the target image
@ -202,7 +202,7 @@ CSFML_API void sfRenderImage_ConvertCoords(sfRenderImage* renderImage, unsigned
/// \return Pointer to the target image
///
////////////////////////////////////////////////////////////
CSFML_API sfImage* sfRenderImage_GetImage(sfRenderImage* renderImage);
CSFML_API const sfImage* sfRenderImage_GetImage(const sfRenderImage* renderImage);
////////////////////////////////////////////////////////////
/// Check whether the system supports render images or not

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

@ -47,7 +47,7 @@
/// \param settings : Creation settings (pass NULL to use default values)
///
////////////////////////////////////////////////////////////
CSFML_API sfRenderWindow* sfRenderWindow_Create(sfVideoMode mode, const char* title, unsigned long style, sfContextSettings* settings);
CSFML_API sfRenderWindow* sfRenderWindow_Create(sfVideoMode mode, const char* title, unsigned long style, const sfContextSettings* settings);
////////////////////////////////////////////////////////////
/// Construct a renderwindow from an existing control
@ -56,7 +56,7 @@ CSFML_API sfRenderWindow* sfRenderWindow_Create(sfVideoMode mode, const char* ti
/// \param settings : Creation settings (pass NULL to use default values)
///
////////////////////////////////////////////////////////////
CSFML_API sfRenderWindow* sfRenderWindow_CreateFromHandle(sfWindowHandle handle, sfContextSettings* settings);
CSFML_API sfRenderWindow* sfRenderWindow_CreateFromHandle(sfWindowHandle handle, const sfContextSettings* settings);
////////////////////////////////////////////////////////////
/// Destroy an existing renderwindow
@ -80,7 +80,7 @@ CSFML_API void sfRenderWindow_Close(sfRenderWindow* renderWindow);
/// \param renderWindow : Renderwindow object
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfRenderWindow_IsOpened(sfRenderWindow* renderWindow);
CSFML_API sfBool sfRenderWindow_IsOpened(const sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Get the width of the rendering region of a window
@ -90,7 +90,7 @@ CSFML_API sfBool sfRenderWindow_IsOpened(sfRenderWindow* renderWindow);
/// \return Width in pixels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfRenderWindow_GetWidth(sfRenderWindow* renderWindow);
CSFML_API unsigned int sfRenderWindow_GetWidth(const sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Get the height of the rendering region of a window
@ -100,7 +100,7 @@ CSFML_API unsigned int sfRenderWindow_GetWidth(sfRenderWindow* renderWindow);
/// \return Height in pixels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfRenderWindow_GetHeight(sfRenderWindow* renderWindow);
CSFML_API unsigned int sfRenderWindow_GetHeight(const sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Get the creation settings of a window
@ -110,7 +110,7 @@ CSFML_API unsigned int sfRenderWindow_GetHeight(sfRenderWindow* renderWindow);
/// \return Settings used to create the window
///
////////////////////////////////////////////////////////////
CSFML_API sfContextSettings sfRenderWindow_GetSettings(sfRenderWindow* renderWindow);
CSFML_API sfContextSettings sfRenderWindow_GetSettings(const sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Get the event on top of events stack of a window, if any, and pop it
@ -211,7 +211,7 @@ CSFML_API void sfRenderWindow_EnableKeyRepeat(sfRenderWindow* renderWindow, sfBo
/// \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, const sfUint8* pixels);
////////////////////////////////////////////////////////////
/// Activate or deactivate a window as the current target for rendering
@ -258,7 +258,7 @@ CSFML_API void sfRenderWindow_Display(sfRenderWindow* renderWindow);
/// \return Reference to the input
///
////////////////////////////////////////////////////////////
CSFML_API sfInput* sfRenderWindow_GetInput(sfRenderWindow* renderWindow);
CSFML_API const sfInput* sfRenderWindow_GetInput(const sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Limit the framerate to a maximum fixed frequency for a window
@ -277,7 +277,7 @@ CSFML_API void sfRenderWindow_SetFramerateLimit(sfRenderWindow* renderWindow, un
/// \return Time elapsed, in seconds
///
////////////////////////////////////////////////////////////
CSFML_API float sfRenderWindow_GetFrameTime(sfRenderWindow* renderWindow);
CSFML_API float sfRenderWindow_GetFrameTime(const sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Change the joystick threshold, ie. the value below which
@ -296,9 +296,9 @@ CSFML_API void sfRenderWindow_SetJoystickThreshold(sfRenderWindow* renderWindow,
/// \param sprite / text / shape : Object to draw
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_DrawSprite(sfRenderWindow* renderWindow, sfSprite* sprite);
CSFML_API void sfRenderWindow_DrawShape (sfRenderWindow* renderWindow, sfShape* shape);
CSFML_API void sfRenderWindow_DrawText (sfRenderWindow* renderWindow, sfText* text);
CSFML_API void sfRenderWindow_DrawSprite(sfRenderWindow* renderWindow, const sfSprite* sprite);
CSFML_API void sfRenderWindow_DrawShape (sfRenderWindow* renderWindow, const sfShape* shape);
CSFML_API void sfRenderWindow_DrawText (sfRenderWindow* renderWindow, const sfText* text);
////////////////////////////////////////////////////////////
/// Draw something on a renderwindow with a shader
@ -308,9 +308,9 @@ CSFML_API void sfRenderWindow_DrawText (sfRenderWindow* renderWindow, sfText*
/// \param shader : Shader to use
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_DrawSpriteWithShader(sfRenderWindow* renderWindow, sfSprite* sprite, sfShader* shader);
CSFML_API void sfRenderWindow_DrawShapeWithShader (sfRenderWindow* renderWindow, sfShape* shape, sfShader* shader);
CSFML_API void sfRenderWindow_DrawTextWithShader (sfRenderWindow* renderWindow, sfText* text, sfShader* shader);
CSFML_API void sfRenderWindow_DrawSpriteWithShader(sfRenderWindow* renderWindow, const sfSprite* sprite, const sfShader* shader);
CSFML_API void sfRenderWindow_DrawShapeWithShader (sfRenderWindow* renderWindow, const sfShape* shape, const sfShader* shader);
CSFML_API void sfRenderWindow_DrawTextWithShader (sfRenderWindow* renderWindow, const sfText* text, const sfShader* shader);
////////////////////////////////////////////////////////////
/// Clear the screen with the given color
@ -328,7 +328,7 @@ CSFML_API void sfRenderWindow_Clear(sfRenderWindow* renderWindow, sfColor color)
/// \param view : Pointer to the new view
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_SetView(sfRenderWindow* renderWindow, sfView* view);
CSFML_API void sfRenderWindow_SetView(sfRenderWindow* renderWindow, const sfView* view);
////////////////////////////////////////////////////////////
/// Get the current active view of a renderwindow
@ -338,7 +338,7 @@ CSFML_API void sfRenderWindow_SetView(sfRenderWindow* renderWindow, sfView* view
/// \return Current active view
///
////////////////////////////////////////////////////////////
CSFML_API const sfView* sfRenderWindow_GetView(sfRenderWindow* renderWindow);
CSFML_API const sfView* sfRenderWindow_GetView(const sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Get the default view of a renderwindow
@ -359,7 +359,7 @@ CSFML_API sfView* sfRenderWindow_GetDefaultView(sfRenderWindow* renderWindow);
/// \return Viewport rectangle, expressed in pixels in the current target
///
////////////////////////////////////////////////////////////
CSFML_API sfIntRect sfRenderWindow_GetViewport(sfRenderWindow* renderWindow, sfView* view);
CSFML_API sfIntRect sfRenderWindow_GetViewport(const sfRenderWindow* renderWindow, const sfView* view);
////////////////////////////////////////////////////////////
/// Convert a point in window coordinates into view coordinates
@ -372,7 +372,7 @@ CSFML_API sfIntRect sfRenderWindow_GetViewport(sfRenderWindow* renderWindow, sfV
/// \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(const sfRenderWindow* renderWindow, unsigned int windowX, unsigned int windowY, float* viewX, float* viewY, const sfView* targetView);
#endif // SFML_RENDERWINDOW_H

8
CSFML/include/SFML/Graphics/Shader.h
View File

@ -40,7 +40,7 @@
/// \return A new sfShader object, or NULL if it failed
///
////////////////////////////////////////////////////////////
CSFML_API sfShader* sfShader_CreateFromFile(const char* Filename);
CSFML_API sfShader* sfShader_CreateFromFile(const char* filename);
////////////////////////////////////////////////////////////
/// Create a new shader from an effect source code
@ -108,7 +108,7 @@ CSFML_API void sfShader_SetParameter4(sfShader* shader, const char* name, float
/// \param texture : Image to set (pass NULL to use the texture of the object being drawn)
///
////////////////////////////////////////////////////////////
CSFML_API void sfShader_SetTexture(sfShader* shader, const char* name, sfImage* texture);
CSFML_API void sfShader_SetTexture(sfShader* shader, const char* name, const sfImage* texture);
////////////////////////////////////////////////////////////
/// Bind a shader for rendering
@ -116,7 +116,7 @@ CSFML_API void sfShader_SetTexture(sfShader* shader, const char* name, sfImage*
/// \param shader : Shader to bind
///
////////////////////////////////////////////////////////////
CSFML_API void sfShader_Bind(sfShader* shader);
CSFML_API void sfShader_Bind(const sfShader* shader);
////////////////////////////////////////////////////////////
/// Unbind a shader
@ -124,7 +124,7 @@ CSFML_API void sfShader_Bind(sfShader* shader);
/// \param shader : Shader to unbind
///
////////////////////////////////////////////////////////////
CSFML_API void sfShader_Unbind(sfShader* shader);
CSFML_API void sfShader_Unbind(const sfShader* shader);
////////////////////////////////////////////////////////////
/// Tell whether or not the system supports shaders

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

@ -189,7 +189,7 @@ CSFML_API void sfShape_SetBlendMode(sfShape* shape, sfBlendMode mode);
/// \return Current X position
///
////////////////////////////////////////////////////////////
CSFML_API float sfShape_GetX(sfShape* shape);
CSFML_API float sfShape_GetX(const sfShape* shape);
////////////////////////////////////////////////////////////
/// Get the Y position of a shape
@ -199,7 +199,7 @@ CSFML_API float sfShape_GetX(sfShape* shape);
/// \return Current Y position
///
////////////////////////////////////////////////////////////
CSFML_API float sfShape_GetY(sfShape* shape);
CSFML_API float sfShape_GetY(const sfShape* shape);
////////////////////////////////////////////////////////////
/// Get the horizontal scale of a shape
@ -209,7 +209,7 @@ CSFML_API float sfShape_GetY(sfShape* shape);
/// \return Current X scale factor (always positive)
///
////////////////////////////////////////////////////////////
CSFML_API float sfShape_GetScaleX(sfShape* shape);
CSFML_API float sfShape_GetScaleX(const sfShape* shape);
////////////////////////////////////////////////////////////
/// Get the vertical scale of a shape
@ -219,7 +219,7 @@ CSFML_API float sfShape_GetScaleX(sfShape* shape);
/// \return Current Y scale factor (always positive)
///
////////////////////////////////////////////////////////////
CSFML_API float sfShape_GetScaleY(sfShape* shape);
CSFML_API float sfShape_GetScaleY(const sfShape* shape);
////////////////////////////////////////////////////////////
/// Get the orientation of a shape
@ -229,7 +229,7 @@ CSFML_API float sfShape_GetScaleY(sfShape* shape);
/// \return Current rotation, in degrees
///
////////////////////////////////////////////////////////////
CSFML_API float sfShape_GetRotation(sfShape* shape);
CSFML_API float sfShape_GetRotation(const sfShape* shape);
////////////////////////////////////////////////////////////
/// Get the X position of the origin a shape
@ -239,7 +239,7 @@ CSFML_API float sfShape_GetRotation(sfShape* shape);
/// \return Current X origin
///
////////////////////////////////////////////////////////////
CSFML_API float sfShape_GetOriginX(sfShape* shape);
CSFML_API float sfShape_GetOriginX(const sfShape* shape);
////////////////////////////////////////////////////////////
/// Get the Y position of the origin a shape
@ -249,7 +249,7 @@ CSFML_API float sfShape_GetOriginX(sfShape* shape);
/// \return Current Y origin
///
////////////////////////////////////////////////////////////
CSFML_API float sfShape_GetOriginY(sfShape* shape);
CSFML_API float sfShape_GetOriginY(const sfShape* shape);
////////////////////////////////////////////////////////////
/// Get the color of a shape
@ -259,7 +259,7 @@ CSFML_API float sfShape_GetOriginY(sfShape* shape);
/// \return Current color
///
////////////////////////////////////////////////////////////
CSFML_API sfColor sfShape_GetColor(sfShape* shape);
CSFML_API sfColor sfShape_GetColor(const sfShape* shape);
////////////////////////////////////////////////////////////
/// Get the current blending mode of a shape
@ -269,7 +269,7 @@ CSFML_API sfColor sfShape_GetColor(sfShape* shape);
/// \return Current blending mode
///
////////////////////////////////////////////////////////////
CSFML_API sfBlendMode sfShape_GetBlendMode(sfShape* shape);
CSFML_API sfBlendMode sfShape_GetBlendMode(const sfShape* shape);
////////////////////////////////////////////////////////////
/// Move a shape
@ -311,7 +311,7 @@ CSFML_API void sfShape_Rotate(sfShape* shape, float angle);
/// \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(const sfShape* shape, float pointX, float pointY, float* x, float* y);
////////////////////////////////////////////////////////////
/// Transform a point from the shape's local coordinates into global coordinates
@ -324,7 +324,7 @@ CSFML_API void sfShape_TransformToLocal(sfShape* shape, float pointX, float poin
/// \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(const sfShape* shape, float pointX, float pointY, float* x, float* y);
////////////////////////////////////////////////////////////
/// Add a point to a shape
@ -374,7 +374,7 @@ CSFML_API void sfShape_SetOutlineWidth(sfShape* shape, float width);
/// \param return Current outline width
///
////////////////////////////////////////////////////////////
CSFML_API float sfShape_GetOutlineWidth(sfShape* shape);
CSFML_API float sfShape_GetOutlineWidth(const sfShape* shape);
////////////////////////////////////////////////////////////
/// Get the number of points composing a shape
@ -384,7 +384,7 @@ CSFML_API float sfShape_GetOutlineWidth(sfShape* shape);
/// \return Total number of points
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfShape_GetNbPoints(sfShape* shape);
CSFML_API unsigned int sfShape_GetNbPoints(const sfShape* shape);
////////////////////////////////////////////////////////////
/// Get a the position of a shape's point
@ -395,7 +395,7 @@ CSFML_API unsigned int sfShape_GetNbPoints(sfShape* shape);
/// \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(const sfShape* shape, unsigned int index, float* x, float* y);
////////////////////////////////////////////////////////////
/// Get a the color of a shape's point
@ -406,7 +406,7 @@ CSFML_API void sfShape_GetPointPosition(sfShape* shape, unsigned int index, floa
/// \return Color of the point
///
////////////////////////////////////////////////////////////
CSFML_API sfColor sfShape_GetPointColor(sfShape* shape, unsigned int index);
CSFML_API sfColor sfShape_GetPointColor(const sfShape* shape, unsigned int index);
////////////////////////////////////////////////////////////
/// Get a the outline color of a shape's point
@ -417,7 +417,7 @@ CSFML_API sfColor sfShape_GetPointColor(sfShape* shape, unsigned int index);
/// \return Outline color of the point
///
////////////////////////////////////////////////////////////
CSFML_API sfColor sfShape_GetPointOutlineColor(sfShape* shape, unsigned int index);
CSFML_API sfColor sfShape_GetPointOutlineColor(const sfShape* shape, unsigned int index);
////////////////////////////////////////////////////////////
/// Set a the position of a shape's point

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

@ -153,7 +153,7 @@ CSFML_API void sfSprite_SetBlendMode(sfSprite* sprite, sfBlendMode mode);
/// \return Current X position
///
////////////////////////////////////////////////////////////
CSFML_API float sfSprite_GetX(sfSprite* sprite);
CSFML_API float sfSprite_GetX(const sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get the Y position of a sprite
@ -163,7 +163,7 @@ CSFML_API float sfSprite_GetX(sfSprite* sprite);
/// \return Current Y position
///
////////////////////////////////////////////////////////////
CSFML_API float sfSprite_GetY(sfSprite* sprite);
CSFML_API float sfSprite_GetY(const sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get the horizontal scale of a sprite
@ -173,7 +173,7 @@ CSFML_API float sfSprite_GetY(sfSprite* sprite);
/// \return Current X scale factor (always positive)
///
////////////////////////////////////////////////////////////
CSFML_API float sfSprite_GetScaleX(sfSprite* sprite);
CSFML_API float sfSprite_GetScaleX(const sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get the vertical scale of a sprite
@ -183,7 +183,7 @@ CSFML_API float sfSprite_GetScaleX(sfSprite* sprite);
/// \return Current Y scale factor (always positive)
///
////////////////////////////////////////////////////////////
CSFML_API float sfSprite_GetScaleY(sfSprite* sprite);
CSFML_API float sfSprite_GetScaleY(const sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get the orientation of a sprite
@ -193,7 +193,7 @@ CSFML_API float sfSprite_GetScaleY(sfSprite* sprite);
/// \return Current rotation, in degrees
///
////////////////////////////////////////////////////////////
CSFML_API float sfSprite_GetRotation(sfSprite* sprite);
CSFML_API float sfSprite_GetRotation(const sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get the X position of the origin a sprite
@ -203,7 +203,7 @@ CSFML_API float sfSprite_GetRotation(sfSprite* sprite);
/// \return Current X origin
///
////////////////////////////////////////////////////////////
CSFML_API float sfSprite_GetOriginX(sfSprite* sprite);
CSFML_API float sfSprite_GetOriginX(const sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get the Y position of the origin a sprite
@ -213,7 +213,7 @@ CSFML_API float sfSprite_GetOriginX(sfSprite* sprite);
/// \return Current Y origin
///
////////////////////////////////////////////////////////////
CSFML_API float sfSprite_GetOriginY(sfSprite* sprite);
CSFML_API float sfSprite_GetOriginY(const sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get the color of a sprite
@ -223,7 +223,7 @@ CSFML_API float sfSprite_GetOriginY(sfSprite* sprite);
/// \return Current color
///
////////////////////////////////////////////////////////////
CSFML_API sfColor sfSprite_GetColor(sfSprite* sprite);
CSFML_API sfColor sfSprite_GetColor(const sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get the current blending mode of a sprite
@ -233,7 +233,7 @@ CSFML_API sfColor sfSprite_GetColor(sfSprite* sprite);
/// \return Current blending mode
///
////////////////////////////////////////////////////////////
CSFML_API sfBlendMode sfSprite_GetBlendMode(sfSprite* sprite);
CSFML_API sfBlendMode sfSprite_GetBlendMode(const sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Move a sprite
@ -275,7 +275,7 @@ CSFML_API void sfSprite_Rotate(sfSprite* sprite, float angle);
/// \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(const sfSprite* sprite, float pointX, float pointY, float* x, float* y);
////////////////////////////////////////////////////////////
/// Transform a point from the sprite's local coordinates into global coordinates
@ -288,7 +288,7 @@ CSFML_API void sfSprite_TransformToLocal(sfSprite* sprite, float pointX, float p
/// \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(const sfSprite* sprite, float pointX, float pointY, float* x, float* y);
////////////////////////////////////////////////////////////
/// Change the image of a sprite
@ -297,7 +297,7 @@ CSFML_API void sfSprite_TransformToGlobal(sfSprite* sprite, float pointX, float
/// \param image : New image
///
////////////////////////////////////////////////////////////
CSFML_API void sfSprite_SetImage(sfSprite* sprite, sfImage* image);
CSFML_API void sfSprite_SetImage(sfSprite* sprite, const sfImage* image);
////////////////////////////////////////////////////////////
/// Set the sub-rectangle of a sprite inside the source image
@ -344,7 +344,7 @@ CSFML_API void sfSprite_FlipY(sfSprite* sprite, sfBool flipped);
/// \return Pointer to the image (can be NULL)
///
////////////////////////////////////////////////////////////
CSFML_API sfImage* sfSprite_GetImage(sfSprite* sprite);
CSFML_API const sfImage* sfSprite_GetImage(const sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get the sub-rectangle of a sprite inside the source image
@ -354,7 +354,7 @@ CSFML_API sfImage* sfSprite_GetImage(sfSprite* sprite);
/// \return Sub-rectangle
///
////////////////////////////////////////////////////////////
CSFML_API sfIntRect sfSprite_GetSubRect(sfSprite* sprite);
CSFML_API sfIntRect sfSprite_GetSubRect(const sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get a sprite width
@ -364,7 +364,7 @@ CSFML_API sfIntRect sfSprite_GetSubRect(sfSprite* sprite);
/// \return Width of the sprite
///
////////////////////////////////////////////////////////////
CSFML_API float sfSprite_GetWidth(sfSprite* sprite);
CSFML_API float sfSprite_GetWidth(const sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get a sprite height
@ -374,7 +374,7 @@ CSFML_API float sfSprite_GetWidth(sfSprite* sprite);
/// \return Height of the sprite
///
////////////////////////////////////////////////////////////
CSFML_API float sfSprite_GetHeight(sfSprite* sprite);
CSFML_API float sfSprite_GetHeight(const sfSprite* sprite);
////////////////////////////////////////////////////////////
/// Get the color of a given pixel in a sprite
@ -386,7 +386,7 @@ CSFML_API float sfSprite_GetHeight(sfSprite* sprite);
/// \return Color of pixel (X, Y)
///
////////////////////////////////////////////////////////////
CSFML_API sfColor sfSprite_GetPixel(sfSprite* sprite, unsigned int x, unsigned int y);
CSFML_API sfColor sfSprite_GetPixel(const sfSprite* sprite, unsigned int x, unsigned int y);
#endif // SFML_SPRITE_H

38
CSFML/include/SFML/Graphics/Text.h
View File

@ -165,7 +165,7 @@ CSFML_API void sfText_SetBlendMode(sfText* text, sfBlendMode mode);
/// \return Current X position
///
////////////////////////////////////////////////////////////
CSFML_API float sfText_GetX(sfText* text);
CSFML_API float sfText_GetX(const sfText* text);
////////////////////////////////////////////////////////////
/// Get the top Y of a text
@ -175,7 +175,7 @@ CSFML_API float sfText_GetX(sfText* text);
/// \return Current Y position
///
////////////////////////////////////////////////////////////
CSFML_API float sfText_GetY(sfText* text);
CSFML_API float sfText_GetY(const sfText* text);
////////////////////////////////////////////////////////////
/// Get the horizontal scale of a text
@ -185,7 +185,7 @@ CSFML_API float sfText_GetY(sfText* text);
/// \return Current X scale factor (always positive)
///
////////////////////////////////////////////////////////////
CSFML_API float sfText_GetScaleX(sfText* text);
CSFML_API float sfText_GetScaleX(const sfText* text);
////////////////////////////////////////////////////////////
/// Get the vertical scale of a text
@ -195,7 +195,7 @@ CSFML_API float sfText_GetScaleX(sfText* text);
/// \return Current Y scale factor (always positive)
///
////////////////////////////////////////////////////////////
CSFML_API float sfText_GetScaleY(sfText* text);
CSFML_API float sfText_GetScaleY(const sfText* text);
////////////////////////////////////////////////////////////
/// Get the orientation of a text
@ -205,7 +205,7 @@ CSFML_API float sfText_GetScaleY(sfText* text);
/// \return Current rotation, in degrees
///
////////////////////////////////////////////////////////////
CSFML_API float sfText_GetRotation(sfText* text);
CSFML_API float sfText_GetRotation(const sfText* text);
////////////////////////////////////////////////////////////
/// Get the X position of the origin a text
@ -215,7 +215,7 @@ CSFML_API float sfText_GetRotation(sfText* text);
/// \return Current X origin position
///
////////////////////////////////////////////////////////////
CSFML_API float sfText_GetOriginX(sfText* text);
CSFML_API float sfText_GetOriginX(const sfText* text);
////////////////////////////////////////////////////////////
/// Get the top Y of the origin of a text
@ -225,7 +225,7 @@ CSFML_API float sfText_GetOriginX(sfText* text);
/// \return Current Y origin position
///
////////////////////////////////////////////////////////////
CSFML_API float sfText_GetOriginY(sfText* text);
CSFML_API float sfText_GetOriginY(const sfText* text);
////////////////////////////////////////////////////////////
/// Get the color of a text
@ -235,7 +235,7 @@ CSFML_API float sfText_GetOriginY(sfText* text);
/// \return Current color
///
////////////////////////////////////////////////////////////
CSFML_API sfColor sfText_GetColor(sfText* text);
CSFML_API sfColor sfText_GetColor(const sfText* text);
////////////////////////////////////////////////////////////
/// Get the current blending mode of a text
@ -245,7 +245,7 @@ CSFML_API sfColor sfText_GetColor(sfText* text);
/// \return Current blending mode
///
////////////////////////////////////////////////////////////
CSFML_API sfBlendMode sfText_GetBlendMode(sfText* text);
CSFML_API sfBlendMode sfText_GetBlendMode(const sfText* text);
////////////////////////////////////////////////////////////
/// Move a text
@ -287,7 +287,7 @@ CSFML_API void sfText_Rotate(sfText* text, float angle);
/// \param y : Value to fill with the y coordinate of the converted point
///
////////////////////////////////////////////////////////////
CSFML_API void sfText_TransformToLocal(sfText* text, float pointX, float pointY, float* x, float* y);
CSFML_API void sfText_TransformToLocal(const sfText* text, float pointX, float pointY, float* x, float* y);
////////////////////////////////////////////////////////////
/// Transform a point from the string's local coordinates into global coordinates
@ -300,7 +300,7 @@ CSFML_API void sfText_TransformToLocal(sfText* text, float pointX, float pointY,
/// \param y : Value to fill with the y coordinate of the converted point
///
////////////////////////////////////////////////////////////
CSFML_API void sfText_TransformToGlobal(sfText* text, float pointX, float pointY, float* X, float* y);
CSFML_API void sfText_TransformToGlobal(const sfText* text, float pointX, float pointY, float* X, float* y);
////////////////////////////////////////////////////////////
/// Set the string of a text (from a multibyte string)
@ -327,7 +327,7 @@ CSFML_API void sfText_SetUnicodeString(sfText* text, const sfUint32* string);
/// \param font : Font to use
///
////////////////////////////////////////////////////////////
CSFML_API void sfText_SetFont(sfText* text, sfFont* font);
CSFML_API void sfText_SetFont(sfText* text, const sfFont* font);
////////////////////////////////////////////////////////////
/// Set the size of a text
@ -355,7 +355,7 @@ CSFML_API void sfText_SetStyle(sfText* text, unsigned long style);
/// \return String as UTF-32
///
////////////////////////////////////////////////////////////
CSFML_API const sfUint32* sfText_GetUnicodeString(sfText* text);
CSFML_API const sfUint32* sfText_GetUnicodeString(const sfText* text);
////////////////////////////////////////////////////////////
/// Get the text of a text (returns an ANSI string)
@ -365,7 +365,7 @@ CSFML_API const sfUint32* sfText_GetUnicodeString(sfText* text);
/// \return String an a locale-dependant ANSI string
///
////////////////////////////////////////////////////////////
CSFML_API const char* sfText_GetString(sfText* text);
CSFML_API const char* sfText_GetString(const sfText* text);
////////////////////////////////////////////////////////////
/// Get the font used by a text
@ -375,7 +375,7 @@ CSFML_API const char* sfText_GetString(sfText* text);
/// \return Pointer to the font
///
////////////////////////////////////////////////////////////
CSFML_API sfFont* sfText_GetFont(sfText* text);
CSFML_API const sfFont* sfText_GetFont(const sfText* text);
////////////////////////////////////////////////////////////
/// Get the size of the characters of a text
@ -385,7 +385,7 @@ CSFML_API sfFont* sfText_GetFont(sfText* text);
/// \return Size of the characters
///
////////////////////////////////////////////////////////////
CSFML_API float sfText_GetSize(sfText* text);
CSFML_API float sfText_GetSize(const sfText* text);
////////////////////////////////////////////////////////////
/// Get the style of a text
@ -395,7 +395,7 @@ CSFML_API float sfText_GetSize(sfText* text);
/// \return Current string style (see sfTextStyle enum)
///
////////////////////////////////////////////////////////////
CSFML_API unsigned long sfText_GetStyle(sfText* text);
CSFML_API unsigned long sfText_GetStyle(const sfText* text);
////////////////////////////////////////////////////////////
/// Return the visual position of the Index-th character of the text,
@ -408,7 +408,7 @@ CSFML_API unsigned long sfText_GetStyle(sfText* text);
/// \param y : Value to fill with the y coordinate of the position
///
////////////////////////////////////////////////////////////
CSFML_API void sfText_GetCharacterPos(sfText* text, size_t index, float* x, float* y);
CSFML_API void sfText_GetCharacterPos(const sfText* text, size_t index, float* x, float* y);
////////////////////////////////////////////////////////////
/// Get the bounding rectangle of a text on screen
@ -418,7 +418,7 @@ CSFML_API void sfText_GetCharacterPos(sfText* text, size_t index, float* x, floa
/// \return Rectangle contaning the string in screen coordinates
///
////////////////////////////////////////////////////////////
CSFML_API sfFloatRect sfText_GetRect(sfText* text);
CSFML_API sfFloatRect sfText_GetRect(const sfText* text);
#endif // SFML_TEXT_H

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

@ -115,7 +115,7 @@ CSFML_API void sfView_Reset(sfView* view, sfFloatRect rectangle);
/// \return X coordinate of the center of the view
///
////////////////////////////////////////////////////////////
CSFML_API float sfView_GetCenterX(sfView* view);
CSFML_API float sfView_GetCenterX(const sfView* view);
////////////////////////////////////////////////////////////
/// Get the Y coordinate of the center of a view
@ -125,7 +125,7 @@ CSFML_API float sfView_GetCenterX(sfView* view);
/// \return Y coordinate of the center of the view
///
////////////////////////////////////////////////////////////
CSFML_API float sfView_GetCenterY(sfView* view);
CSFML_API float sfView_GetCenterY(const sfView* view);
////////////////////////////////////////////////////////////
/// Get the width of the view
@ -135,7 +135,7 @@ CSFML_API float sfView_GetCenterY(sfView* view);
/// \return Width of the view
///
////////////////////////////////////////////////////////////
CSFML_API float sfView_GetWidth(sfView* view);
CSFML_API float sfView_GetWidth(const sfView* view);
////////////////////////////////////////////////////////////
/// Get the height of the view
@ -145,7 +145,7 @@ CSFML_API float sfView_GetWidth(sfView* view);
/// \return Height of the view
///
////////////////////////////////////////////////////////////
CSFML_API float sfView_GetHeight(sfView* view);
CSFML_API float sfView_GetHeight(const sfView* view);
////////////////////////////////////////////////////////////
/// Get the current rotation of a view
@ -155,7 +155,7 @@ CSFML_API float sfView_GetHeight(sfView* view);
/// \return Rotation of the view, in degrees
///
////////////////////////////////////////////////////////////
CSFML_API float sfView_GetRotation(sfView* view);
CSFML_API float sfView_GetRotation(const sfView* view);
////////////////////////////////////////////////////////////
/// Get the target viewport of a view
@ -165,7 +165,7 @@ CSFML_API float sfView_GetRotation(sfView* view);
/// \return Viewport rectangle, expressed as a factor of the target size
///
////////////////////////////////////////////////////////////
CSFML_API sfFloatRect sfView_GetViewport(sfView* view);
CSFML_API sfFloatRect sfView_GetViewport(const sfView* view);
////////////////////////////////////////////////////////////
/// Move a view

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

@ -128,7 +128,7 @@ CSFML_API void sfFtpListingResponse_Destroy(sfFtpListingResponse* ftpListingResp
/// \return sfTrue if status is success (code < 400)
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfFtpListingResponse_IsOk(sfFtpListingResponse* ftpListingResponse);
CSFML_API sfBool sfFtpListingResponse_IsOk(const sfFtpListingResponse* ftpListingResponse);
////////////////////////////////////////////////////////////
/// Get the response status code
@ -138,7 +138,7 @@ CSFML_API sfBool sfFtpListingResponse_IsOk(sfFtpListingResponse* ftpListingRespo
/// \return Status code
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpStatus sfFtpListingResponse_GetStatus(sfFtpListingResponse* ftpListingResponse);
CSFML_API sfFtpStatus sfFtpListingResponse_GetStatus(const sfFtpListingResponse* ftpListingResponse);
////////////////////////////////////////////////////////////
/// Get the full message contained in the response
@ -148,7 +148,7 @@ CSFML_API sfFtpStatus sfFtpListingResponse_GetStatus(sfFtpListingResponse* ftpLi
/// \return The response message
///
////////////////////////////////////////////////////////////
CSFML_API const char* sfFtpListingResponse_GetMessage(sfFtpListingResponse* ftpListingResponse);
CSFML_API const char* sfFtpListingResponse_GetMessage(const sfFtpListingResponse* ftpListingResponse);
////////////////////////////////////////////////////////////
/// Get the number of filenames in the listing
@ -158,7 +158,7 @@ CSFML_API const char* sfFtpListingResponse_GetMessage(sfFtpListingResponse* ftpL
/// \return Total number of filenames
///
////////////////////////////////////////////////////////////
CSFML_API size_t sfFtpListingResponse_GetCount(sfFtpListingResponse* ftpListingResponse);
CSFML_API size_t sfFtpListingResponse_GetCount(const sfFtpListingResponse* ftpListingResponse);
////////////////////////////////////////////////////////////
/// Get the Index-th filename in the directory
@ -169,7 +169,7 @@ CSFML_API size_t sfFtpListingResponse_GetCount(sfFtpListingResponse* ftpListingR
/// \return Index-th filename
///
////////////////////////////////////////////////////////////
CSFML_API const char* sfFtpListingResponse_GetFilename(sfFtpListingResponse* ftpListingResponse, size_t index);
CSFML_API const char* sfFtpListingResponse_GetFilename(const sfFtpListingResponse* ftpListingResponse, size_t index);
////////////////////////////////////////////////////////////
/// Destroy an existing Ftp directory response
@ -188,7 +188,7 @@ CSFML_API void sfFtpDirectoryResponse_Destroy(sfFtpDirectoryResponse* ftpDirecto
/// \return sfTrue if status is success (code < 400)
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfFtpDirectoryResponse_IsOk(sfFtpDirectoryResponse* ftpDirectoryResponse);
CSFML_API sfBool sfFtpDirectoryResponse_IsOk(const sfFtpDirectoryResponse* ftpDirectoryResponse);
////////////////////////////////////////////////////////////
/// Get the response status code
@ -198,7 +198,7 @@ CSFML_API sfBool sfFtpDirectoryResponse_IsOk(sfFtpDirectoryResponse* ftpDirector
/// \return Status code
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpStatus sfFtpDirectoryResponse_GetStatus(sfFtpDirectoryResponse* ftpDirectoryResponse);
CSFML_API sfFtpStatus sfFtpDirectoryResponse_GetStatus(const sfFtpDirectoryResponse* ftpDirectoryResponse);
////////////////////////////////////////////////////////////
/// Get the full message contained in the response
@ -208,7 +208,7 @@ CSFML_API sfFtpStatus sfFtpDirectoryResponse_GetStatus(sfFtpDirectoryResponse* f
/// \return The response message
///
////////////////////////////////////////////////////////////
CSFML_API const char* sfFtpDirectoryResponse_GetMessage(sfFtpDirectoryResponse* ftpDirectoryResponse);
CSFML_API const char* sfFtpDirectoryResponse_GetMessage(const sfFtpDirectoryResponse* ftpDirectoryResponse);
////////////////////////////////////////////////////////////
/// Get the directory returned in the response
@ -218,7 +218,7 @@ CSFML_API const char* sfFtpDirectoryResponse_GetMessage(sfFtpDirectoryResponse*
/// \return Directory name
///
////////////////////////////////////////////////////////////
CSFML_API const char* sfFtpDirectoryResponse_GetDirectory(sfFtpDirectoryResponse* ftpDirectoryResponse);
CSFML_API const char* sfFtpDirectoryResponse_GetDirectory(const sfFtpDirectoryResponse* ftpDirectoryResponse);
////////////////////////////////////////////////////////////
@ -238,7 +238,7 @@ CSFML_API void sfFtpResponse_Destroy(sfFtpResponse* ftpResponse);
/// \return sfTrue if status is success (code < 400)
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfFtpResponse_IsOk(sfFtpResponse* ftpResponse);
CSFML_API sfBool sfFtpResponse_IsOk(const sfFtpResponse* ftpResponse);
////////////////////////////////////////////////////////////
/// Get the response status code
@ -248,7 +248,7 @@ CSFML_API sfBool sfFtpResponse_IsOk(sfFtpResponse* ftpResponse);
/// \return Status code
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpStatus sfFtpResponse_GetStatus(sfFtpResponse* ftpResponse);
CSFML_API sfFtpStatus sfFtpResponse_GetStatus(const sfFtpResponse* ftpResponse);
////////////////////////////////////////////////////////////
/// Get the full message contained in the response
@ -258,7 +258,7 @@ CSFML_API sfFtpStatus sfFtpResponse_GetStatus(sfFtpResponse* ftpResponse);
/// \return The response message
///
////////////////////////////////////////////////////////////
CSFML_API const char* sfFtpResponse_GetMessage(sfFtpResponse* ftpResponse);
CSFML_API const char* sfFtpResponse_GetMessage(const sfFtpResponse* ftpResponse);
////////////////////////////////////////////////////////////
/// Construct a new Ftp

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

@ -164,7 +164,7 @@ CSFML_API void sfHttpResponse_Destroy(sfHttpResponse* httpResponse);
/// \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(const sfHttpResponse* httpResponse, const char* field);
////////////////////////////////////////////////////////////
/// Get the status of a response
@ -174,7 +174,7 @@ CSFML_API const char* sfHttpResponse_GetField(sfHttpResponse* httpResponse, cons
/// \return Status of the response
///
////////////////////////////////////////////////////////////
CSFML_API sfHttpStatus sfHttpResponse_GetStatus(sfHttpResponse* httpResponse);
CSFML_API sfHttpStatus sfHttpResponse_GetStatus(const sfHttpResponse* httpResponse);
////////////////////////////////////////////////////////////
/// Get the major HTTP version of a response
@ -184,7 +184,7 @@ CSFML_API sfHttpStatus sfHttpResponse_GetStatus(sfHttpResponse* httpResponse);
/// \return HTTP major version of the response
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfHttpResponse_GetMajorVersion(sfHttpResponse* httpResponse);
CSFML_API unsigned int sfHttpResponse_GetMajorVersion(const sfHttpResponse* httpResponse);
////////////////////////////////////////////////////////////
/// Get the minor HTTP version of a response
@ -194,7 +194,7 @@ CSFML_API unsigned int sfHttpResponse_GetMajorVersion(sfHttpResponse* httpRespon
/// \return HTTP minor version of the response
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfHttpResponse_GetMinorVersion(sfHttpResponse* httpResponse);
CSFML_API unsigned int sfHttpResponse_GetMinorVersion(const sfHttpResponse* httpResponse);
////////////////////////////////////////////////////////////
/// Get the body of the response. The body can contain :
@ -208,7 +208,7 @@ CSFML_API unsigned int sfHttpResponse_GetMinorVersion(sfHttpResponse* httpRespon
/// \return Body of the response (empty string if no body)
///
////////////////////////////////////////////////////////////
CSFML_API const char* sfHttpResponse_GetBody(sfHttpResponse* httpResponse);
CSFML_API const char* sfHttpResponse_GetBody(const sfHttpResponse* httpResponse);
////////////////////////////////////////////////////////////
/// Construct a new Http object
@ -251,7 +251,7 @@ CSFML_API void sfHttp_SetHost(sfHttp* http, const char* host, unsigned short por
/// \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, const sfHttpRequest* request, float timeout);
#endif // SFML_HTTP_H

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

@ -56,7 +56,7 @@ CSFML_API void sfPacket_Destroy(sfPacket* packet);
/// \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, const void* data, size_t sizeInBytes);
////////////////////////////////////////////////////////////
/// Clear all the data of a packet
@ -76,7 +76,7 @@ CSFML_API void sfPacket_Clear(sfPacket* packet);
/// \return Pointer to the data
///
////////////////////////////////////////////////////////////
CSFML_API const char* sfPacket_GetData(sfPacket* packet);
CSFML_API const char* sfPacket_GetData(const sfPacket* packet);
////////////////////////////////////////////////////////////
/// Get the size of the data contained in a packet
@ -86,7 +86,7 @@ CSFML_API const char* sfPacket_GetData(sfPacket* packet);
/// \return Data size, in bytes
///
////////////////////////////////////////////////////////////
CSFML_API size_t sfPacket_GetDataSize(sfPacket* packet);
CSFML_API size_t sfPacket_GetDataSize(const sfPacket* packet);
////////////////////////////////////////////////////////////
/// Tell if the reading position has reached the end of the packet
@ -96,7 +96,7 @@ CSFML_API size_t sfPacket_GetDataSize(sfPacket* packet);
/// \return sfTrue if all data have been read into the packet
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfPacket_EndOfPacket(sfPacket* packet);
CSFML_API sfBool sfPacket_EndOfPacket(const sfPacket* packet);
////////////////////////////////////////////////////////////
/// Return the validity of packet
@ -106,7 +106,7 @@ CSFML_API sfBool sfPacket_EndOfPacket(sfPacket* packet);
/// \return sfTrue if last data extraction from packet was successful
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfPacket_CanRead(sfPacket* packet);
CSFML_API sfBool sfPacket_CanRead(const sfPacket* packet);
////////////////////////////////////////////////////////////
/// Functions to extract data from a packet

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

@ -104,8 +104,8 @@ CSFML_API unsigned int sfSelectorUDP_Wait(sfSelectorUDP* selector, float timeout
/// \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(const sfSelectorTCP* selector, unsigned int index);
CSFML_API sfSocketUDP* sfSelectorUDP_GetSocketReady(const sfSelectorUDP* selector, unsigned int index);
#endif // SFML_SELECTOR_H

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

@ -164,7 +164,7 @@ CSFML_API sfBool sfSocketTCP_Close(sfSocketTCP* socket);
/// \return True if the socket is valid
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfSocketTCP_IsValid(sfSocketTCP* socket);
CSFML_API sfBool sfSocketTCP_IsValid(const sfSocketTCP* socket);
#endif // SFML_SOCKETTCP_H

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

@ -54,7 +54,7 @@ CSFML_API void sfClock_Destroy(sfClock* clock);
/// \param clock : Clock to get time from
///
////////////////////////////////////////////////////////////
CSFML_API float sfClock_GetTime(sfClock* clock);
CSFML_API float sfClock_GetTime(const sfClock* clock);
////////////////////////////////////////////////////////////
/// Restart a clock

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

@ -41,7 +41,7 @@
/// \return sfTrue if key is down, sfFalse if key is up
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfInput_IsKeyDown(sfInput* input, sfKeyCode code);
CSFML_API sfBool sfInput_IsKeyDown(const sfInput* input, sfKeyCode code);
////////////////////////////////////////////////////////////
/// Get the state of a mouse button
@ -52,7 +52,7 @@ CSFML_API sfBool sfInput_IsKeyDown(sfInput* input, sfKeyCode code);
/// \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(const sfInput* input, sfMouseButton button);
////////////////////////////////////////////////////////////
/// Get the state of a joystick button
@ -64,7 +64,7 @@ CSFML_API sfBool sfInput_IsMouseButtonDown(sfInput* input, sfMouseButton button)
/// \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(const sfInput* input, unsigned int joyId, unsigned int button);
////////////////////////////////////////////////////////////
/// Get the mouse X position
@ -74,7 +74,7 @@ CSFML_API sfBool sfInput_IsJoystickButtonDown(sfInput* input, unsigned int joyId
/// \return Current mouse left position, relative to owner window
///
////////////////////////////////////////////////////////////
CSFML_API int sfInput_GetMouseX(sfInput* input);
CSFML_API int sfInput_GetMouseX(const sfInput* input);
////////////////////////////////////////////////////////////
/// Get the mouse Y position
@ -84,7 +84,7 @@ CSFML_API int sfInput_GetMouseX(sfInput* input);
/// \return Current mouse top position, relative to owner window
///
////////////////////////////////////////////////////////////
CSFML_API int sfInput_GetMouseY(sfInput* input);
CSFML_API int sfInput_GetMouseY(const sfInput* input);
////////////////////////////////////////////////////////////
/// Get the joystick position on a given axis
@ -96,7 +96,7 @@ CSFML_API int sfInput_GetMouseY(sfInput* input);
/// \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(const sfInput* input, unsigned int joyId, sfJoyAxis axis);
#endif // SFML_INPUT_H

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

@ -71,7 +71,7 @@ typedef struct
/// \param settings : Creation settings (pass NULL to use default values)
///
////////////////////////////////////////////////////////////
CSFML_API sfWindow* sfWindow_Create(sfVideoMode mode, const char* title, unsigned long style, sfContextSettings* settings);
CSFML_API sfWindow* sfWindow_Create(sfVideoMode mode, const char* title, unsigned long style, const sfContextSettings* settings);
////////////////////////////////////////////////////////////
/// Construct a window from an existing control
@ -80,7 +80,7 @@ CSFML_API sfWindow* sfWindow_Create(sfVideoMode mode, const char* title, unsigne
/// \param settings : Creation settings (pass NULL to use default values)
///
////////////////////////////////////////////////////////////
CSFML_API sfWindow* sfWindow_CreateFromHandle(sfWindowHandle handle, sfContextSettings* settings);
CSFML_API sfWindow* sfWindow_CreateFromHandle(sfWindowHandle handle, const sfContextSettings* settings);
////////////////////////////////////////////////////////////
/// Destroy an existing window
@ -104,7 +104,7 @@ CSFML_API void sfWindow_Close(sfWindow* window);
/// \param window : Window object
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfWindow_IsOpened(sfWindow* window);
CSFML_API sfBool sfWindow_IsOpened(const sfWindow* window);
////////////////////////////////////////////////////////////
/// Get the width of the rendering region of a window
@ -114,7 +114,7 @@ CSFML_API sfBool sfWindow_IsOpened(sfWindow* window);
/// \return Width in pixels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfWindow_GetWidth(sfWindow* window);
CSFML_API unsigned int sfWindow_GetWidth(const sfWindow* window);
////////////////////////////////////////////////////////////
/// Get the height of the rendering region of a window
@ -124,7 +124,7 @@ CSFML_API unsigned int sfWindow_GetWidth(sfWindow* window);
/// \return Height in pixels
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfWindow_GetHeight(sfWindow* window);
CSFML_API unsigned int sfWindow_GetHeight(const sfWindow* window);
////////////////////////////////////////////////////////////
/// Get the creation settings of a window
@ -134,7 +134,7 @@ CSFML_API unsigned int sfWindow_GetHeight(sfWindow* window);
/// \return Settings used to create the window
///
////////////////////////////////////////////////////////////
CSFML_API sfContextSettings sfWindow_GetSettings(sfWindow* window);
CSFML_API sfContextSettings sfWindow_GetSettings(const sfWindow* window);
////////////////////////////////////////////////////////////
/// Get the event on top of events stack of a window, if any, and pop it
@ -235,7 +235,7 @@ CSFML_API void sfWindow_EnableKeyRepeat(sfWindow* window, sfBool enabled);
/// \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, const sfUint8* pixels);
////////////////////////////////////////////////////////////
/// Activate or deactivate a window as the current target for rendering
@ -264,7 +264,7 @@ CSFML_API void sfWindow_Display(sfWindow* window);
/// \return Reference to the input
///
////////////////////////////////////////////////////////////
CSFML_API sfInput* sfWindow_GetInput(sfWindow* window);
CSFML_API const sfInput* sfWindow_GetInput(sfWindow* window);
////////////////////////////////////////////////////////////
/// Limit the framerate to a maximum fixed frequency for a window
@ -283,7 +283,7 @@ CSFML_API void sfWindow_SetFramerateLimit(sfWindow* window, unsigned int limit);
/// \return Time elapsed, in seconds
///
////////////////////////////////////////////////////////////
CSFML_API float sfWindow_GetFrameTime(sfWindow* window);
CSFML_API float sfWindow_GetFrameTime(const sfWindow* window);
////////////////////////////////////////////////////////////
/// Change the joystick threshold, ie. the value below which

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

@ -85,7 +85,7 @@ void sfMusic_SetLoop(sfMusic* music, sfBool loop)
////////////////////////////////////////////////////////////
/// Tell whether or not a music is looping
////////////////////////////////////////////////////////////
sfBool sfMusic_GetLoop(sfMusic* music)
sfBool sfMusic_GetLoop(const sfMusic* music)
{
CSFML_CALL_RETURN(music, GetLoop(), sfFalse);
}
@ -94,7 +94,7 @@ sfBool sfMusic_GetLoop(sfMusic* music)
////////////////////////////////////////////////////////////
/// Get a music duration
////////////////////////////////////////////////////////////
float sfMusic_GetDuration(sfMusic* music)
float sfMusic_GetDuration(const sfMusic* music)
{
CSFML_CALL_RETURN(music, GetDuration(), 0.f);
}
@ -130,7 +130,7 @@ void sfMusic_Stop(sfMusic* music)
////////////////////////////////////////////////////////////
/// Return the number of channels of a music (1 = mono, 2 = stereo)
////////////////////////////////////////////////////////////
unsigned int sfMusic_GetChannelsCount(sfMusic* music)
unsigned int sfMusic_GetChannelsCount(const sfMusic* music)
{
CSFML_CALL_RETURN(music, GetChannelsCount(), 0);
}
@ -139,7 +139,7 @@ unsigned int sfMusic_GetChannelsCount(sfMusic* music)
////////////////////////////////////////////////////////////
/// Get the stream sample rate of a music
////////////////////////////////////////////////////////////
unsigned int sfMusic_GetSampleRate(sfMusic* music)
unsigned int sfMusic_GetSampleRate(const sfMusic* music)
{
CSFML_CALL_RETURN(music, GetSampleRate(), 0);
}
@ -148,7 +148,7 @@ unsigned int sfMusic_GetSampleRate(sfMusic* music)
////////////////////////////////////////////////////////////
/// Get the status of a music (stopped, paused, playing)
////////////////////////////////////////////////////////////
sfSoundStatus sfMusic_GetStatus(sfMusic* music)
sfSoundStatus sfMusic_GetStatus(const sfMusic* music)
{
CSFML_CHECK_RETURN(music, sfStopped);
@ -159,7 +159,7 @@ sfSoundStatus sfMusic_GetStatus(sfMusic* music)
////////////////////////////////////////////////////////////
/// Get the current playing position of a music
////////////////////////////////////////////////////////////
float sfMusic_GetPlayingOffset(sfMusic* music)
float sfMusic_GetPlayingOffset(const sfMusic* music)
{
CSFML_CALL_RETURN(music, GetPlayingOffset(), 0.f);
}
@ -237,7 +237,7 @@ void sfMusic_SetPlayingOffset(sfMusic* music, float timeOffset)
////////////////////////////////////////////////////////////
/// Get the pitch of a music
////////////////////////////////////////////////////////////
float sfMusic_GetPitch(sfMusic* music)
float sfMusic_GetPitch(const sfMusic* music)
{
CSFML_CALL_RETURN(music, GetPitch(), 0.f);
}
@ -246,7 +246,7 @@ float sfMusic_GetPitch(sfMusic* music)
////////////////////////////////////////////////////////////
/// Get the volume of a music
////////////////////////////////////////////////////////////
float sfMusic_GetVolume(sfMusic* music)
float sfMusic_GetVolume(const sfMusic* music)
{
CSFML_CALL_RETURN(music, GetVolume(), 0.f);
}
@ -255,7 +255,7 @@ float sfMusic_GetVolume(sfMusic* music)
////////////////////////////////////////////////////////////
/// Get the position of a music
////////////////////////////////////////////////////////////
void sfMusic_GetPosition(sfMusic* music, float* x, float* y, float* z)
void sfMusic_GetPosition(const sfMusic* music, float* x, float* y, float* z)
{
CSFML_CHECK(music);
@ -273,7 +273,7 @@ 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(const sfMusic* music)
{
CSFML_CALL_RETURN(music, IsRelativeToListener(), sfFalse);
}
@ -282,16 +282,16 @@ CSFML_API sfBool sfMusic_IsRelativeToListener(sfMusic* music)
////////////////////////////////////////////////////////////
/// Get the minimum distance of a music
////////////////////////////////////////////////////////////
float sfMusic_GetMinDistance(sfMusic* music)
float sfMusic_GetMinDistance(const sfMusic* music)
{
CSFML_CALL_RETURN(music, GetMinDistance(), 0.f);
}
////////////////////////////////////////////////////////////
/// Get the attenuation factor of a a
/// Get the attenuation factor of a music
////////////////////////////////////////////////////////////
float sfMusic_GetAttenuation(sfMusic* music)
float sfMusic_GetAttenuation(const sfMusic* music)
{
CSFML_CALL_RETURN(music, GetAttenuation(), 0.f);
}

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

@ -78,7 +78,7 @@ void sfSound_Stop(sfSound* sound)
////////////////////////////////////////////////////////////
/// Bind a sound buffer to a sound
////////////////////////////////////////////////////////////
void sfSound_SetBuffer(sfSound* sound, sfSoundBuffer* buffer)
void sfSound_SetBuffer(sfSound* sound, const sfSoundBuffer* buffer)
{
if (buffer)
{
@ -91,7 +91,7 @@ void sfSound_SetBuffer(sfSound* sound, sfSoundBuffer* buffer)
////////////////////////////////////////////////////////////
/// Get the sound buffer bound to a sound
////////////////////////////////////////////////////////////
sfSoundBuffer* sfSound_GetBuffer(sfSound* sound)
const sfSoundBuffer* sfSound_GetBuffer(const sfSound* sound)
{
CSFML_CHECK_RETURN(sound, NULL)
@ -111,7 +111,7 @@ void sfSound_SetLoop(sfSound* sound, sfBool loop)
////////////////////////////////////////////////////////////
/// Tell whether or not a sound is looping
////////////////////////////////////////////////////////////
sfBool sfSound_GetLoop(sfSound* sound)
sfBool sfSound_GetLoop(const sfSound* sound)
{
CSFML_CALL_RETURN(sound, GetLoop(), sfFalse)
}
@ -120,7 +120,7 @@ sfBool sfSound_GetLoop(sfSound* sound)
////////////////////////////////////////////////////////////
/// Get the status of a sound (stopped, paused, playing)
////////////////////////////////////////////////////////////
sfSoundStatus sfSound_GetStatus(sfSound* sound)
sfSoundStatus sfSound_GetStatus(const sfSound* sound)
{
CSFML_CHECK_RETURN(sound, sfStopped);
@ -200,7 +200,7 @@ void sfSound_SetPlayingOffset(sfSound* sound, float timeOffset)
////////////////////////////////////////////////////////////
/// Get the pitch of a sound
////////////////////////////////////////////////////////////
float sfSound_GetPitch(sfSound* sound)
float sfSound_GetPitch(const sfSound* sound)
{
CSFML_CALL_RETURN(sound, GetPitch(), 0.f)
}
@ -209,7 +209,7 @@ float sfSound_GetPitch(sfSound* sound)
////////////////////////////////////////////////////////////
/// Get the volume of a sound
////////////////////////////////////////////////////////////
float sfSound_GetVolume(sfSound* sound)
float sfSound_GetVolume(const sfSound* sound)
{
CSFML_CALL_RETURN(sound, GetVolume(), 0.f)
}
@ -218,7 +218,7 @@ float sfSound_GetVolume(sfSound* sound)
////////////////////////////////////////////////////////////
/// Get the position of a sound
////////////////////////////////////////////////////////////
void sfSound_GetPosition(sfSound* sound, float* x, float* y, float* z)
void sfSound_GetPosition(const sfSound* sound, float* x, float* y, float* z)
{
CSFML_CHECK(sound);
@ -233,7 +233,7 @@ 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(const sfSound* sound)
{
CSFML_CALL_RETURN(sound, IsRelativeToListener(), sfFalse);
}
@ -242,7 +242,7 @@ CSFML_API sfBool sfSound_IsRelativeToListener(sfSound* sound)
////////////////////////////////////////////////////////////
/// Get the minimum distance of a sound
////////////////////////////////////////////////////////////
float sfSound_GetMinDistance(sfSound* sound)
float sfSound_GetMinDistance(const sfSound* sound)
{
CSFML_CALL_RETURN(sound, GetMinDistance(), 0.f);
}
@ -251,7 +251,7 @@ float sfSound_GetMinDistance(sfSound* sound)
////////////////////////////////////////////////////////////
/// Get the attenuation factor of a sound
////////////////////////////////////////////////////////////
float sfSound_GetAttenuation(sfSound* sound)
float sfSound_GetAttenuation(const sfSound* sound)
{
CSFML_CALL_RETURN(sound, GetAttenuation(), 0.f);
}
@ -260,7 +260,7 @@ float sfSound_GetAttenuation(sfSound* sound)
////////////////////////////////////////////////////////////
/// Get the current playing position of a sound
////////////////////////////////////////////////////////////
float sfSound_GetPlayingOffset(sfSound* sound)
float sfSound_GetPlayingOffset(const sfSound* sound)
{
CSFML_CALL_RETURN(sound, GetPlayingOffset(), 0.f)
}

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

@ -95,7 +95,7 @@ void sfSoundBuffer_Destroy(sfSoundBuffer* soundBuffer)
////////////////////////////////////////////////////////////
/// Save a sound buffer to a file
////////////////////////////////////////////////////////////
sfBool sfSoundBuffer_SaveToFile(sfSoundBuffer* soundBuffer, const char* filename)
sfBool sfSoundBuffer_SaveToFile(const sfSoundBuffer* soundBuffer, const char* filename)
{
CSFML_CALL_RETURN(soundBuffer, SaveToFile(filename), sfFalse)
}
@ -104,7 +104,7 @@ sfBool sfSoundBuffer_SaveToFile(sfSoundBuffer* soundBuffer, const char* filename
////////////////////////////////////////////////////////////
/// Return the samples contained in a sound buffer
////////////////////////////////////////////////////////////
const sfInt16* sfSoundBuffer_GetSamples(sfSoundBuffer* soundBuffer)
const sfInt16* sfSoundBuffer_GetSamples(const sfSoundBuffer* soundBuffer)
{
CSFML_CALL_RETURN(soundBuffer, GetSamples(), NULL)
}
@ -113,7 +113,7 @@ const sfInt16* sfSoundBuffer_GetSamples(sfSoundBuffer* soundBuffer)
////////////////////////////////////////////////////////////
/// Return the number of samples contained in a sound buffer
////////////////////////////////////////////////////////////
size_t sfSoundBuffer_GetSamplesCount(sfSoundBuffer* soundBuffer)
size_t sfSoundBuffer_GetSamplesCount(const sfSoundBuffer* soundBuffer)
{
CSFML_CALL_RETURN(soundBuffer, GetSamplesCount(), 0)
}
@ -122,7 +122,7 @@ size_t sfSoundBuffer_GetSamplesCount(sfSoundBuffer* soundBuffer)
////////////////////////////////////////////////////////////
/// Get the sample rate of a sound buffer
////////////////////////////////////////////////////////////
unsigned int sfSoundBuffer_GetSampleRate(sfSoundBuffer* soundBuffer)
unsigned int sfSoundBuffer_GetSampleRate(const sfSoundBuffer* soundBuffer)
{
CSFML_CALL_RETURN(soundBuffer, GetSampleRate(), 0)
}
@ -131,7 +131,7 @@ unsigned int sfSoundBuffer_GetSampleRate(sfSoundBuffer* soundBuffer)
////////////////////////////////////////////////////////////
/// Return the number of channels of a sound buffer (1 = mono, 2 = stereo, ...)
////////////////////////////////////////////////////////////
unsigned int sfSoundBuffer_GetChannelsCount(sfSoundBuffer* soundBuffer)
unsigned int sfSoundBuffer_GetChannelsCount(const sfSoundBuffer* soundBuffer)
{
CSFML_CALL_RETURN(soundBuffer, GetChannelsCount(), 0)
}
@ -140,7 +140,7 @@ unsigned int sfSoundBuffer_GetChannelsCount(sfSoundBuffer* soundBuffer)
////////////////////////////////////////////////////////////
/// Get the duration of a sound buffer
////////////////////////////////////////////////////////////
float sfSoundBuffer_GetDuration(sfSoundBuffer* soundBuffer)
float sfSoundBuffer_GetDuration(const sfSoundBuffer* soundBuffer)
{
CSFML_CALL_RETURN(soundBuffer, GetDuration(), 0.f)
}

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

@ -70,7 +70,7 @@ void sfSoundBufferRecorder_Stop(sfSoundBufferRecorder* soundBufferRecorder)
////////////////////////////////////////////////////////////
/// Get the sample rate of a sound buffer recorder
////////////////////////////////////////////////////////////
unsigned int sfSoundBufferRecorder_GetSampleRate(sfSoundBufferRecorder* soundBufferRecorder)
unsigned int sfSoundBufferRecorder_GetSampleRate(const sfSoundBufferRecorder* soundBufferRecorder)
{
CSFML_CALL_RETURN(soundBufferRecorder, GetSampleRate(), 0);
}
@ -80,7 +80,7 @@ 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)
const sfSoundBuffer* sfSoundBufferRecorder_GetBuffer(const sfSoundBufferRecorder* soundBufferRecorder)
{
CSFML_CHECK_RETURN(soundBufferRecorder, NULL);

2
CSFML/src/SFML/Audio/SoundBufferRecorderStruct.h
View File

@ -38,7 +38,7 @@
struct sfSoundBufferRecorder
{
sf::SoundBufferRecorder This;
sfSoundBuffer SoundBuffer;
mutable sfSoundBuffer SoundBuffer;
};

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

@ -74,7 +74,7 @@ void sfSoundRecorder_Stop(sfSoundRecorder* soundRecorder)
////////////////////////////////////////////////////////////
/// Get the sample rate of a sound recorder
////////////////////////////////////////////////////////////
unsigned int sfSoundRecorder_GetSampleRate(sfSoundRecorder* soundRecorder)
unsigned int sfSoundRecorder_GetSampleRate(const sfSoundRecorder* soundRecorder)
{
CSFML_CALL_RETURN(soundRecorder, GetSampleRate(), 0);
}

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

@ -82,7 +82,7 @@ void sfSoundStream_Stop(sfSoundStream* soundStream)
////////////////////////////////////////////////////////////
/// Get the status of a sound stream (stopped, paused, playing)
////////////////////////////////////////////////////////////
sfSoundStatus sfSoundStream_GetStatus(sfSoundStream* soundStream)
sfSoundStatus sfSoundStream_GetStatus(const sfSoundStream* soundStream)
{
CSFML_CHECK_RETURN(soundStream, sfStopped);
@ -94,7 +94,7 @@ 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(const sfSoundStream* soundStream)
{
CSFML_CALL_RETURN(soundStream, GetChannelsCount(), 0);
}
@ -103,7 +103,7 @@ unsigned int sfSoundStream_GetChannelsCount(sfSoundStream* soundStream)
////////////////////////////////////////////////////////////
/// Get the sample rate of a sound stream
////////////////////////////////////////////////////////////
unsigned int sfSoundStream_GetSampleRate(sfSoundStream* soundStream)
unsigned int sfSoundStream_GetSampleRate(const sfSoundStream* soundStream)
{
CSFML_CALL_RETURN(soundStream, GetSampleRate(), 0);
}
@ -190,7 +190,7 @@ void sfSoundStream_SetLoop(sfSoundStream* soundStream, sfBool loop)
////////////////////////////////////////////////////////////
/// Get the pitch of a sound stream
////////////////////////////////////////////////////////////
float sfSoundStream_GetPitch(sfSoundStream* soundStream)
float sfSoundStream_GetPitch(const sfSoundStream* soundStream)
{
CSFML_CALL_RETURN(soundStream, GetPitch(), 0.f);
}
@ -199,7 +199,7 @@ float sfSoundStream_GetPitch(sfSoundStream* soundStream)
////////////////////////////////////////////////////////////
/// Get the volume of a sound stream
////////////////////////////////////////////////////////////
float sfSoundStream_GetVolume(sfSoundStream* soundStream)
float sfSoundStream_GetVolume(const sfSoundStream* soundStream)
{
CSFML_CALL_RETURN(soundStream, GetVolume(), 0.f);
}
@ -208,7 +208,7 @@ float sfSoundStream_GetVolume(sfSoundStream* soundStream)
////////////////////////////////////////////////////////////
/// Get the position of a sound stream
////////////////////////////////////////////////////////////
void sfSoundStream_GetPosition(sfSoundStream* soundStream, float* x, float* y, float* z)
void sfSoundStream_GetPosition(const sfSoundStream* soundStream, float* x, float* y, float* z)
{
CSFML_CHECK(soundStream);
@ -223,7 +223,7 @@ 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(const sfSoundStream* soundStream)
{
CSFML_CALL_RETURN(soundStream, IsRelativeToListener(), sfFalse);
}
@ -232,7 +232,7 @@ CSFML_API sfBool sfSoundStream_IsRelativeToListener(sfSoundStream* soundStream)
////////////////////////////////////////////////////////////
/// Get the minimum distance of a sound stream
////////////////////////////////////////////////////////////
float sfSoundStream_GetMinDistance(sfSoundStream* soundStream)
float sfSoundStream_GetMinDistance(const sfSoundStream* soundStream)
{
CSFML_CALL_RETURN(soundStream, GetMinDistance(), 0.f);
}
@ -241,7 +241,7 @@ float sfSoundStream_GetMinDistance(sfSoundStream* soundStream)
////////////////////////////////////////////////////////////
/// Get the attenuation factor of a sound stream
////////////////////////////////////////////////////////////
float sfSoundStream_GetAttenuation(sfSoundStream* soundStream)
float sfSoundStream_GetAttenuation(const sfSoundStream* soundStream)
{
CSFML_CALL_RETURN(soundStream, GetAttenuation(), 0.f);
}
@ -250,7 +250,7 @@ float sfSoundStream_GetAttenuation(sfSoundStream* soundStream)
////////////////////////////////////////////////////////////
/// Tell whether or not a stream is looping
////////////////////////////////////////////////////////////
sfBool sfSoundStream_GetLoop(sfSoundStream* soundStream)
sfBool sfSoundStream_GetLoop(const sfSoundStream* soundStream)
{
CSFML_CALL_RETURN(soundStream, GetLoop(), sfFalse);
}
@ -259,7 +259,7 @@ sfBool sfSoundStream_GetLoop(sfSoundStream* soundStream)
////////////////////////////////////////////////////////////
/// Get the current playing position of a sound stream
////////////////////////////////////////////////////////////
float sfSoundStream_GetPlayingOffset(sfSoundStream* soundStream)
float sfSoundStream_GetPlayingOffset(const sfSoundStream* soundStream)
{
CSFML_CALL_RETURN(soundStream, GetPlayingOffset(), 0.f);
}

2
CSFML/src/SFML/Audio/SoundStruct.h
View File

@ -38,7 +38,7 @@
struct sfSound
{
sf::Sound This;
sfSoundBuffer* Buffer;
const sfSoundBuffer* Buffer;
};

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

@ -98,7 +98,7 @@ 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(const sfFont* font)
{
CSFML_CALL_RETURN(font, GetCharacterSize(), 0);
}
@ -107,7 +107,7 @@ unsigned int sfFont_GetCharacterSize(sfFont* font)
////////////////////////////////////////////////////////////
/// Get the built-in default font (Arial)
////////////////////////////////////////////////////////////
sfFont* sfFont_GetDefaultFont()
const sfFont* sfFont_GetDefaultFont()
{
static sfFont defaultFont = {sf::Font::GetDefaultFont()};

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

@ -120,7 +120,7 @@ void sfImage_Destroy(sfImage* image)
////////////////////////////////////////////////////////////
/// Save the content of an image to a file
////////////////////////////////////////////////////////////
sfBool sfImage_SaveToFile(sfImage* image, const char* filename)
sfBool sfImage_SaveToFile(const sfImage* image, const char* filename)
{
CSFML_CALL_PTR_RETURN(image, SaveToFile(filename), sfFalse);
}
@ -141,7 +141,7 @@ 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, const sfImage* source, unsigned int destX, unsigned int destY, sfIntRect sourceRect)
{
CSFML_CHECK(source);
sf::IntRect SFMLRect(sourceRect.Left, sourceRect.Top, sourceRect.Right, sourceRect.Bottom);
@ -175,7 +175,7 @@ void sfImage_SetPixel(sfImage* image, unsigned int x, unsigned int y, sfColor co
////////////////////////////////////////////////////////////
/// Get a pixel from an image
////////////////////////////////////////////////////////////
sfColor sfImage_GetPixel(sfImage* image, unsigned int x, unsigned int y)
sfColor sfImage_GetPixel(const sfImage* image, unsigned int x, unsigned int y)
{
sfColor color = {0, 0, 0, 0};
CSFML_CHECK_RETURN(image, color);
@ -191,7 +191,7 @@ 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(const sfImage* image)
{
CSFML_CALL_PTR_RETURN(image, GetPixelsPtr(), NULL);
}
@ -200,7 +200,7 @@ const sfUint8* sfImage_GetPixelsPtr(sfImage* image)
////////////////////////////////////////////////////////////
/// Bind the image for rendering
////////////////////////////////////////////////////////////
void sfImage_Bind(sfImage* image)
void sfImage_Bind(const sfImage* image)
{
CSFML_CALL_PTR(image, Bind());
}
@ -218,7 +218,7 @@ void sfImage_SetSmooth(sfImage* image, sfBool smooth)
////////////////////////////////////////////////////////////
/// Return the width of the image
////////////////////////////////////////////////////////////
unsigned int sfImage_GetWidth(sfImage* image)
unsigned int sfImage_GetWidth(const sfImage* image)
{
CSFML_CALL_PTR_RETURN(image, GetWidth(), 0);
}
@ -227,7 +227,7 @@ unsigned int sfImage_GetWidth(sfImage* image)
////////////////////////////////////////////////////////////
/// Return the height of the image
////////////////////////////////////////////////////////////
unsigned int sfImage_GetHeight(sfImage* image)
unsigned int sfImage_GetHeight(const sfImage* image)
{
CSFML_CALL_PTR_RETURN(image, GetHeight(), 0);
}
@ -236,7 +236,7 @@ unsigned int sfImage_GetHeight(sfImage* image)
////////////////////////////////////////////////////////////
/// Tells whether the smoothing filter is enabled or not on an image
////////////////////////////////////////////////////////////
sfBool sfImage_IsSmooth(sfImage* image)
sfBool sfImage_IsSmooth(const sfImage* image)
{
CSFML_CALL_PTR_RETURN(image, IsSmooth(), sfFalse);
}

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

@ -54,12 +54,12 @@ void sfIntRect_Offset(sfIntRect* rect, int offsetX, int offsetY)
////////////////////////////////////////////////////////////
/// Check if a point is inside a rectangle's area
////////////////////////////////////////////////////////////
sfBool sfFloatRect_Contains(sfFloatRect* rect, float x, float y)
sfBool sfFloatRect_Contains(const 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);
}
sfBool sfIntRect_Contains(sfIntRect* rect, int x, int y)
sfBool sfIntRect_Contains(const 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);
@ -69,7 +69,7 @@ sfBool sfIntRect_Contains(sfIntRect* rect, int x, int y)
////////////////////////////////////////////////////////////
/// Check intersection between two rectangles
////////////////////////////////////////////////////////////
sfBool sfFloatRect_Intersects(sfFloatRect* rect1, sfFloatRect* rect2, sfFloatRect* intersection)
sfBool sfFloatRect_Intersects(const sfFloatRect* rect1, const sfFloatRect* rect2, sfFloatRect* intersection)
{
CSFML_CHECK_RETURN(rect1, sfFalse)
CSFML_CHECK_RETURN(rect2, sfFalse)
@ -94,7 +94,7 @@ sfBool sfFloatRect_Intersects(sfFloatRect* rect1, sfFloatRect* rect2, sfFloatRec
return SFMLRect1.Intersects(SFMLRect2);
}
}
sfBool sfIntRect_Intersects(sfIntRect* rect1, sfIntRect* rect2, sfIntRect* intersection)
sfBool sfIntRect_Intersects(const sfIntRect* rect1, const sfIntRect* rect2, sfIntRect* intersection)
{
CSFML_CHECK_RETURN(rect1, sfFalse)
CSFML_CHECK_RETURN(rect2, sfFalse)

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

@ -63,7 +63,7 @@ void sfRenderImage_Destroy(sfRenderImage* renderImage)
////////////////////////////////////////////////////////////
/// Get the width of the rendering region of a renderimage
////////////////////////////////////////////////////////////
unsigned int sfRenderImage_GetWidth(sfRenderImage* renderImage)
unsigned int sfRenderImage_GetWidth(const sfRenderImage* renderImage)
{
CSFML_CALL_RETURN(renderImage, GetWidth(), 0);
}
@ -72,7 +72,7 @@ unsigned int sfRenderImage_GetWidth(sfRenderImage* renderImage)
////////////////////////////////////////////////////////////
/// Get the height of the rendering region of a renderimage
////////////////////////////////////////////////////////////
unsigned int sfRenderImage_GetHeight(sfRenderImage* renderImage)
unsigned int sfRenderImage_GetHeight(const sfRenderImage* renderImage)
{
CSFML_CALL_RETURN(renderImage, GetHeight(), 0);
}
@ -118,17 +118,17 @@ void sfRenderImage_Display(sfRenderImage* renderImage)
////////////////////////////////////////////////////////////
/// Draw something on a renderimage
////////////////////////////////////////////////////////////
void sfRenderImage_DrawSprite(sfRenderImage* renderImage, sfSprite* sprite)
void sfRenderImage_DrawSprite(sfRenderImage* renderImage, const sfSprite* sprite)
{
CSFML_CHECK(sprite);
CSFML_CALL(renderImage, Draw(sprite->This));
}
void sfRenderImage_DrawShape(sfRenderImage* renderImage, sfShape* shape)
void sfRenderImage_DrawShape(sfRenderImage* renderImage, const sfShape* shape)
{
CSFML_CHECK(shape);
CSFML_CALL(renderImage, Draw(shape->This));
}
void sfRenderImage_DrawText(sfRenderImage* renderImage, sfText* text)
void sfRenderImage_DrawText(sfRenderImage* renderImage, const sfText* text)
{
CSFML_CHECK(text);
CSFML_CALL(renderImage, Draw(text->This));
@ -138,19 +138,19 @@ void sfRenderImage_DrawText(sfRenderImage* renderImage, sfText* text)
////////////////////////////////////////////////////////////
/// Draw something on a renderimage with a shader
////////////////////////////////////////////////////////////
void sfRenderImage_DrawSpriteWithShader(sfRenderImage* renderImage, sfSprite* sprite, sfShader* shader)
void sfRenderImage_DrawSpriteWithShader(sfRenderImage* renderImage, const sfSprite* sprite, const sfShader* shader)
{
CSFML_CHECK(sprite);
CSFML_CHECK(shader);
CSFML_CALL(renderImage, Draw(sprite->This, shader->This));
}
void sfRenderImage_DrawShapeWithShader(sfRenderImage* renderImage, sfShape* shape, sfShader* shader)
void sfRenderImage_DrawShapeWithShader(sfRenderImage* renderImage, const sfShape* shape, const sfShader* shader)
{
CSFML_CHECK(shape);
CSFML_CHECK(shader);
CSFML_CALL(renderImage, Draw(shape->This, shader->This));
}
void sfRenderImage_DrawTextWithShader(sfRenderImage* renderImage, sfText* text, sfShader* shader)
void sfRenderImage_DrawTextWithShader(sfRenderImage* renderImage, const sfText* text, const sfShader* shader)
{
CSFML_CHECK(text);
CSFML_CHECK(shader);
@ -172,7 +172,7 @@ void sfRenderImage_Clear(sfRenderImage* renderImage, sfColor color)
////////////////////////////////////////////////////////////
/// Change the current active view of a renderimage
////////////////////////////////////////////////////////////
void sfRenderImage_SetView(sfRenderImage* renderImage, sfView* view)
void sfRenderImage_SetView(sfRenderImage* renderImage, const sfView* view)
{
CSFML_CHECK(view);
CSFML_CALL(renderImage, SetView(*view->This));
@ -183,7 +183,7 @@ void sfRenderImage_SetView(sfRenderImage* renderImage, sfView* view)
////////////////////////////////////////////////////////////
/// Get the current active view of a renderimage
////////////////////////////////////////////////////////////
const sfView* sfRenderImage_GetView(sfRenderImage* renderImage)
const sfView* sfRenderImage_GetView(const sfRenderImage* renderImage)
{
CSFML_CHECK_RETURN(renderImage, NULL);
@ -205,7 +205,7 @@ sfView* sfRenderImage_GetDefaultView(sfRenderImage* renderImage)
////////////////////////////////////////////////////////////
/// Get the viewport of a view applied to this target
////////////////////////////////////////////////////////////
sfIntRect sfRenderImage_GetViewport(sfRenderImage* renderImage, sfView* view)
sfIntRect sfRenderImage_GetViewport(const sfRenderImage* renderImage, const sfView* view)
{
sfIntRect rect = {0, 0, 0, 0};
CSFML_CHECK_RETURN(view, rect);
@ -224,7 +224,7 @@ sfIntRect sfRenderImage_GetViewport(sfRenderImage* renderImage, sfView* view)
////////////////////////////////////////////////////////////
/// Convert a point in image coordinates into view coordinates
////////////////////////////////////////////////////////////
void sfRenderImage_ConvertCoords(sfRenderImage* renderImage, unsigned int imageX, unsigned int imageY, float* viewX, float* viewY, sfView* targetView)
void sfRenderImage_ConvertCoords(const sfRenderImage* renderImage, unsigned int imageX, unsigned int imageY, float* viewX, float* viewY, const sfView* targetView)
{
CSFML_CHECK(renderImage);
@ -242,7 +242,7 @@ void sfRenderImage_ConvertCoords(sfRenderImage* renderImage, unsigned int imageX
////////////////////////////////////////////////////////////
/// Get the target image
////////////////////////////////////////////////////////////
sfImage* sfRenderImage_GetImage(sfRenderImage* renderImage)
const sfImage* sfRenderImage_GetImage(const sfRenderImage* renderImage)
{
CSFML_CHECK_RETURN(renderImage, NULL);

4
CSFML/src/SFML/Graphics/RenderImageStruct.h
View File

@ -40,9 +40,9 @@
struct sfRenderImage
{
sf::RenderImage This;
sfImage* Target;
const sfImage* Target;
sfView* DefaultView;
sfView* CurrentView;
const sfView* CurrentView;
};

38
CSFML/src/SFML/Graphics/RenderWindow.cpp
View File

@ -39,7 +39,7 @@
////////////////////////////////////////////////////////////
/// Construct a new renderwindow
////////////////////////////////////////////////////////////
sfRenderWindow* sfRenderWindow_Create(sfVideoMode mode, const char* title, unsigned long style, sfContextSettings* settings)
sfRenderWindow* sfRenderWindow_Create(sfVideoMode mode, const char* title, unsigned long style, const sfContextSettings* settings)
{
// Convert video mode
sf::VideoMode videoMode(mode.Width, mode.Height, mode.BitsPerPixel);
@ -69,7 +69,7 @@ sfRenderWindow* sfRenderWindow_Create(sfVideoMode mode, const char* title, unsig
////////////////////////////////////////////////////////////
/// Construct a renderwindow from an existing control
////////////////////////////////////////////////////////////
sfRenderWindow* sfRenderWindow_CreateFromHandle(sfWindowHandle handle, sfContextSettings* settings)
sfRenderWindow* sfRenderWindow_CreateFromHandle(sfWindowHandle handle, const sfContextSettings* settings)
{
// Convert context settings
sf::ContextSettings params;
@ -114,7 +114,7 @@ void sfRenderWindow_Close(sfRenderWindow* renderWindow)
////////////////////////////////////////////////////////////
/// Tell whether or not a renderwindow is opened
////////////////////////////////////////////////////////////
sfBool sfRenderWindow_IsOpened(sfRenderWindow* renderWindow)
sfBool sfRenderWindow_IsOpened(const sfRenderWindow* renderWindow)
{
CSFML_CALL_RETURN(renderWindow, IsOpened(), sfFalse);
}
@ -123,7 +123,7 @@ sfBool sfRenderWindow_IsOpened(sfRenderWindow* renderWindow)
////////////////////////////////////////////////////////////
/// Get the width of the rendering region of a window
////////////////////////////////////////////////////////////
unsigned int sfRenderWindow_GetWidth(sfRenderWindow* renderWindow)
unsigned int sfRenderWindow_GetWidth(const sfRenderWindow* renderWindow)
{
CSFML_CALL_RETURN(renderWindow, GetWidth(), 0);
}
@ -132,7 +132,7 @@ unsigned int sfRenderWindow_GetWidth(sfRenderWindow* renderWindow)
////////////////////////////////////////////////////////////
/// Get the height of the rendering region of a window
////////////////////////////////////////////////////////////
unsigned int sfRenderWindow_GetHeight(sfRenderWindow* renderWindow)
unsigned int sfRenderWindow_GetHeight(const sfRenderWindow* renderWindow)
{
CSFML_CALL_RETURN(renderWindow, GetHeight(), 0);
}
@ -141,7 +141,7 @@ unsigned int sfRenderWindow_GetHeight(sfRenderWindow* renderWindow)
////////////////////////////////////////////////////////////
/// Get the creation settings of a window
////////////////////////////////////////////////////////////
sfContextSettings sfRenderWindow_GetSettings(sfRenderWindow* renderWindow)
sfContextSettings sfRenderWindow_GetSettings(const sfRenderWindow* renderWindow)
{
sfContextSettings settings = {0, 0, 0};
CSFML_CHECK_RETURN(renderWindow, settings);
@ -270,7 +270,7 @@ void sfRenderWindow_EnableKeyRepeat(sfRenderWindow* renderWindow, sfBool enabled
////////////////////////////////////////////////////////////
/// Change the window's icon
////////////////////////////////////////////////////////////
void sfRenderWindow_SetIcon(sfRenderWindow* renderWindow, unsigned int width, unsigned int height, sfUint8* pixels)
void sfRenderWindow_SetIcon(sfRenderWindow* renderWindow, unsigned int width, unsigned int height, const sfUint8* pixels)
{
CSFML_CALL(renderWindow, SetIcon(width, height, pixels))
}
@ -317,7 +317,7 @@ void sfRenderWindow_Display(sfRenderWindow* renderWindow)
////////////////////////////////////////////////////////////
/// Get the input manager of a window
////////////////////////////////////////////////////////////
sfInput* sfRenderWindow_GetInput(sfRenderWindow* renderWindow)
const sfInput* sfRenderWindow_GetInput(const sfRenderWindow* renderWindow)
{
CSFML_CHECK_RETURN(renderWindow, NULL);
@ -337,7 +337,7 @@ void sfRenderWindow_SetFramerateLimit(sfRenderWindow* renderWindow, unsigned int
////////////////////////////////////////////////////////////
/// Get time elapsed since last frame of a window
////////////////////////////////////////////////////////////
float sfRenderWindow_GetFrameTime(sfRenderWindow* renderWindow)
float sfRenderWindow_GetFrameTime(const sfRenderWindow* renderWindow)
{
CSFML_CALL_RETURN(renderWindow, GetFrameTime(), 0.f);
}
@ -356,17 +356,17 @@ void sfRenderWindow_SetJoystickThreshold(sfRenderWindow* renderWindow, float thr
////////////////////////////////////////////////////////////
/// Draw something on a renderwindow
////////////////////////////////////////////////////////////
void sfRenderWindow_DrawSprite(sfRenderWindow* renderWindow, sfSprite* sprite)
void sfRenderWindow_DrawSprite(sfRenderWindow* renderWindow, const sfSprite* sprite)
{
CSFML_CHECK(sprite);
CSFML_CALL(renderWindow, Draw(sprite->This));
}
void sfRenderWindow_DrawShape(sfRenderWindow* renderWindow, sfShape* shape)
void sfRenderWindow_DrawShape(sfRenderWindow* renderWindow, const sfShape* shape)
{
CSFML_CHECK(shape);
CSFML_CALL(renderWindow, Draw(shape->This));
}
void sfRenderWindow_DrawText(sfRenderWindow* renderWindow, sfText* text)
void sfRenderWindow_DrawText(sfRenderWindow* renderWindow, const sfText* text)
{
CSFML_CHECK(text);
CSFML_CALL(renderWindow, Draw(text->This));
@ -376,19 +376,19 @@ void sfRenderWindow_DrawText(sfRenderWindow* renderWindow, sfText* text)
////////////////////////////////////////////////////////////
/// Draw something on a renderwindow with a shader
////////////////////////////////////////////////////////////
void sfRenderWindow_DrawSpriteWithShader(sfRenderWindow* renderWindow, sfSprite* sprite, sfShader* shader)
void sfRenderWindow_DrawSpriteWithShader(sfRenderWindow* renderWindow, const sfSprite* sprite, const sfShader* shader)
{
CSFML_CHECK(sprite);
CSFML_CHECK(shader);
CSFML_CALL(renderWindow, Draw(sprite->This, shader->This));
}
void sfRenderWindow_DrawShapeWithShader(sfRenderWindow* renderWindow, sfShape* shape, sfShader* shader)
void sfRenderWindow_DrawShapeWithShader(sfRenderWindow* renderWindow, const sfShape* shape, const sfShader* shader)
{
CSFML_CHECK(shape);
CSFML_CHECK(shader);
CSFML_CALL(renderWindow, Draw(shape->This, shader->This));
}
void sfRenderWindow_DrawTextWithShader(sfRenderWindow* renderWindow, sfText* text, sfShader* shader)
void sfRenderWindow_DrawTextWithShader(sfRenderWindow* renderWindow, const sfText* text, const sfShader* shader)
{
CSFML_CHECK(text);
CSFML_CHECK(shader);
@ -410,7 +410,7 @@ void sfRenderWindow_Clear(sfRenderWindow* renderWindow, sfColor color)
////////////////////////////////////////////////////////////
/// Change the current active view of a renderwindow
////////////////////////////////////////////////////////////
void sfRenderWindow_SetView(sfRenderWindow* renderWindow, sfView* view)
void sfRenderWindow_SetView(sfRenderWindow* renderWindow, const sfView* view)
{
CSFML_CHECK(view);
CSFML_CALL(renderWindow, SetView(*view->This));
@ -421,7 +421,7 @@ void sfRenderWindow_SetView(sfRenderWindow* renderWindow, sfView* view)
////////////////////////////////////////////////////////////
/// Get the current active view of a renderwindow
////////////////////////////////////////////////////////////
const sfView* sfRenderWindow_GetView(sfRenderWindow* renderWindow)
const sfView* sfRenderWindow_GetView(const sfRenderWindow* renderWindow)
{
CSFML_CHECK_RETURN(renderWindow, NULL);
@ -443,7 +443,7 @@ sfView* sfRenderWindow_GetDefaultView(sfRenderWindow* renderWindow)
////////////////////////////////////////////////////////////
/// Get the viewport of a view applied to this target
////////////////////////////////////////////////////////////
sfIntRect sfRenderWindow_GetViewport(sfRenderWindow* renderWindow, sfView* view)
sfIntRect sfRenderWindow_GetViewport(const sfRenderWindow* renderWindow, const sfView* view)
{
sfIntRect rect = {0, 0, 0, 0};
CSFML_CHECK_RETURN(view, rect);
@ -462,7 +462,7 @@ sfIntRect sfRenderWindow_GetViewport(sfRenderWindow* renderWindow, sfView* view)
////////////////////////////////////////////////////////////
/// Convert a point in window coordinates into view coordinates
////////////////////////////////////////////////////////////
void sfRenderWindow_ConvertCoords(sfRenderWindow* renderWindow, unsigned int windowX, unsigned int windowY, float* viewX, float* viewY, sfView* targetView)
void sfRenderWindow_ConvertCoords(const sfRenderWindow* renderWindow, unsigned int windowX, unsigned int windowY, float* viewX, float* viewY, const sfView* targetView)
{
CSFML_CHECK(renderWindow);

2
CSFML/src/SFML/Graphics/RenderWindowStruct.h
View File

@ -41,7 +41,7 @@ struct sfRenderWindow
sf::RenderWindow This;
sfInput Input;
sfView* DefaultView;
sfView* CurrentView;
const sfView* CurrentView;
};

6
CSFML/src/SFML/Graphics/Shader.cpp
View File

@ -113,7 +113,7 @@ void sfShader_SetParameter4(sfShader* shader, const char* name, float x, float y
////////////////////////////////////////////////////////////
/// Set a texture parameter in a shader
////////////////////////////////////////////////////////////
void sfShader_SetTexture(sfShader* shader, const char* name, sfImage* texture)
void sfShader_SetTexture(sfShader* shader, const char* name, const sfImage* texture)
{
CSFML_CALL(shader, SetTexture(name, texture && texture->This ? *texture->This : sf::Shader::CurrentTexture))
}
@ -122,7 +122,7 @@ void sfShader_SetTexture(sfShader* shader, const char* name, sfImage* texture)
////////////////////////////////////////////////////////////
/// Bind a shader for rendering
////////////////////////////////////////////////////////////
void sfShader_Bind(sfShader* shader)
void sfShader_Bind(const sfShader* shader)
{
CSFML_CALL(shader, Bind())
}
@ -131,7 +131,7 @@ void sfShader_Bind(sfShader* shader)
////////////////////////////////////////////////////////////
/// Unbind a shader
////////////////////////////////////////////////////////////
void sfShader_Unbind(sfShader* shader)
void sfShader_Unbind(const sfShader* shader)
{
CSFML_CALL(shader, Unbind())
}

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

@ -185,7 +185,7 @@ void sfShape_SetBlendMode(sfShape* shape, sfBlendMode mode)
////////////////////////////////////////////////////////////
/// Get the X position of a shape
////////////////////////////////////////////////////////////
float sfShape_GetX(sfShape* shape)
float sfShape_GetX(const sfShape* shape)
{
CSFML_CALL_RETURN(shape, GetPosition().x, 0.f)
}
@ -194,7 +194,7 @@ float sfShape_GetX(sfShape* shape)
////////////////////////////////////////////////////////////
/// Get the Y position of a shape
////////////////////////////////////////////////////////////
float sfShape_GetY(sfShape* shape)
float sfShape_GetY(const sfShape* shape)
{
CSFML_CALL_RETURN(shape, GetPosition().y, 0.f)
}
@ -203,7 +203,7 @@ float sfShape_GetY(sfShape* shape)
////////////////////////////////////////////////////////////
/// Get the horizontal scale of a shape
////////////////////////////////////////////////////////////
float sfShape_GetScaleX(sfShape* shape)
float sfShape_GetScaleX(const sfShape* shape)
{
CSFML_CALL_RETURN(shape, GetScale().x, 0.f)
}
@ -212,7 +212,7 @@ float sfShape_GetScaleX(sfShape* shape)
////////////////////////////////////////////////////////////
/// Get the vertical scale of a shape
////////////////////////////////////////////////////////////
float sfShape_GetScaleY(sfShape* shape)
float sfShape_GetScaleY(const sfShape* shape)
{
CSFML_CALL_RETURN(shape, GetScale().y, 0.f)
}
@ -221,7 +221,7 @@ float sfShape_GetScaleY(sfShape* shape)
////////////////////////////////////////////////////////////
/// Get the orientation of a shape
////////////////////////////////////////////////////////////
float sfShape_GetRotation(sfShape* shape)
float sfShape_GetRotation(const sfShape* shape)
{
CSFML_CALL_RETURN(shape, GetRotation(), 0.f)
}
@ -230,7 +230,7 @@ float sfShape_GetRotation(sfShape* shape)
////////////////////////////////////////////////////////////
/// Get the X position of the origin a shape
////////////////////////////////////////////////////////////
float sfShape_GetOriginX(sfShape* shape)
float sfShape_GetOriginX(const sfShape* shape)
{
CSFML_CALL_RETURN(shape, GetOrigin().x, 0.f)
}
@ -239,7 +239,7 @@ float sfShape_GetOriginX(sfShape* shape)
////////////////////////////////////////////////////////////
/// Get the Y position of the origin a shape
////////////////////////////////////////////////////////////
float sfShape_GetOriginY(sfShape* shape)
float sfShape_GetOriginY(const sfShape* shape)
{
CSFML_CALL_RETURN(shape, GetOrigin().y, 0.f)
}
@ -248,7 +248,7 @@ float sfShape_GetOriginY(sfShape* shape)
////////////////////////////////////////////////////////////
/// Get the color of a shape
////////////////////////////////////////////////////////////
sfColor sfShape_GetColor(sfShape* shape)
sfColor sfShape_GetColor(const sfShape* shape)
{
sfColor color = {0, 0, 0, 0};
CSFML_CHECK_RETURN(shape, color)
@ -261,7 +261,7 @@ sfColor sfShape_GetColor(sfShape* shape)
////////////////////////////////////////////////////////////
/// Get the current blending mode of a shape
////////////////////////////////////////////////////////////
sfBlendMode sfShape_GetBlendMode(sfShape* shape)
sfBlendMode sfShape_GetBlendMode(const sfShape* shape)
{
CSFML_CHECK_RETURN(shape, sfBlendNone)
@ -300,7 +300,7 @@ 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(const sfShape* shape, float pointX, float pointY, float* x, float* y)
{
CSFML_CHECK(shape)
@ -314,7 +314,7 @@ 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(const sfShape* shape, float pointX, float pointY, float* x, float* y)
{
CSFML_CHECK(shape)
@ -368,7 +368,7 @@ void sfShape_SetOutlineWidth(sfShape* shape, float width)
////////////////////////////////////////////////////////////
/// Get the width of a shape outline
////////////////////////////////////////////////////////////
float sfShape_GetOutlineWidth(sfShape* shape)
float sfShape_GetOutlineWidth(const sfShape* shape)
{
CSFML_CALL_RETURN(shape, GetOutlineWidth(), 0.f)
}
@ -377,7 +377,7 @@ float sfShape_GetOutlineWidth(sfShape* shape)
////////////////////////////////////////////////////////////
/// Get the number of points composing a shape
////////////////////////////////////////////////////////////
unsigned int sfShape_GetNbPoints(sfShape* shape)
unsigned int sfShape_GetNbPoints(const sfShape* shape)
{
CSFML_CALL_RETURN(shape, GetNbPoints(), 0)
}
@ -386,7 +386,7 @@ unsigned int sfShape_GetNbPoints(sfShape* shape)
////////////////////////////////////////////////////////////
/// Get a point of a shape
////////////////////////////////////////////////////////////
void sfShape_GetPointPosition(sfShape* shape, unsigned int index, float* x, float* y)
void sfShape_GetPointPosition(const sfShape* shape, unsigned int index, float* x, float* y)
{
CSFML_CHECK(shape)
@ -399,7 +399,7 @@ void sfShape_GetPointPosition(sfShape* shape, unsigned int index, float* x, floa
////////////////////////////////////////////////////////////
/// Get a the color of a shape's point
////////////////////////////////////////////////////////////
sfColor sfShape_GetPointColor(sfShape* shape, unsigned int index)
sfColor sfShape_GetPointColor(const sfShape* shape, unsigned int index)
{
sfColor color = {255, 255, 255, 255};
CSFML_CHECK_RETURN(shape, color)
@ -417,7 +417,7 @@ sfColor sfShape_GetPointColor(sfShape* shape, unsigned int index)
////////////////////////////////////////////////////////////
/// Get a the outline color of a shape's point
////////////////////////////////////////////////////////////
sfColor sfShape_GetPointOutlineColor(sfShape* shape, unsigned int index)
sfColor sfShape_GetPointOutlineColor(const sfShape* shape, unsigned int index)
{
sfColor color = {255, 255, 255, 255};
CSFML_CHECK_RETURN(shape, color)

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

@ -151,7 +151,7 @@ void sfSprite_SetBlendMode(sfSprite* sprite, sfBlendMode mode)
////////////////////////////////////////////////////////////
/// Get the X position of a sprite
////////////////////////////////////////////////////////////
float sfSprite_GetX(sfSprite* sprite)
float sfSprite_GetX(const sfSprite* sprite)
{
CSFML_CALL_RETURN(sprite, GetPosition().x, 0.f)
}
@ -160,7 +160,7 @@ float sfSprite_GetX(sfSprite* sprite)
////////////////////////////////////////////////////////////
/// Get the Y position of a sprite
////////////////////////////////////////////////////////////
float sfSprite_GetY(sfSprite* sprite)
float sfSprite_GetY(const sfSprite* sprite)
{
CSFML_CALL_RETURN(sprite, GetPosition().y, 0.f)
}
@ -169,7 +169,7 @@ float sfSprite_GetY(sfSprite* sprite)
////////////////////////////////////////////////////////////
/// Get the horizontal scale of a sprite
////////////////////////////////////////////////////////////
float sfSprite_GetScaleX(sfSprite* sprite)
float sfSprite_GetScaleX(const sfSprite* sprite)
{
CSFML_CALL_RETURN(sprite, GetScale().x, 0.f)
}
@ -178,7 +178,7 @@ float sfSprite_GetScaleX(sfSprite* sprite)
////////////////////////////////////////////////////////////
/// Get the vertical scale of a sprite
////////////////////////////////////////////////////////////
float sfSprite_GetScaleY(sfSprite* sprite)
float sfSprite_GetScaleY(const sfSprite* sprite)
{
CSFML_CALL_RETURN(sprite, GetScale().y, 0.f)
}
@ -187,7 +187,7 @@ float sfSprite_GetScaleY(sfSprite* sprite)
////////////////////////////////////////////////////////////
/// Get the orientation of a sprite
////////////////////////////////////////////////////////////
float sfSprite_GetRotation(sfSprite* sprite)
float sfSprite_GetRotation(const sfSprite* sprite)
{
CSFML_CALL_RETURN(sprite, GetRotation(), 0.f)
}
@ -196,7 +196,7 @@ float sfSprite_GetRotation(sfSprite* sprite)
////////////////////////////////////////////////////////////
/// Get the X position of the origin a sprite
////////////////////////////////////////////////////////////
float sfSprite_GetOriginX(sfSprite* sprite)
float sfSprite_GetOriginX(const sfSprite* sprite)
{
CSFML_CALL_RETURN(sprite, GetOrigin().x, 0.f)
}
@ -205,7 +205,7 @@ float sfSprite_GetOriginX(sfSprite* sprite)
////////////////////////////////////////////////////////////
/// Get the Y position of the origin a sprite
////////////////////////////////////////////////////////////
float sfSprite_GetOriginY(sfSprite* sprite)
float sfSprite_GetOriginY(const sfSprite* sprite)
{
CSFML_CALL_RETURN(sprite, GetOrigin().y, 0.f)
}
@ -214,7 +214,7 @@ float sfSprite_GetOriginY(sfSprite* sprite)
////////////////////////////////////////////////////////////
/// Get the color of a sprite
////////////////////////////////////////////////////////////
sfColor sfSprite_GetColor(sfSprite* sprite)
sfColor sfSprite_GetColor(const sfSprite* sprite)
{
sfColor color = {0, 0, 0, 0};
CSFML_CHECK_RETURN(sprite, color)
@ -227,7 +227,7 @@ sfColor sfSprite_GetColor(sfSprite* sprite)
////////////////////////////////////////////////////////////
/// Get the current blending mode of a sprite
////////////////////////////////////////////////////////////
sfBlendMode sfSprite_GetBlendMode(sfSprite* sprite)
sfBlendMode sfSprite_GetBlendMode(const sfSprite* sprite)
{
CSFML_CHECK_RETURN(sprite, sfBlendNone)
@ -266,7 +266,7 @@ 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(const sfSprite* sprite, float pointX, float pointY, float* x, float* y)
{
CSFML_CHECK(sprite)
@ -280,7 +280,7 @@ 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(const sfSprite* sprite, float pointX, float pointY, float* x, float* y)
{
CSFML_CHECK(sprite)
@ -293,7 +293,7 @@ void sfSprite_TransformToGlobal(sfSprite* sprite, float pointX, float pointY, fl
////////////////////////////////////////////////////////////
/// Change the image of a sprite
////////////////////////////////////////////////////////////
void sfSprite_SetImage(sfSprite* sprite, sfImage* image)
void sfSprite_SetImage(sfSprite* sprite, const sfImage* image)
{
if (image)
{
@ -343,7 +343,7 @@ void sfSprite_FlipY(sfSprite* sprite, sfBool flipped)
////////////////////////////////////////////////////////////
/// Get the source image of a sprite
////////////////////////////////////////////////////////////
sfImage* sfSprite_GetImage(sfSprite* sprite)
const sfImage* sfSprite_GetImage(const sfSprite* sprite)
{
CSFML_CHECK_RETURN(sprite, NULL)
@ -354,7 +354,7 @@ sfImage* sfSprite_GetImage(sfSprite* sprite)
////////////////////////////////////////////////////////////
/// Get the sub-rectangle of a sprite inside the source image
////////////////////////////////////////////////////////////
sfIntRect sfSprite_GetSubRect(sfSprite* sprite)
sfIntRect sfSprite_GetSubRect(const sfSprite* sprite)
{
sfIntRect rect = {0, 0, 0, 0};
CSFML_CHECK_RETURN(sprite, rect)
@ -366,7 +366,7 @@ sfIntRect sfSprite_GetSubRect(sfSprite* sprite)
////////////////////////////////////////////////////////////
/// Get a sprite width
////////////////////////////////////////////////////////////
float sfSprite_GetWidth(sfSprite* sprite)
float sfSprite_GetWidth(const sfSprite* sprite)
{
CSFML_CALL_RETURN(sprite, GetSize().x, 0.f)
}
@ -375,7 +375,7 @@ float sfSprite_GetWidth(sfSprite* sprite)
////////////////////////////////////////////////////////////
/// Get a sprite height
////////////////////////////////////////////////////////////
float sfSprite_GetHeight(sfSprite* sprite)
float sfSprite_GetHeight(const sfSprite* sprite)
{
CSFML_CALL_RETURN(sprite, GetSize().y, 0.f)
}
@ -384,7 +384,7 @@ float sfSprite_GetHeight(sfSprite* sprite)
////////////////////////////////////////////////////////////
/// Get the color of a given pixel in a sprite
////////////////////////////////////////////////////////////
sfColor sfSprite_GetPixel(sfSprite* sprite, unsigned int x, unsigned int y)
sfColor sfSprite_GetPixel(const sfSprite* sprite, unsigned int x, unsigned int y)
{
sfColor color = {0, 0, 0, 0};
CSFML_CHECK_RETURN(sprite, color)

2
CSFML/src/SFML/Graphics/SpriteStruct.h
View File

@ -39,7 +39,7 @@
struct sfSprite
{
sf::Sprite This;
sfImage* Image;
const sfImage* Image;
sfIntRect SubRect;
};

38
CSFML/src/SFML/Graphics/Text.cpp
View File

@ -147,7 +147,7 @@ void sfText_SetBlendMode(sfText* text, sfBlendMode mode)
////////////////////////////////////////////////////////////
/// Get the X position of a text
////////////////////////////////////////////////////////////
float sfText_GetX(sfText* text)
float sfText_GetX(const sfText* text)
{
CSFML_CALL_RETURN(text, GetPosition().x, 0.f)
}
@ -156,7 +156,7 @@ float sfText_GetX(sfText* text)
////////////////////////////////////////////////////////////
/// Get the Y position of a text
////////////////////////////////////////////////////////////
float sfText_GetY(sfText* text)
float sfText_GetY(const sfText* text)
{
CSFML_CALL_RETURN(text, GetPosition().y, 0.f)
}
@ -165,7 +165,7 @@ float sfText_GetY(sfText* text)
////////////////////////////////////////////////////////////
/// Get the horizontal scale of a text
////////////////////////////////////////////////////////////
float sfText_GetScaleX(sfText* text)
float sfText_GetScaleX(const sfText* text)
{
CSFML_CALL_RETURN(text, GetScale().x, 0.f)
}
@ -174,7 +174,7 @@ float sfText_GetScaleX(sfText* text)
////////////////////////////////////////////////////////////
/// Get the vertical scale of a text
////////////////////////////////////////////////////////////
float sfText_GetScaleY(sfText* text)
float sfText_GetScaleY(const sfText* text)
{
CSFML_CALL_RETURN(text, GetScale().y, 0.f)
}
@ -183,7 +183,7 @@ float sfText_GetScaleY(sfText* text)
////////////////////////////////////////////////////////////
/// Get the orientation of a text
////////////////////////////////////////////////////////////
float sfText_GetRotation(sfText* text)
float sfText_GetRotation(const sfText* text)
{
CSFML_CALL_RETURN(text, GetRotation(), 0.f)
}
@ -192,7 +192,7 @@ float sfText_GetRotation(sfText* text)
////////////////////////////////////////////////////////////
/// Get the X position of the origin a text
////////////////////////////////////////////////////////////
float sfText_GetOriginX(sfText* text)
float sfText_GetOriginX(const sfText* text)
{
CSFML_CALL_RETURN(text, GetOrigin().x, 0.f)
}
@ -201,7 +201,7 @@ float sfText_GetOriginX(sfText* text)
////////////////////////////////////////////////////////////
/// Get the top Y of the origin of a text
////////////////////////////////////////////////////////////
float sfText_GetOriginY(sfText* text)
float sfText_GetOriginY(const sfText* text)
{
CSFML_CALL_RETURN(text, GetOrigin().y, 0.f)
}
@ -210,7 +210,7 @@ float sfText_GetOriginY(sfText* text)
////////////////////////////////////////////////////////////
/// Get the color of a text
////////////////////////////////////////////////////////////
sfColor sfText_GetColor(sfText* text)
sfColor sfText_GetColor(const sfText* text)
{
sfColor color = {0, 0, 0, 0};
CSFML_CHECK_RETURN(text, color)
@ -223,7 +223,7 @@ sfColor sfText_GetColor(sfText* text)
////////////////////////////////////////////////////////////
/// Get the current blending mode of a text
////////////////////////////////////////////////////////////
sfBlendMode sfText_GetBlendMode(sfText* text)
sfBlendMode sfText_GetBlendMode(const sfText* text)
{
CSFML_CHECK_RETURN(text, sfBlendNone)
@ -262,7 +262,7 @@ void sfText_Rotate(sfText* text, float angle)
/// Transform a point from global coordinates into the text's local coordinates
/// (ie it applies the inverse of object's origin, translation, rotation and scale to the point)
////////////////////////////////////////////////////////////
void sfText_TransformToLocal(sfText* text, float pointX, float pointY, float* x, float* y)
void sfText_TransformToLocal(const sfText* text, float pointX, float pointY, float* x, float* y)
{
CSFML_CHECK(text)
@ -276,7 +276,7 @@ void sfText_TransformToLocal(sfText* text, float pointX, float pointY, float* x,
/// Transform a point from the text's local coordinates into global coordinates
/// (ie it applies the object's origin, translation, rotation and scale to the point)
////////////////////////////////////////////////////////////
void sfText_TransformToGlobal(sfText* text, float pointX, float pointY, float* x, float* y)
void sfText_TransformToGlobal(const sfText* text, float pointX, float pointY, float* x, float* y)
{
CSFML_CHECK(text)
@ -308,7 +308,7 @@ void sfText_SetUnicodeString(sfText* text, const sfUint32* string)
////////////////////////////////////////////////////////////
/// Set the font of a string
////////////////////////////////////////////////////////////
void sfText_SetFont(sfText* text, sfFont* font)
void sfText_SetFont(sfText* text, const sfFont* font)
{
CSFML_CHECK(font);
@ -338,7 +338,7 @@ void sfText_SetStyle(sfText* text, unsigned long style)
////////////////////////////////////////////////////////////
/// Get the string of a text (returns a unicode string)
////////////////////////////////////////////////////////////
const sfUint32* sfText_GetUnicodeString(sfText* text)
const sfUint32* sfText_GetUnicodeString(const sfText* text)
{
CSFML_CHECK_RETURN(text, NULL)
@ -349,7 +349,7 @@ const sfUint32* sfText_GetUnicodeString(sfText* text)
////////////////////////////////////////////////////////////
/// Get the string of a text (returns an ANSI string)
////////////////////////////////////////////////////////////
const char* sfText_GetString(sfText* text)
const char* sfText_GetString(const sfText* text)
{
CSFML_CHECK_RETURN(text, NULL)
@ -362,7 +362,7 @@ const char* sfText_GetString(sfText* text)
////////////////////////////////////////////////////////////
/// Get the font used by a text
////////////////////////////////////////////////////////////
sfFont* sfText_GetFont(sfText* text)
const sfFont* sfText_GetFont(const sfText* text)
{
CSFML_CHECK_RETURN(text, NULL)
@ -373,7 +373,7 @@ sfFont* sfText_GetFont(sfText* text)
////////////////////////////////////////////////////////////
/// Get the size of the characters of a text
////////////////////////////////////////////////////////////
float sfText_GetSize(sfText* text)
float sfText_GetSize(const sfText* text)
{
CSFML_CALL_RETURN(text, GetSize(), 0.f)
}
@ -382,7 +382,7 @@ float sfText_GetSize(sfText* text)
////////////////////////////////////////////////////////////
/// Get the style of a text
////////////////////////////////////////////////////////////
unsigned long sfText_GetStyle(sfText* text)
unsigned long sfText_GetStyle(const sfText* text)
{
CSFML_CALL_RETURN(text, GetStyle(), 0)
}
@ -393,7 +393,7 @@ unsigned long sfText_GetStyle(sfText* text)
/// in coordinates relative to the text
/// (note : translation, origin, rotation and scale are not applied)
////////////////////////////////////////////////////////////
void sfText_GetCharacterPos(sfText* text, size_t index, float* x, float* y)
void sfText_GetCharacterPos(const sfText* text, size_t index, float* x, float* y)
{
CSFML_CHECK(text);
@ -406,7 +406,7 @@ void sfText_GetCharacterPos(sfText* text, size_t index, float* x, float* y)
////////////////////////////////////////////////////////////
/// Get the bounding rectangle of a text on screen
////////////////////////////////////////////////////////////
sfFloatRect sfText_GetRect(sfText* text)
sfFloatRect sfText_GetRect(const sfText* text)
{
sfFloatRect rect = {0.f, 0.f, 0.f, 0.f};
CSFML_CHECK_RETURN(text, rect)

6
CSFML/src/SFML/Graphics/TextStruct.h
View File

@ -40,9 +40,9 @@
struct sfText
{
sf::Text This;
std::string String;
sfFont* Font;
sfFloatRect Rect;
const sfFont* Font;
mutable std::string String;
mutable sfFloatRect Rect;
};

12
CSFML/src/SFML/Graphics/View.cpp
View File

@ -106,7 +106,7 @@ void sfView_Reset(sfView* View, sfFloatRect Rectangle)
////////////////////////////////////////////////////////////
/// Get the X coordinate of the center of a view
////////////////////////////////////////////////////////////
float sfView_GetCenterX(sfView* View)
float sfView_GetCenterX(const sfView* View)
{
CSFML_CHECK_RETURN(View, 0.f);
@ -117,7 +117,7 @@ float sfView_GetCenterX(sfView* View)
////////////////////////////////////////////////////////////
/// Get the Y coordinate of the center of a view
////////////////////////////////////////////////////////////
float sfView_GetCenterY(sfView* View)
float sfView_GetCenterY(const sfView* View)
{
CSFML_CHECK_RETURN(View, 0.f);
@ -128,7 +128,7 @@ float sfView_GetCenterY(sfView* View)
////////////////////////////////////////////////////////////
/// Get the width of the view
////////////////////////////////////////////////////////////
float sfView_GetWidth(sfView* View)
float sfView_GetWidth(const sfView* View)
{
CSFML_CHECK_RETURN(View, 0.f);
@ -139,7 +139,7 @@ float sfView_GetWidth(sfView* View)
////////////////////////////////////////////////////////////
/// Get the height of the view
////////////////////////////////////////////////////////////
float sfView_GetHeight(sfView* View)
float sfView_GetHeight(const sfView* View)
{
CSFML_CHECK_RETURN(View, 0.f);
@ -150,7 +150,7 @@ float sfView_GetHeight(sfView* View)
////////////////////////////////////////////////////////////
/// Get the current rotation of a view
////////////////////////////////////////////////////////////
float sfView_GetRotation(sfView* View)
float sfView_GetRotation(const sfView* View)
{
CSFML_CALL_PTR_RETURN(View, GetRotation(), 0.f);
}
@ -159,7 +159,7 @@ float sfView_GetRotation(sfView* View)
////////////////////////////////////////////////////////////
/// Get the target viewport of a view
////////////////////////////////////////////////////////////
sfFloatRect sfView_GetViewport(sfView* View)
sfFloatRect sfView_GetViewport(const sfView* View)
{
sfFloatRect Rect = {0, 0, 0, 0};
CSFML_CHECK_RETURN(View, Rect);

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

@ -43,7 +43,7 @@ void sfFtpListingResponse_Destroy(sfFtpListingResponse* ftpListingResponse)
/// Convenience function to check if the response status code
/// means a success
////////////////////////////////////////////////////////////
sfBool sfFtpListingResponse_IsOk(sfFtpListingResponse* ftpListingResponse)
sfBool sfFtpListingResponse_IsOk(const sfFtpListingResponse* ftpListingResponse)
{
CSFML_CALL_RETURN(ftpListingResponse, IsOk(), sfFalse);
}
@ -51,7 +51,7 @@ sfBool sfFtpListingResponse_IsOk(sfFtpListingResponse* ftpListingResponse)
////////////////////////////////////////////////////////////
/// Get the response status code
////////////////////////////////////////////////////////////
sfFtpStatus sfFtpListingResponse_GetStatus(sfFtpListingResponse* ftpListingResponse)
sfFtpStatus sfFtpListingResponse_GetStatus(const sfFtpListingResponse* ftpListingResponse)
{
CSFML_CHECK_RETURN(ftpListingResponse, sfFtpInvalidResponse);
@ -61,7 +61,7 @@ sfFtpStatus sfFtpListingResponse_GetStatus(sfFtpListingResponse* ftpListingRespo
////////////////////////////////////////////////////////////
/// Get the full message contained in the response
////////////////////////////////////////////////////////////
const char* sfFtpListingResponse_GetMessage(sfFtpListingResponse* ftpListingResponse)
const char* sfFtpListingResponse_GetMessage(const sfFtpListingResponse* ftpListingResponse)
{
CSFML_CHECK_RETURN(ftpListingResponse, NULL);
@ -71,7 +71,7 @@ const char* sfFtpListingResponse_GetMessage(sfFtpListingResponse* ftpListingResp
////////////////////////////////////////////////////////////
/// Get the number of filenames in the listing
////////////////////////////////////////////////////////////
size_t sfFtpListingResponse_GetCount(sfFtpListingResponse* ftpListingResponse)
size_t sfFtpListingResponse_GetCount(const sfFtpListingResponse* ftpListingResponse)
{
CSFML_CALL_RETURN(ftpListingResponse, GetCount(), 0);
}
@ -79,7 +79,7 @@ size_t sfFtpListingResponse_GetCount(sfFtpListingResponse* ftpListingResponse)
////////////////////////////////////////////////////////////
/// Get the Index-th filename in the directory
////////////////////////////////////////////////////////////
const char* sfFtpListingResponse_GetFilename(sfFtpListingResponse* ftpListingResponse, size_t index)
const char* sfFtpListingResponse_GetFilename(const sfFtpListingResponse* ftpListingResponse, size_t index)
{
CSFML_CHECK_RETURN(ftpListingResponse, NULL);
@ -99,7 +99,7 @@ void sfFtpDirectoryResponse_Destroy(sfFtpDirectoryResponse* ftpDirectoryResponse
/// Convenience function to check if the response status code
/// means a success
////////////////////////////////////////////////////////////
sfBool sfFtpDirectoryResponse_IsOk(sfFtpDirectoryResponse* ftpDirectoryResponse)
sfBool sfFtpDirectoryResponse_IsOk(const sfFtpDirectoryResponse* ftpDirectoryResponse)
{
CSFML_CALL_RETURN(ftpDirectoryResponse, IsOk(), sfFalse);
}
@ -107,7 +107,7 @@ sfBool sfFtpDirectoryResponse_IsOk(sfFtpDirectoryResponse* ftpDirectoryResponse)
////////////////////////////////////////////////////////////
/// Get the response status code
////////////////////////////////////////////////////////////
sfFtpStatus sfFtpDirectoryResponse_GetStatus(sfFtpDirectoryResponse* ftpDirectoryResponse)
sfFtpStatus sfFtpDirectoryResponse_GetStatus(const sfFtpDirectoryResponse* ftpDirectoryResponse)
{
CSFML_CHECK_RETURN(ftpDirectoryResponse, sfFtpInvalidResponse);
@ -117,7 +117,7 @@ sfFtpStatus sfFtpDirectoryResponse_GetStatus(sfFtpDirectoryResponse* ftpDirector
////////////////////////////////////////////////////////////
/// Get the full message contained in the response
////////////////////////////////////////////////////////////
const char* sfFtpDirectoryResponse_GetMessage(sfFtpDirectoryResponse* ftpDirectoryResponse)
const char* sfFtpDirectoryResponse_GetMessage(const sfFtpDirectoryResponse* ftpDirectoryResponse)
{
CSFML_CHECK_RETURN(ftpDirectoryResponse, NULL);
@ -127,7 +127,7 @@ const char* sfFtpDirectoryResponse_GetMessage(sfFtpDirectoryResponse* ftpDirecto
////////////////////////////////////////////////////////////
/// Get the directory returned in the response
////////////////////////////////////////////////////////////
const char* sfFtpDirectoryResponse_GetDirectory(sfFtpDirectoryResponse* ftpDirectoryResponse)
const char* sfFtpDirectoryResponse_GetDirectory(const sfFtpDirectoryResponse* ftpDirectoryResponse)
{
CSFML_CHECK_RETURN(ftpDirectoryResponse, NULL);
@ -148,7 +148,7 @@ 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(const sfFtpResponse* ftpResponse)
{
CSFML_CALL_RETURN(ftpResponse, IsOk(), sfFalse);
}
@ -157,7 +157,7 @@ sfBool sfFtpResponse_IsOk(sfFtpResponse* ftpResponse)
////////////////////////////////////////////////////////////
/// Get the response status code
////////////////////////////////////////////////////////////
sfFtpStatus sfFtpResponse_GetStatus(sfFtpResponse* ftpResponse)
sfFtpStatus sfFtpResponse_GetStatus(const sfFtpResponse* ftpResponse)
{
CSFML_CHECK_RETURN(ftpResponse, sfFtpInvalidResponse);
@ -168,7 +168,7 @@ sfFtpStatus sfFtpResponse_GetStatus(sfFtpResponse* ftpResponse)
////////////////////////////////////////////////////////////
/// Get the full message contained in the response
////////////////////////////////////////////////////////////
const char* sfFtpResponse_GetMessage(sfFtpResponse* ftpResponse)
const char* sfFtpResponse_GetMessage(const sfFtpResponse* ftpResponse)
{
CSFML_CHECK_RETURN(ftpResponse, NULL);

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

@ -112,7 +112,7 @@ void sfHttpResponse_Destroy(sfHttpResponse* 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(const sfHttpResponse* httpResponse, const char* field)
{
CSFML_CHECK_RETURN(httpResponse, NULL);
if (!field)
@ -125,7 +125,7 @@ const char* sfHttpResponse_GetField(sfHttpResponse* httpResponse, const char* fi
////////////////////////////////////////////////////////////
/// Get the status of a response
////////////////////////////////////////////////////////////
sfHttpStatus sfHttpResponse_GetStatus(sfHttpResponse* httpResponse)
sfHttpStatus sfHttpResponse_GetStatus(const sfHttpResponse* httpResponse)
{
CSFML_CHECK_RETURN(httpResponse, sfHttpInvalidResponse);
@ -136,7 +136,7 @@ sfHttpStatus sfHttpResponse_GetStatus(sfHttpResponse* httpResponse)
////////////////////////////////////////////////////////////
/// Get the major HTTP version of a response
////////////////////////////////////////////////////////////
unsigned int sfHttpResponse_GetMajorVersion(sfHttpResponse* httpResponse)
unsigned int sfHttpResponse_GetMajorVersion(const sfHttpResponse* httpResponse)
{
CSFML_CALL_RETURN(httpResponse, GetMajorHttpVersion(), 0);
}
@ -145,7 +145,7 @@ unsigned int sfHttpResponse_GetMajorVersion(sfHttpResponse* httpResponse)
////////////////////////////////////////////////////////////
/// Get the minor HTTP version of a response
////////////////////////////////////////////////////////////
unsigned int sfHttpResponse_GetMinorVersion(sfHttpResponse* httpResponse)
unsigned int sfHttpResponse_GetMinorVersion(const sfHttpResponse* httpResponse)
{
CSFML_CALL_RETURN(httpResponse, GetMinorHttpVersion(), 0);
}
@ -158,7 +158,7 @@ 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(const sfHttpResponse* httpResponse)
{
CSFML_CHECK_RETURN(httpResponse, NULL);
@ -201,7 +201,7 @@ 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, const sfHttpRequest* request, float timeout)
{
CSFML_CHECK_RETURN(http, NULL);
CSFML_CHECK_RETURN(request, NULL);

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

@ -79,7 +79,7 @@ void sfPacket_Destroy(sfPacket* packet)
////////////////////////////////////////////////////////////
/// Append data to the end of a packet
////////////////////////////////////////////////////////////
void sfPacket_Append(sfPacket* packet, void* data, size_t sizeInBytes)
void sfPacket_Append(sfPacket* packet, const void* data, size_t sizeInBytes)
{
CSFML_CALL(packet, Append(data, sizeInBytes));
}
@ -99,7 +99,7 @@ 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(const sfPacket* packet)
{
CSFML_CALL_RETURN(packet, GetData(), NULL);
}
@ -108,7 +108,7 @@ const char* sfPacket_GetData(sfPacket* packet)
////////////////////////////////////////////////////////////
/// Get the size of the data contained in a packet
////////////////////////////////////////////////////////////
size_t sfPacket_GetDataSize(sfPacket* packet)
size_t sfPacket_GetDataSize(const sfPacket* packet)
{
CSFML_CALL_RETURN(packet, GetDataSize(), 0);
}
@ -117,7 +117,7 @@ size_t sfPacket_GetDataSize(sfPacket* packet)
////////////////////////////////////////////////////////////
/// Tell if the reading position has reached the end of the packet
////////////////////////////////////////////////////////////
sfBool sfPacket_EndOfPacket(sfPacket* packet)
sfBool sfPacket_EndOfPacket(const sfPacket* packet)
{
CSFML_CALL_RETURN(packet, EndOfPacket(), sfFalse);
}
@ -126,7 +126,7 @@ sfBool sfPacket_EndOfPacket(sfPacket* packet)
////////////////////////////////////////////////////////////
/// Check if a packet is in a valid reading state
////////////////////////////////////////////////////////////
sfBool sfPacket_CanRead(sfPacket* packet)
sfBool sfPacket_CanRead(const sfPacket* packet)
{
CSFML_CALL_RETURN(packet, operator bool(), sfFalse);
}

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

@ -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(const sfSelectorTCP* selector, unsigned int index)
{
CSFML_CHECK_RETURN(selector, NULL);
return selector->Sockets[selector->This.GetSocketReady(index)];
return selector->Sockets.find(selector->This.GetSocketReady(index))->second;
}
sfSocketUDP* sfSelectorUDP_GetSocketReady(sfSelectorUDP* selector, unsigned int index)
sfSocketUDP* sfSelectorUDP_GetSocketReady(const sfSelectorUDP* selector, unsigned int index)
{
CSFML_CHECK_RETURN(selector, NULL);
return selector->Sockets[selector->This.GetSocketReady(index)];
return selector->Sockets.find(selector->This.GetSocketReady(index))->second;
}

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

@ -183,7 +183,7 @@ sfBool sfSocketTCP_Close(sfSocketTCP* socket)
/// 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(const sfSocketTCP* socket)
{
CSFML_CALL_RETURN(socket, IsValid(), sfFalse);
}

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

@ -47,7 +47,11 @@ sfSocketUDP* sfSocketUDP_Create()
////////////////////////////////////////////////////////////
void sfSocketUDP_Destroy(sfSocketUDP* socket)
{
if (socket)
{
socket->This.Close();
delete socket;
}
}
@ -178,7 +182,7 @@ sfBool sfSocketUDP_Close(sfSocketUDP* socket)
/// 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(const sfSocketUDP* socket)
{
CSFML_CALL_RETURN(socket, IsValid(), sfFalse);
}

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

@ -51,7 +51,7 @@ void sfClock_Destroy(sfClock* clock)
////////////////////////////////////////////////////////////
/// Get the time elapsed for a clock
////////////////////////////////////////////////////////////
float sfClock_GetTime(sfClock* clock)
float sfClock_GetTime(const sfClock* clock)
{
CSFML_CALL_RETURN(clock, GetElapsedTime(), 0.f)
}

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

@ -34,7 +34,7 @@
////////////////////////////////////////////////////////////
/// Construct a new window
////////////////////////////////////////////////////////////
sfWindow* sfWindow_Create(sfVideoMode mode, const char* title, unsigned long style, sfContextSettings* settings)
sfWindow* sfWindow_Create(sfVideoMode mode, const char* title, unsigned long style, const sfContextSettings* settings)
{
// Convert video mode
sf::VideoMode videoMode(mode.Width, mode.Height, mode.BitsPerPixel);
@ -62,7 +62,7 @@ sfWindow* sfWindow_Create(sfVideoMode mode, const char* title, unsigned long sty
////////////////////////////////////////////////////////////
/// Construct a window from an existing control
////////////////////////////////////////////////////////////
sfWindow* sfWindow_CreateFromHandle(sfWindowHandle handle, sfContextSettings* settings)
sfWindow* sfWindow_CreateFromHandle(sfWindowHandle handle, const sfContextSettings* settings)
{
// Convert context settings
sf::ContextSettings params;
@ -104,7 +104,7 @@ void sfWindow_Close(sfWindow* window)
////////////////////////////////////////////////////////////
/// Tell whether or not a window is opened
////////////////////////////////////////////////////////////
sfBool sfWindow_IsOpened(sfWindow* window)
sfBool sfWindow_IsOpened(const sfWindow* window)
{
CSFML_CALL_RETURN(window, IsOpened(), sfFalse);
}
@ -113,7 +113,7 @@ sfBool sfWindow_IsOpened(sfWindow* window)
////////////////////////////////////////////////////////////
/// Get the width of the rendering region of a window
////////////////////////////////////////////////////////////
unsigned int sfWindow_GetWidth(sfWindow* window)
unsigned int sfWindow_GetWidth(const sfWindow* window)
{
CSFML_CALL_RETURN(window, GetWidth(), 0)
}
@ -122,7 +122,7 @@ unsigned int sfWindow_GetWidth(sfWindow* window)
////////////////////////////////////////////////////////////
/// Get the height of the rendering region of a window
////////////////////////////////////////////////////////////
unsigned int sfWindow_GetHeight(sfWindow* window)
unsigned int sfWindow_GetHeight(const sfWindow* window)
{
CSFML_CALL_RETURN(window, GetHeight(), 0)
}
@ -131,7 +131,7 @@ unsigned int sfWindow_GetHeight(sfWindow* window)
////////////////////////////////////////////////////////////
/// Get the creation settings of a window
////////////////////////////////////////////////////////////
sfContextSettings sfWindow_GetSettings(sfWindow* window)
sfContextSettings sfWindow_GetSettings(const sfWindow* window)
{
sfContextSettings settings = {0, 0, 0};
CSFML_CHECK_RETURN(window, settings);
@ -259,7 +259,7 @@ void sfWindow_EnableKeyRepeat(sfWindow* window, sfBool enabled)
////////////////////////////////////////////////////////////
/// 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, const sfUint8* pixels)
{
CSFML_CALL(window, SetIcon(width, height, pixels))
}
@ -286,7 +286,7 @@ void sfWindow_Display(sfWindow* window)
////////////////////////////////////////////////////////////
/// Get the input manager of a window
////////////////////////////////////////////////////////////
sfInput* sfWindow_GetInput(sfWindow* window)
const sfInput* sfWindow_GetInput(sfWindow* window)
{
CSFML_CHECK_RETURN(window, NULL);
@ -306,7 +306,7 @@ void sfWindow_SetFramerateLimit(sfWindow* window, unsigned int limit)
////////////////////////////////////////////////////////////
/// Get time elapsed since last frame of a window
////////////////////////////////////////////////////////////
float sfWindow_GetFrameTime(sfWindow* window)
float sfWindow_GetFrameTime(const sfWindow* window)
{
CSFML_CALL_RETURN(window, GetFrameTime(), 0.f)
}

2
build/codeblocks/sfml-network.cbp
View File

@ -28,6 +28,7 @@
</ResourceCompiler>
<Linker>
<Add library="ws2_32" />
<Add library="..\..\lib\mingw\libsfml-system-d.a" />
<Add directory="..\..\bin\static" />
</Linker>
</Target>
@ -52,6 +53,7 @@
</ResourceCompiler>
<Linker>
<Add library="ws2_32" />
<Add library="..\..\lib\mingw\libsfml-system.a" />
<Add directory="..\..\bin\static" />
</Linker>
</Target>

51
build/vc2005/SFML.sln
View File

@ -8,13 +8,16 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sfml-audio", "sfml-audio.vc
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sfml-graphics", "sfml-graphics.vcproj", "{FA4620B1-393A-4719-9BB4-3BC8CAA70C4B}"
ProjectSection(ProjectDependencies) = postProject
{0F9CE5F0-4D89-4314-9147-8AAB1B8842ED} = {0F9CE5F0-4D89-4314-9147-8AAB1B8842ED}
{C061A27D-7CA0-4179-9869-672FA04A86A8} = {C061A27D-7CA0-4179-9869-672FA04A86A8}
{0F9CE5F0-4D89-4314-9147-8AAB1B8842ED} = {0F9CE5F0-4D89-4314-9147-8AAB1B8842ED}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sfml-main", "sfml-main.vcproj", "{2BD26A09-E1B6-42E2-A0D0-63987B76BB97}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sfml-network", "sfml-network.vcproj", "{823DDC98-42D5-4A38-88CF-9DC06C788AE4}"
ProjectSection(ProjectDependencies) = postProject
{C061A27D-7CA0-4179-9869-672FA04A86A8} = {C061A27D-7CA0-4179-9869-672FA04A86A8}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sfml-system", "sfml-system.vcproj", "{C061A27D-7CA0-4179-9869-672FA04A86A8}"
EndProject
@ -25,10 +28,10 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sfml-window", "sfml-window.
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "opengl", "..\..\samples\build\vc2005\opengl.vcproj", "{4CD9A872-16EF-4C53-81FC-C7E77E782718}"
ProjectSection(ProjectDependencies) = postProject
{2BD26A09-E1B6-42E2-A0D0-63987B76BB97} = {2BD26A09-E1B6-42E2-A0D0-63987B76BB97}
{C061A27D-7CA0-4179-9869-672FA04A86A8} = {C061A27D-7CA0-4179-9869-672FA04A86A8}
{FA4620B1-393A-4719-9BB4-3BC8CAA70C4B} = {FA4620B1-393A-4719-9BB4-3BC8CAA70C4B}
{0F9CE5F0-4D89-4314-9147-8AAB1B8842ED} = {0F9CE5F0-4D89-4314-9147-8AAB1B8842ED}
{FA4620B1-393A-4719-9BB4-3BC8CAA70C4B} = {FA4620B1-393A-4719-9BB4-3BC8CAA70C4B}
{C061A27D-7CA0-4179-9869-672FA04A86A8} = {C061A27D-7CA0-4179-9869-672FA04A86A8}
{2BD26A09-E1B6-42E2-A0D0-63987B76BB97} = {2BD26A09-E1B6-42E2-A0D0-63987B76BB97}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sockets", "..\..\samples\build\vc2005\sockets.vcproj", "{E6ED898F-218E-4467-8B1D-92E393283E1B}"
@ -38,58 +41,58 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sockets", "..\..\samples\bu
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sound", "..\..\samples\build\vc2005\sound.vcproj", "{11E3764D-850E-4EDA-9823-F66383A11042}"
ProjectSection(ProjectDependencies) = postProject
{B1BDA469-E6A7-4AF7-BDF9-EDDD7AD979A2} = {B1BDA469-E6A7-4AF7-BDF9-EDDD7AD979A2}
{C061A27D-7CA0-4179-9869-672FA04A86A8} = {C061A27D-7CA0-4179-9869-672FA04A86A8}
{B1BDA469-E6A7-4AF7-BDF9-EDDD7AD979A2} = {B1BDA469-E6A7-4AF7-BDF9-EDDD7AD979A2}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sound-capture", "..\..\samples\build\vc2005\sound-capture.vcproj", "{34EBDA13-AFA3-4AD9-AB64-2B2D40E09573}"
ProjectSection(ProjectDependencies) = postProject
{C061A27D-7CA0-4179-9869-672FA04A86A8} = {C061A27D-7CA0-4179-9869-672FA04A86A8}
{B1BDA469-E6A7-4AF7-BDF9-EDDD7AD979A2} = {B1BDA469-E6A7-4AF7-BDF9-EDDD7AD979A2}
{C061A27D-7CA0-4179-9869-672FA04A86A8} = {C061A27D-7CA0-4179-9869-672FA04A86A8}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "voip", "..\..\samples\build\vc2005\voip.vcproj", "{4B169017-FFDD-4588-9658-6F1C9ABC6495}"
ProjectSection(ProjectDependencies) = postProject
{B1BDA469-E6A7-4AF7-BDF9-EDDD7AD979A2} = {B1BDA469-E6A7-4AF7-BDF9-EDDD7AD979A2}
{C061A27D-7CA0-4179-9869-672FA04A86A8} = {C061A27D-7CA0-4179-9869-672FA04A86A8}
{823DDC98-42D5-4A38-88CF-9DC06C788AE4} = {823DDC98-42D5-4A38-88CF-9DC06C788AE4}
{C061A27D-7CA0-4179-9869-672FA04A86A8} = {C061A27D-7CA0-4179-9869-672FA04A86A8}
{B1BDA469-E6A7-4AF7-BDF9-EDDD7AD979A2} = {B1BDA469-E6A7-4AF7-BDF9-EDDD7AD979A2}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "win32", "..\..\samples\build\vc2005\win32.vcproj", "{303EC049-639D-4F9C-9F33-D4B7F702275B}"
ProjectSection(ProjectDependencies) = postProject
{0F9CE5F0-4D89-4314-9147-8AAB1B8842ED} = {0F9CE5F0-4D89-4314-9147-8AAB1B8842ED}
{FA4620B1-393A-4719-9BB4-3BC8CAA70C4B} = {FA4620B1-393A-4719-9BB4-3BC8CAA70C4B}
{C061A27D-7CA0-4179-9869-672FA04A86A8} = {C061A27D-7CA0-4179-9869-672FA04A86A8}
{FA4620B1-393A-4719-9BB4-3BC8CAA70C4B} = {FA4620B1-393A-4719-9BB4-3BC8CAA70C4B}
{0F9CE5F0-4D89-4314-9147-8AAB1B8842ED} = {0F9CE5F0-4D89-4314-9147-8AAB1B8842ED}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "window", "..\..\samples\build\vc2005\window.vcproj", "{11E9ABEF-17A5-4FF7-91E5-994F34172F68}"
ProjectSection(ProjectDependencies) = postProject
{C061A27D-7CA0-4179-9869-672FA04A86A8} = {C061A27D-7CA0-4179-9869-672FA04A86A8}
{0F9CE5F0-4D89-4314-9147-8AAB1B8842ED} = {0F9CE5F0-4D89-4314-9147-8AAB1B8842ED}
{2BD26A09-E1B6-42E2-A0D0-63987B76BB97} = {2BD26A09-E1B6-42E2-A0D0-63987B76BB97}
{0F9CE5F0-4D89-4314-9147-8AAB1B8842ED} = {0F9CE5F0-4D89-4314-9147-8AAB1B8842ED}
{C061A27D-7CA0-4179-9869-672FA04A86A8} = {C061A27D-7CA0-4179-9869-672FA04A86A8}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "wxwidgets", "..\..\samples\build\vc2005\wxwidgets.vcproj", "{8B3B274A-B3B7-4C6B-8D4A-5334E2116830}"
ProjectSection(ProjectDependencies) = postProject
{0F9CE5F0-4D89-4314-9147-8AAB1B8842ED} = {0F9CE5F0-4D89-4314-9147-8AAB1B8842ED}
{FA4620B1-393A-4719-9BB4-3BC8CAA70C4B} = {FA4620B1-393A-4719-9BB4-3BC8CAA70C4B}
{C061A27D-7CA0-4179-9869-672FA04A86A8} = {C061A27D-7CA0-4179-9869-672FA04A86A8}
{FA4620B1-393A-4719-9BB4-3BC8CAA70C4B} = {FA4620B1-393A-4719-9BB4-3BC8CAA70C4B}
{0F9CE5F0-4D89-4314-9147-8AAB1B8842ED} = {0F9CE5F0-4D89-4314-9147-8AAB1B8842ED}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "qt", "..\..\samples\build\vc2005\qt.vcproj", "{EAB1A0A4-8CCC-4A74-B3B5-9F60243581D2}"
ProjectSection(ProjectDependencies) = postProject
{C061A27D-7CA0-4179-9869-672FA04A86A8} = {C061A27D-7CA0-4179-9869-672FA04A86A8}
{FA4620B1-393A-4719-9BB4-3BC8CAA70C4B} = {FA4620B1-393A-4719-9BB4-3BC8CAA70C4B}
{0F9CE5F0-4D89-4314-9147-8AAB1B8842ED} = {0F9CE5F0-4D89-4314-9147-8AAB1B8842ED}
{FA4620B1-393A-4719-9BB4-3BC8CAA70C4B} = {FA4620B1-393A-4719-9BB4-3BC8CAA70C4B}
{C061A27D-7CA0-4179-9869-672FA04A86A8} = {C061A27D-7CA0-4179-9869-672FA04A86A8}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "pong", "..\..\samples\build\vc2005\pong.vcproj", "{DDDE27DC-5568-43EE-BD0E-57C581F73EDE}"
ProjectSection(ProjectDependencies) = postProject
{2BD26A09-E1B6-42E2-A0D0-63987B76BB97} = {2BD26A09-E1B6-42E2-A0D0-63987B76BB97}
{B1BDA469-E6A7-4AF7-BDF9-EDDD7AD979A2} = {B1BDA469-E6A7-4AF7-BDF9-EDDD7AD979A2}
{0F9CE5F0-4D89-4314-9147-8AAB1B8842ED} = {0F9CE5F0-4D89-4314-9147-8AAB1B8842ED}
{FA4620B1-393A-4719-9BB4-3BC8CAA70C4B} = {FA4620B1-393A-4719-9BB4-3BC8CAA70C4B}
{C061A27D-7CA0-4179-9869-672FA04A86A8} = {C061A27D-7CA0-4179-9869-672FA04A86A8}
{FA4620B1-393A-4719-9BB4-3BC8CAA70C4B} = {FA4620B1-393A-4719-9BB4-3BC8CAA70C4B}
{0F9CE5F0-4D89-4314-9147-8AAB1B8842ED} = {0F9CE5F0-4D89-4314-9147-8AAB1B8842ED}
{B1BDA469-E6A7-4AF7-BDF9-EDDD7AD979A2} = {B1BDA469-E6A7-4AF7-BDF9-EDDD7AD979A2}
{2BD26A09-E1B6-42E2-A0D0-63987B76BB97} = {2BD26A09-E1B6-42E2-A0D0-63987B76BB97}
EndProjectSection
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "SFML", "SFML", "{C6D36691-1669-4189-AAB8-06C9932C2A45}"
@ -98,16 +101,16 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Samples", "Samples", "{3EE1
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ftp", "..\..\samples\build\vc2005\ftp.vcproj", "{7236920B-254C-43A3-9DC1-778B477226DF}"
ProjectSection(ProjectDependencies) = postProject
{823DDC98-42D5-4A38-88CF-9DC06C788AE4} = {823DDC98-42D5-4A38-88CF-9DC06C788AE4}
{C061A27D-7CA0-4179-9869-672FA04A86A8} = {C061A27D-7CA0-4179-9869-672FA04A86A8}
{823DDC98-42D5-4A38-88CF-9DC06C788AE4} = {823DDC98-42D5-4A38-88CF-9DC06C788AE4}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "shader", "..\..\samples\build\vc2005\shader.vcproj", "{E8B7727D-2308-4ADC-90AE-D3F46798447D}"
ProjectSection(ProjectDependencies) = postProject
{2BD26A09-E1B6-42E2-A0D0-63987B76BB97} = {2BD26A09-E1B6-42E2-A0D0-63987B76BB97}
{C061A27D-7CA0-4179-9869-672FA04A86A8} = {C061A27D-7CA0-4179-9869-672FA04A86A8}
{FA4620B1-393A-4719-9BB4-3BC8CAA70C4B} = {FA4620B1-393A-4719-9BB4-3BC8CAA70C4B}
{0F9CE5F0-4D89-4314-9147-8AAB1B8842ED} = {0F9CE5F0-4D89-4314-9147-8AAB1B8842ED}
{FA4620B1-393A-4719-9BB4-3BC8CAA70C4B} = {FA4620B1-393A-4719-9BB4-3BC8CAA70C4B}
{C061A27D-7CA0-4179-9869-672FA04A86A8} = {C061A27D-7CA0-4179-9869-672FA04A86A8}
{2BD26A09-E1B6-42E2-A0D0-63987B76BB97} = {2BD26A09-E1B6-42E2-A0D0-63987B76BB97}
EndProjectSection
EndProject
Global

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

@ -89,7 +89,7 @@ public :
/// \return The index-th socket
///
////////////////////////////////////////////////////////////
Type GetSocketReady(unsigned int index);
Type GetSocketReady(unsigned int index) const;
private :

2
include/SFML/Network/Selector.inl
View File

@ -85,7 +85,7 @@ unsigned int Selector<Type>::Wait(float timeout)
/// is the integer returned by the previous call to Wait()
////////////////////////////////////////////////////////////
template <typename Type>
Type Selector<Type>::GetSocketReady(unsigned int index)
Type Selector<Type>::GetSocketReady(unsigned int index) const
{
SocketHelper::SocketType socket = SelectorBase::GetSocketReady(index);

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

@ -94,7 +94,7 @@ public :
/// \return The index-th socket
///
////////////////////////////////////////////////////////////
SocketHelper::SocketType GetSocketReady(unsigned int index);
SocketHelper::SocketType GetSocketReady(unsigned int index) const;
private :

2
src/SFML/Network/SelectorBase.cpp
View File

@ -105,7 +105,7 @@ unsigned int SelectorBase::Wait(float timeout)
/// ready for reading. The total number of sockets ready
/// is the integer returned by the previous call to Wait()
////////////////////////////////////////////////////////////
SocketHelper::SocketType SelectorBase::GetSocketReady(unsigned int index)
SocketHelper::SocketType SelectorBase::GetSocketReady(unsigned int index) const
{
// The standard FD_xxx interface doesn't define a direct access,
// so we must go through the whole set to find the socket we're looking for