diff options
| author | James Cowgill <james410@cowgill.org.uk> | 2013-08-23 09:57:55 +0100 |
|---|---|---|
| committer | James Cowgill <james410@cowgill.org.uk> | 2013-08-23 09:57:55 +0100 |
| commit | 9a298ca833d9b6a3425bb30c2e52cf04e34aeb7c (patch) | |
| tree | d46630a885bcea03bbea036b86c645dc6c55708d /include | |
| parent | 0969839d538a385254c6eced9648acc7299876cc (diff) | |
Imported Upstream version 2.1+dfsg
Diffstat (limited to 'include')
108 files changed, 15344 insertions, 6605 deletions
diff --git a/include/SFML/Audio.hpp b/include/SFML/Audio.hpp index 9a83a73..1129863 100755..100644 --- a/include/SFML/Audio.hpp +++ b/include/SFML/Audio.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -40,3 +40,11 @@ #endif // SFML_AUDIO_HPP
+
+////////////////////////////////////////////////////////////
+/// \defgroup audio Audio module
+///
+/// Sounds, streaming (musics or custom sources), recording,
+/// spatialization.
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Network/Sockets.hpp b/include/SFML/Audio/Export.hpp index 1359cb9..7c4b6ca 100755..100644 --- a/include/SFML/Network/Sockets.hpp +++ b/include/SFML/Audio/Export.hpp @@ -1,45 +1,48 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_SOCKETS_HPP
-#define SFML_SOCKETS_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
-
-
-#ifdef SFML_SYSTEM_WINDOWS
-
- #include <SFML/Network/Win32/Sockets.hpp>
-
-#else
-
- #include <SFML/Network/Unix/Sockets.hpp>
-
-#endif
-
-
-#endif // SFML_SOCKETS_HPP
+//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_AUDIO_EXPORT_HPP +#define SFML_AUDIO_EXPORT_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Config.hpp> + + +//////////////////////////////////////////////////////////// +// Define portable import / export macros +//////////////////////////////////////////////////////////// +#if defined(SFML_AUDIO_EXPORTS) + + #define SFML_AUDIO_API SFML_API_EXPORT + +#else + + #define SFML_AUDIO_API SFML_API_IMPORT + +#endif + + +#endif // SFML_AUDIO_EXPORT_HPP diff --git a/include/SFML/Audio/Listener.hpp b/include/SFML/Audio/Listener.hpp index 95227ca..213d96a 100755..100644 --- a/include/SFML/Audio/Listener.hpp +++ b/include/SFML/Audio/Listener.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,95 +28,157 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
+#include <SFML/Audio/Export.hpp>
#include <SFML/System/Vector3.hpp>
namespace sf
{
////////////////////////////////////////////////////////////
-/// Listener is a global interface for defining the audio
-/// listener properties ; the audio listener is the point in
-/// the scene from where all the sounds are heard
+/// \brief The audio listener is the point in the scene
+/// from where all the sounds are heard
+///
////////////////////////////////////////////////////////////
-class SFML_API Listener
+class SFML_AUDIO_API Listener
{
public :
////////////////////////////////////////////////////////////
- /// Change the global volume of all the sounds.
- /// The default volume is 100
+ /// \brief Change the global volume of all the sounds and musics
///
- /// \param Volume : New global volume, in the range [0, 100]
+ /// The volume is a number between 0 and 100; it is combined with
+ /// the individual volume of each sound / music.
+ /// The default value for the volume is 100 (maximum).
+ ///
+ /// \param volume New global volume, in the range [0, 100]
+ ///
+ /// \see getGlobalVolume
///
////////////////////////////////////////////////////////////
- static void SetGlobalVolume(float Volume);
+ static void setGlobalVolume(float volume);
////////////////////////////////////////////////////////////
- /// Get the current value of the global volume of all the sounds
+ /// \brief Get the current value of the global volume
///
/// \return Current global volume, in the range [0, 100]
///
+ /// \see setGlobalVolume
+ ///
////////////////////////////////////////////////////////////
- static float GetGlobalVolume();
+ static float getGlobalVolume();
////////////////////////////////////////////////////////////
- /// Change the position of the listener (take 3 values).
- /// The default position is (0, 0, 0)
+ /// \brief Set the position of the listener in the scene
+ ///
+ /// The default listener's position is (0, 0, 0).
+ ///
+ /// \param x X coordinate of the listener's position
+ /// \param y Y coordinate of the listener's position
+ /// \param z Z coordinate of the listener's position
///
- /// \param X, Y, Z : Position of the listener in the world
+ /// \see getPosition, setDirection
///
////////////////////////////////////////////////////////////
- static void SetPosition(float X, float Y, float Z);
+ static void setPosition(float x, float y, float z);
////////////////////////////////////////////////////////////
- /// Change the position of the listener (take a 3D vector).
- /// The default position is (0, 0, 0)
+ /// \brief Set the position of the listener in the scene
///
- /// \param Position : Position of the listener in the world
+ /// The default listener's position is (0, 0, 0).
+ ///
+ /// \param position New listener's position
+ ///
+ /// \see getPosition, setDirection
///
////////////////////////////////////////////////////////////
- static void SetPosition(const Vector3f& Position);
+ static void setPosition(const Vector3f& position);
////////////////////////////////////////////////////////////
- /// Get the current position of the listener
+ /// \brief Get the current position of the listener in the scene
///
- /// \return Position of the listener in the world
+ /// \return Listener's position
+ ///
+ /// \see setPosition
///
////////////////////////////////////////////////////////////
- static Vector3f GetPosition();
+ static Vector3f getPosition();
////////////////////////////////////////////////////////////
- /// Change the orientation of the listener (the point
- /// he must look at) (take 3 values).
- /// The default target is (0, 0, -1)
+ /// \brief Set the orientation of the listener in the scene
+ ///
+ /// The orientation defines the 3D axes of the listener
+ /// (left, up, front) in the scene. The orientation vector
+ /// doesn't have to be normalized.
+ /// The default listener's orientation is (0, 0, -1).
///
- /// \param X, Y, Z : Position of the point the listener must look at
+ /// \param x X coordinate of the listener's orientation
+ /// \param y Y coordinate of the listener's orientation
+ /// \param z Z coordinate of the listener's orientation
+ ///
+ /// \see getDirection, setPosition
///
////////////////////////////////////////////////////////////
- static void SetTarget(float X, float Y, float Z);
+ static void setDirection(float x, float y, float z);
////////////////////////////////////////////////////////////
- /// Change the orientation of the listener (the point
- /// he must look at) (take a 3D vector).
- /// The default target is (0, 0, -1)
+ /// \brief Set the orientation of the listener in the scene
+ ///
+ /// The orientation defines the 3D axes of the listener
+ /// (left, up, front) in the scene. The orientation vector
+ /// doesn't have to be normalized.
+ /// The default listener's orientation is (0, 0, -1).
///
- /// \param Target : Position of the point the listener must look at
+ /// \param direction New listener's orientation
+ ///
+ /// \see getDirection, setPosition
///
////////////////////////////////////////////////////////////
- static void SetTarget(const Vector3f& Target);
+ static void setDirection(const Vector3f& direction);
////////////////////////////////////////////////////////////
- /// Get the current orientation of the listener (the point
- /// he's looking at)
+ /// \brief Get the current orientation of the listener in the scene
+ ///
+ /// \return Listener's orientation
///
- /// \return : Position of the point the listener is looking at
+ /// \see setDirection
///
////////////////////////////////////////////////////////////
- static Vector3f GetTarget();
+ static Vector3f getDirection();
};
} // namespace sf
#endif // SFML_LISTENER_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Listener
+/// \ingroup audio
+///
+/// The audio listener defines the global properties of the
+/// audio environment, it defines where and how sounds and musics
+/// are heard. If sf::View is the eyes of the user, then sf::Listener
+/// is his ears (by the way, they are often linked together --
+/// same position, orientation, etc.).
+///
+/// sf::Listener is a simple interface, which allows to setup the
+/// listener in the 3D audio environment (position and direction),
+/// and to adjust the global volume.
+///
+/// Because the listener is unique in the scene, sf::Listener only
+/// contains static functions and doesn't have to be instanciated.
+///
+/// Usage example:
+/// \code
+/// // Move the listener to the position (1, 0, -5)
+/// sf::Listener::setPosition(1, 0, -5);
+///
+/// // Make it face the right axis (1, 0, 0)
+/// sf::Listener::setDirection(1, 0, 0);
+///
+/// // Reduce the global volume
+/// sf::Listener::setGlobalVolume(50);
+/// \endcode
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Audio/Music.hpp b/include/SFML/Audio/Music.hpp index 0b8f70d..ba922e9 100755..100644 --- a/include/SFML/Audio/Music.hpp +++ b/include/SFML/Audio/Music.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,7 +28,10 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
+#include <SFML/Audio/Export.hpp>
#include <SFML/Audio/SoundStream.hpp>
+#include <SFML/System/Mutex.hpp>
+#include <SFML/System/Time.hpp>
#include <string>
#include <vector>
@@ -40,81 +43,186 @@ namespace priv class SoundFile;
}
+class InputStream;
+
////////////////////////////////////////////////////////////
-/// Music defines a big sound played using streaming,
-/// so usually what we call a music :)
+/// \brief Streamed music played from an audio file
+///
////////////////////////////////////////////////////////////
-class SFML_API Music : public SoundStream
+class SFML_AUDIO_API Music : public SoundStream
{
public :
////////////////////////////////////////////////////////////
- /// Construct the music with a buffer size
- ///
- /// \param BufferSize : Size of the internal buffer, expressed in number of samples
- /// (ie. size taken by the music in memory) (44100 by default)
+ /// \brief Default constructor
///
////////////////////////////////////////////////////////////
- explicit Music(std::size_t BufferSize = 44100);
+ Music();
////////////////////////////////////////////////////////////
- /// Destructor
+ /// \brief Destructor
///
////////////////////////////////////////////////////////////
~Music();
////////////////////////////////////////////////////////////
- /// Open a music file (doesn't play it -- call Play() for that)
+ /// \brief Open a music from an audio file
+ ///
+ /// This function doesn't start playing the music (call play()
+ /// to do so).
+ /// Here is a complete list of all the supported audio formats:
+ /// ogg, wav, flac, aiff, au, raw, paf, svx, nist, voc, ircam,
+ /// w64, mat4, mat5 pvf, htk, sds, avr, sd2, caf, wve, mpc2k, rf64.
+ ///
+ /// \param filename Path of the music file to open
///
- /// \param Filename : Path of the music file to open
+ /// \return True if loading succeeded, false if it failed
///
- /// \return True if loading has been successful
+ /// \see openFromMemory, openFromStream
///
////////////////////////////////////////////////////////////
- bool OpenFromFile(const std::string& Filename);
+ bool openFromFile(const std::string& filename);
////////////////////////////////////////////////////////////
- /// Open a music file from memory (doesn't play it -- call Play() for that)
+ /// \brief Open a music from an audio file in memory
///
- /// \param Data : Pointer to the file data in memory
- /// \param SizeInBytes : Size of the data to load, in bytes
+ /// This function doesn't start playing the music (call play()
+ /// to do so).
+ /// Here is a complete list of all the supported audio formats:
+ /// ogg, wav, flac, aiff, au, raw, paf, svx, nist, voc, ircam,
+ /// w64, mat4, mat5 pvf, htk, sds, avr, sd2, caf, wve, mpc2k, rf64.
+ /// Since the music is not loaded completely but rather streamed
+ /// continuously, the \a data must remain available as long as the
+ /// music is playing (ie. you can't deallocate it right after calling
+ /// this function).
///
- /// \return True if loading has been successful
+ /// \param data Pointer to the file data in memory
+ /// \param sizeInBytes Size of the data to load, in bytes
+ ///
+ /// \return True if loading succeeded, false if it failed
+ ///
+ /// \see openFromFile, openFromStream
///
////////////////////////////////////////////////////////////
- bool OpenFromMemory(const char* Data, std::size_t SizeInBytes);
+ bool openFromMemory(const void* data, std::size_t sizeInBytes);
////////////////////////////////////////////////////////////
- /// Get the music duration
+ /// \brief Open a music from an audio file in a custom stream
+ ///
+ /// This function doesn't start playing the music (call play()
+ /// to do so).
+ /// Here is a complete list of all the supported audio formats:
+ /// ogg, wav, flac, aiff, au, raw, paf, svx, nist, voc, ircam,
+ /// w64, mat4, mat5 pvf, htk, sds, avr, sd2, caf, wve, mpc2k, rf64.
+ /// Since the music is not loaded completely but rather streamed
+ /// continuously, the \a stream must remain alive as long as the
+ /// music is playing (ie. you can't destroy it right after calling
+ /// this function).
+ ///
+ /// \param stream Source stream to read from
///
- /// \return Music duration, in seconds
+ /// \return True if loading succeeded, false if it failed
+ ///
+ /// \see openFromFile, openFromMemory
///
////////////////////////////////////////////////////////////
- float GetDuration() const;
+ bool openFromStream(InputStream& stream);
-private :
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the total duration of the music
+ ///
+ /// \return Music duration
+ ///
+ ////////////////////////////////////////////////////////////
+ Time getDuration() const;
+
+protected :
////////////////////////////////////////////////////////////
- /// /see SoundStream::OnStart
+ /// \brief Request a new chunk of audio samples from the stream source
+ ///
+ /// This function fills the chunk from the next samples
+ /// to read from the audio file.
+ ///
+ /// \param data Chunk of data to fill
+ ///
+ /// \return True to continue playback, false to stop
+ ///
+ ////////////////////////////////////////////////////////////
+ virtual bool onGetData(Chunk& data);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Change the current playing position in the stream source
+ ///
+ /// \param timeOffset New playing position, from the beginning of the music
///
////////////////////////////////////////////////////////////
- virtual bool OnStart();
+ virtual void onSeek(Time timeOffset);
+
+private :
////////////////////////////////////////////////////////////
- /// /see SoundStream::OnGetData
+ /// \brief Initialize the internal state after loading a new music
///
////////////////////////////////////////////////////////////
- virtual bool OnGetData(Chunk& Data);
+ void initialize();
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- priv::SoundFile* myFile; ///< Sound file
- float myDuration; ///< Music duration, in seconds
- std::vector<Int16> mySamples; ///< Temporary buffer of samples
+ priv::SoundFile* m_file; ///< Sound file
+ Time m_duration; ///< Music duration
+ std::vector<Int16> m_samples; ///< Temporary buffer of samples
+ Mutex m_mutex; ///< Mutex protecting the data
};
} // namespace sf
#endif // SFML_MUSIC_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Music
+/// \ingroup audio
+///
+/// Musics are sounds that are streamed rather than completely
+/// loaded in memory. This is especially useful for compressed
+/// musics that usually take hundreds of MB when they are
+/// uncompressed: by streaming it instead of loading it entirely,
+/// you avoid saturating the memory and have almost no loading delay.
+///
+/// Apart from that, a sf::Music has almost the same features as
+/// the sf::SoundBuffer / sf::Sound pair: you can play/pause/stop
+/// it, request its parameters (channels, sample rate), change
+/// the way it is played (pitch, volume, 3D position, ...), etc.
+///
+/// As a sound stream, a music is played in its own thread in order
+/// not to block the rest of the program. This means that you can
+/// leave the music alone after calling play(), it will manage itself
+/// very well.
+///
+/// Usage example:
+/// \code
+/// // Declare a new music
+/// sf::Music music;
+///
+/// // Open it from an audio file
+/// if (!music.openFromFile("music.ogg"))
+/// {
+/// // error...
+/// }
+///
+/// // Change some parameters
+/// music.setPosition(0, 1, 10); // change its 3D position
+/// music.setPitch(2); // increase the pitch
+/// music.setVolume(50); // reduce the volume
+/// music.setLoop(true); // make it loop
+///
+/// // Play it
+/// music.play();
+/// \endcode
+///
+/// \see sf::Sound, sf::SoundStream
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Audio/Sound.hpp b/include/SFML/Audio/Sound.hpp index 7cb8002..1250f42 100755..100644 --- a/include/SFML/Audio/Sound.hpp +++ b/include/SFML/Audio/Sound.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,9 +28,9 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/System/Resource.hpp>
-#include <SFML/System/Vector3.hpp>
-#include <SFML/Audio/AudioResource.hpp>
+#include <SFML/Audio/Export.hpp>
+#include <SFML/Audio/SoundSource.hpp>
+#include <SFML/System/Time.hpp>
#include <cstdlib>
@@ -39,276 +39,224 @@ namespace sf class SoundBuffer;
////////////////////////////////////////////////////////////
-/// Sound defines the properties of a sound such as position,
-/// volume, pitch, etc.
+/// \brief Regular sound that can be played in the audio environment
+///
////////////////////////////////////////////////////////////
-class SFML_API Sound : public AudioResource
+class SFML_AUDIO_API Sound : public SoundSource
{
public :
////////////////////////////////////////////////////////////
- /// Enumeration of the sound states
- ////////////////////////////////////////////////////////////
- enum Status
- {
- Stopped, ///< Sound is not playing
- Paused, ///< Sound is paused
- Playing ///< Sound is playing
- };
-
- ////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
///
////////////////////////////////////////////////////////////
Sound();
////////////////////////////////////////////////////////////
- /// Construct the sound from its parameters
+ /// \brief Construct the sound with a buffer
///
- /// \param Buffer : Sound buffer to play (NULL by default)
- /// \param Loop : Loop flag (false by default)
- /// \param Pitch : Value of the pitch (1 by default)
- /// \param Volume : Volume (100 by default)
- /// \param Position : Position (0, 0, 0 by default)
+ /// \param buffer Sound buffer containing the audio data to play with the sound
///
////////////////////////////////////////////////////////////
- explicit Sound(const SoundBuffer& Buffer, bool Loop = false, float Pitch = 1.f, float Volume = 100.f, const Vector3f& Position = Vector3f(0, 0, 0));
+ explicit Sound(const SoundBuffer& buffer);
////////////////////////////////////////////////////////////
- /// Copy constructor
+ /// \brief Copy constructor
///
- /// \param Copy : Instance to copy
+ /// \param copy Instance to copy
///
////////////////////////////////////////////////////////////
- Sound(const Sound& Copy);
+ Sound(const Sound& copy);
////////////////////////////////////////////////////////////
- /// Destructor
+ /// \brief Destructor
///
////////////////////////////////////////////////////////////
~Sound();
////////////////////////////////////////////////////////////
- /// Play the sound
+ /// \brief Start or resume playing the sound
///
- ////////////////////////////////////////////////////////////
- void Play();
-
- ////////////////////////////////////////////////////////////
- /// Pause the sound
+ /// This function starts the stream if it was stopped, resumes
+ /// it if it was paused, and restarts it from beginning if it
+ /// was it already playing.
+ /// This function uses its own thread so that it doesn't block
+ /// the rest of the program while the sound is played.
///
- ////////////////////////////////////////////////////////////
- void Pause();
-
- ////////////////////////////////////////////////////////////
- /// Stop the sound
+ /// \see pause, stop
///
////////////////////////////////////////////////////////////
- void Stop();
+ void play();
////////////////////////////////////////////////////////////
- /// Set the source buffer
+ /// \brief Pause the sound
///
- /// \param Buffer : New sound buffer to bind to the sound
+ /// This function pauses the sound if it was playing,
+ /// otherwise (sound already paused or stopped) it has no effect.
///
- ////////////////////////////////////////////////////////////
- void SetBuffer(const SoundBuffer& Buffer);
-
- ////////////////////////////////////////////////////////////
- /// Set the sound loop state.
- /// This parameter is disabled by default
- ///
- /// \param Loop : True to play in loop, false to play once
+ /// \see play, stop
///
////////////////////////////////////////////////////////////
- void SetLoop(bool Loop);
+ void pause();
////////////////////////////////////////////////////////////
- /// Set the sound pitch.
- /// The default pitch is 1
- ///
- /// \param Pitch : New pitch
+ /// \brief stop playing the sound
///
- ////////////////////////////////////////////////////////////
- void SetPitch(float Pitch);
-
- ////////////////////////////////////////////////////////////
- /// Set the sound volume.
- /// The default volume is 100
+ /// This function stops the sound if it was playing or paused,
+ /// and does nothing if it was already stopped.
+ /// It also resets the playing position (unlike pause()).
///
- /// \param Volume : Volume (in range [0, 100])
+ /// \see play, pause
///
////////////////////////////////////////////////////////////
- void SetVolume(float Volume);
+ void stop();
////////////////////////////////////////////////////////////
- /// Set the sound position (take 3 values).
- /// The default position is (0, 0, 0)
+ /// \brief Set the source buffer containing the audio data to play
///
- /// \param X, Y, Z : Position of the sound in the world
+ /// It is important to note that the sound buffer is not copied,
+ /// thus the sf::SoundBuffer instance must remain alive as long
+ /// as it is attached to the sound.
///
- ////////////////////////////////////////////////////////////
- void SetPosition(float X, float Y, float Z);
-
- ////////////////////////////////////////////////////////////
- /// Set the sound position (take a 3D vector).
- /// The default position is (0, 0, 0)
+ /// \param buffer Sound buffer to attach to the sound
///
- /// \param Position : Position of the sound in the world
+ /// \see getBuffer
///
////////////////////////////////////////////////////////////
- void SetPosition(const Vector3f& Position);
+ void setBuffer(const SoundBuffer& buffer);
////////////////////////////////////////////////////////////
- /// Make the sound's position relative to the listener's
- /// position, or absolute.
- /// The default value is false (absolute)
+ /// \brief Set whether or not the sound should loop after reaching the end
///
- /// \param Relative : True to set the position relative, false to set it absolute
+ /// If set, the sound will restart from beginning after
+ /// reaching the end and so on, until it is stopped or
+ /// setLoop(false) is called.
+ /// The default looping state for sound is false.
///
- ////////////////////////////////////////////////////////////
- void SetRelativeToListener(bool Relative);
-
- ////////////////////////////////////////////////////////////
- /// Set the minimum distance - closer than this distance,
- /// the listener will hear the sound at its maximum volume.
- /// The default minimum distance is 1.0
+ /// \param loop True to play in loop, false to play once
///
- /// \param MinDistance : New minimum distance for the sound
+ /// \see getLoop
///
////////////////////////////////////////////////////////////
- void SetMinDistance(float MinDistance);
+ void setLoop(bool loop);
////////////////////////////////////////////////////////////
- /// Set the attenuation factor - the higher the attenuation, the
- /// more the sound will be attenuated with distance from listener.
- /// The default attenuation factor 1.0
+ /// \brief Change the current playing position of the sound
///
- /// \param Attenuation : New attenuation factor for the sound
+ /// The playing position can be changed when the sound is
+ /// either paused or playing.
///
- ////////////////////////////////////////////////////////////
- void SetAttenuation(float Attenuation);
-
- ////////////////////////////////////////////////////////////
- /// Set the current playing position of the sound
+ /// \param timeOffset New playing position, from the beginning of the sound
///
- /// \param TimeOffset : New playing position, expressed in seconds
+ /// \see getPlayingOffset
///
////////////////////////////////////////////////////////////
- void SetPlayingOffset(float TimeOffset);
+ void setPlayingOffset(Time timeOffset);
////////////////////////////////////////////////////////////
- /// Get the source buffer
+ /// \brief Get the audio buffer attached to the sound
///
- /// \return Sound buffer bound to the sound (can be NULL)
+ /// \return Sound buffer attached to the sound (can be NULL)
///
////////////////////////////////////////////////////////////
- const SoundBuffer* GetBuffer() const;
+ const SoundBuffer* getBuffer() const;
////////////////////////////////////////////////////////////
- /// Tell whether or not the sound is looping
+ /// \brief Tell whether or not the sound is in loop mode
///
/// \return True if the sound is looping, false otherwise
///
- ////////////////////////////////////////////////////////////
- bool GetLoop() const;
-
- ////////////////////////////////////////////////////////////
- /// Get the pitch
- ///
- /// \return Pitch value
+ /// \see setLoop
///
////////////////////////////////////////////////////////////
- float GetPitch() const;
+ bool getLoop() const;
////////////////////////////////////////////////////////////
- /// Get the volume
+ /// \brief Get the current playing position of the sound
///
- /// \return Volume value (in range [1, 100])
+ /// \return Current playing position, from the beginning of the sound
///
- ////////////////////////////////////////////////////////////
- float GetVolume() const;
-
- ////////////////////////////////////////////////////////////
- /// Get the sound position
- ///
- /// \return Position of the sound in the world
+ /// \see setPlayingOffset
///
////////////////////////////////////////////////////////////
- Vector3f GetPosition() const;
+ Time getPlayingOffset() const;
////////////////////////////////////////////////////////////
- /// Tell if the sound's position is relative to the listener's
- /// position, or if it's absolute
- ///
- /// \return True if the position is relative, false if it's absolute
- ///
- ////////////////////////////////////////////////////////////
- bool IsRelativeToListener() const;
-
- ////////////////////////////////////////////////////////////
- /// Get the minimum distance
- ///
- /// \return Minimum distance for the sound
- ///
- ////////////////////////////////////////////////////////////
- float GetMinDistance() const;
-
- ////////////////////////////////////////////////////////////
- /// Get the attenuation factor
- ///
- /// \return Attenuation factor of the sound
- ///
- ////////////////////////////////////////////////////////////
- float GetAttenuation() const;
-
- ////////////////////////////////////////////////////////////
- /// Get the status of the sound (stopped, paused, playing)
+ /// \brief Get the current status of the sound (stopped, paused, playing)
///
/// \return Current status of the sound
///
////////////////////////////////////////////////////////////
- Status GetStatus() const;
-
- ////////////////////////////////////////////////////////////
- /// Get the current playing position of the sound
- ///
- /// \return Current playing position, expressed in seconds
- ///
- ////////////////////////////////////////////////////////////
- float GetPlayingOffset() const;
+ Status getStatus() const;
////////////////////////////////////////////////////////////
- /// Assignment operator
+ /// \brief Overload of assignment operator
///
- /// \param Other : Instance to assign
+ /// \param right Instance to assign
///
- /// \return Reference to the sound
+ /// \return Reference to self
///
////////////////////////////////////////////////////////////
- Sound& operator =(const Sound& Other);
+ Sound& operator =(const Sound& right);
////////////////////////////////////////////////////////////
- /// Reset the internal buffer
+ /// \brief Reset the internal buffer of the sound
///
/// This function is for internal use only, you don't have
- /// to use it.
+ /// to use it. It is called by the sf::SoundBuffer that
+ /// this sound uses, when it is destroyed in order to prevent
+ /// the sound from using a dead buffer.
///
////////////////////////////////////////////////////////////
- void ResetBuffer();
+ void resetBuffer();
private :
- friend class SoundStream;
-
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- unsigned int mySource; ///< OpenAL source identifier
- ResourcePtr<SoundBuffer> myBuffer; ///< Sound buffer bound to the source
+ const SoundBuffer* m_buffer; ///< Sound buffer bound to the source
};
} // namespace sf
#endif // SFML_SOUND_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Sound
+/// \ingroup audio
+///
+/// sf::Sound is the class to use to play sounds.
+/// It provides:
+/// \li Control (play, pause, stop)
+/// \li Ability to modify output parameters in real-time (pitch, volume, ...)
+/// \li 3D spatial features (position, attenuation, ...).
+///
+/// sf::Sound is perfect for playing short sounds that can
+/// fit in memory and require no latency, like foot steps or
+/// gun shots. For longer sounds, like background musics
+/// or long speeches, rather see sf::Music (which is based
+/// on streaming).
+///
+/// In order to work, a sound must be given a buffer of audio
+/// data to play. Audio data (samples) is stored in sf::SoundBuffer,
+/// and attached to a sound with the setBuffer() function.
+/// The buffer object attached to a sound must remain alive
+/// as long as the sound uses it. Note that multiple sounds
+/// can use the same sound buffer at the same time.
+///
+/// Usage example:
+/// \code
+/// sf::SoundBuffer buffer;
+/// buffer.loadFromFile("sound.wav");
+///
+/// sf::Sound sound;
+/// sound.setBuffer(buffer);
+/// sound.play();
+/// \endcode
+///
+/// \see sf::SoundBuffer, sf::Music
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Audio/SoundBuffer.hpp b/include/SFML/Audio/SoundBuffer.hpp index 023e5aa..23fed88 100755..100644 --- a/include/SFML/Audio/SoundBuffer.hpp +++ b/include/SFML/Audio/SoundBuffer.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,8 +28,8 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/System/Resource.hpp>
-#include <SFML/Audio/AudioResource.hpp>
+#include <SFML/Audio/Export.hpp>
+#include <SFML/System/Time.hpp>
#include <string>
#include <vector>
#include <set>
@@ -37,161 +37,239 @@ namespace sf
{
+namespace priv
+{
+ class SoundFile;
+}
+
class Sound;
+class InputStream;
////////////////////////////////////////////////////////////
-/// SoundBuffer is the low-level for loading and manipulating
-/// sound buffers
+/// \brief Storage for audio samples defining a sound
+///
////////////////////////////////////////////////////////////
-class SFML_API SoundBuffer : public AudioResource, public Resource<SoundBuffer>
+class SFML_AUDIO_API SoundBuffer
{
public :
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
///
////////////////////////////////////////////////////////////
SoundBuffer();
////////////////////////////////////////////////////////////
- /// Copy constructor
+ /// \brief Copy constructor
///
- /// \param Copy : Instance to copy
+ /// \param copy Instance to copy
///
////////////////////////////////////////////////////////////
- SoundBuffer(const SoundBuffer& Copy);
+ SoundBuffer(const SoundBuffer& copy);
////////////////////////////////////////////////////////////
- /// Destructor
+ /// \brief Destructor
///
////////////////////////////////////////////////////////////
~SoundBuffer();
////////////////////////////////////////////////////////////
- /// Load the sound buffer from a file
+ /// \brief Load the sound buffer from a file
+ ///
+ /// Here is a complete list of all the supported audio formats:
+ /// ogg, wav, flac, aiff, au, raw, paf, svx, nist, voc, ircam,
+ /// w64, mat4, mat5 pvf, htk, sds, avr, sd2, caf, wve, mpc2k, rf64.
///
- /// \param Filename : Path of the sound file to load
+ /// \param filename Path of the sound file to load
///
- /// \return True if loading has been successful
+ /// \return True if loading succeeded, false if it failed
+ ///
+ /// \see loadFromMemory, loadFromStream, loadFromSamples, saveToFile
///
////////////////////////////////////////////////////////////
- bool LoadFromFile(const std::string& Filename);
+ bool loadFromFile(const std::string& filename);
////////////////////////////////////////////////////////////
- /// Load the sound buffer from a file in memory
+ /// \brief Load the sound buffer from a file in memory
+ ///
+ /// Here is a complete list of all the supported audio formats:
+ /// ogg, wav, flac, aiff, au, raw, paf, svx, nist, voc, ircam,
+ /// w64, mat4, mat5 pvf, htk, sds, avr, sd2, caf, wve, mpc2k, rf64.
///
- /// \param Data : Pointer to the file data in memory
- /// \param SizeInBytes : Size of the data to load, in bytes
+ /// \param data Pointer to the file data in memory
+ /// \param sizeInBytes Size of the data to load, in bytes
///
- /// \return True if loading has been successful
+ /// \return True if loading succeeded, false if it failed
+ ///
+ /// \see loadFromFile, loadFromStream, loadFromSamples
///
////////////////////////////////////////////////////////////
- bool LoadFromMemory(const char* Data, std::size_t SizeInBytes);
+ bool loadFromMemory(const void* data, std::size_t sizeInBytes);
////////////////////////////////////////////////////////////
- /// Load the sound buffer from an array of samples - assumed format for
- /// samples is 16 bits signed integer
+ /// \brief Load the sound buffer from a custom stream
+ ///
+ /// Here is a complete list of all the supported audio formats:
+ /// ogg, wav, flac, aiff, au, raw, paf, svx, nist, voc, ircam,
+ /// w64, mat4, mat5 pvf, htk, sds, avr, sd2, caf, wve, mpc2k, rf64.
+ ///
+ /// \param stream Source stream to read from
///
- /// \param Samples : Pointer to the samples in memory
- /// \param SamplesCount : Number of samples pointed by Samples
- /// \param ChannelsCount : Number of channels (1 = mono, 2 = stereo, ...)
- /// \param SampleRate : Frequency (number of samples to play per second)
+ /// \return True if loading succeeded, false if it failed
///
- /// \return True if loading has been successful
+ /// \see loadFromFile, loadFromMemory, loadFromSamples
///
////////////////////////////////////////////////////////////
- bool LoadFromSamples(const Int16* Samples, std::size_t SamplesCount, unsigned int ChannelsCount, unsigned int SampleRate);
+ bool loadFromStream(InputStream& stream);
////////////////////////////////////////////////////////////
- /// Save the sound buffer to a file
+ /// \brief Load the sound buffer from an array of audio samples
+ ///
+ /// The assumed format of the audio samples is 16 bits signed integer
+ /// (sf::Int16).
+ ///
+ /// \param samples Pointer to the array of samples in memory
+ /// \param sampleCount Number of samples in the array
+ /// \param channelCount Number of channels (1 = mono, 2 = stereo, ...)
+ /// \param sampleRate Sample rate (number of samples to play per second)
///
- /// \param Filename : Path of the sound file to write
+ /// \return True if loading succeeded, false if it failed
///
- /// \return True if saving has been successful
+ /// \see loadFromFile, loadFromMemory, saveToFile
///
////////////////////////////////////////////////////////////
- bool SaveToFile(const std::string& Filename) const;
+ bool loadFromSamples(const Int16* samples, std::size_t sampleCount, unsigned int channelCount, unsigned int sampleRate);
////////////////////////////////////////////////////////////
- /// Return the sound samples
+ /// \brief Save the sound buffer to an audio file
///
- /// \return Pointer to the array of sound samples, in 16 bits signed integer format
+ /// Here is a complete list of all the supported audio formats:
+ /// ogg, wav, flac, aiff, au, raw, paf, svx, nist, voc, ircam,
+ /// w64, mat4, mat5 pvf, htk, sds, avr, sd2, caf, wve, mpc2k, rf64.
+ ///
+ /// \param filename Path of the sound file to write
+ ///
+ /// \return True if saving succeeded, false if it failed
+ ///
+ /// \see loadFromFile, loadFromMemory, loadFromSamples
///
////////////////////////////////////////////////////////////
- const Int16* GetSamples() const;
+ bool saveToFile(const std::string& filename) const;
////////////////////////////////////////////////////////////
- /// Return the samples count
+ /// \brief Get the array of audio samples stored in the buffer
+ ///
+ /// The format of the returned samples is 16 bits signed integer
+ /// (sf::Int16). The total number of samples in this array
+ /// is given by the getSampleCount() function.
+ ///
+ /// \return Read-only pointer to the array of sound samples
+ ///
+ /// \see getSampleCount
+ ///
+ ////////////////////////////////////////////////////////////
+ const Int16* getSamples() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the number of samples stored in the buffer
+ ///
+ /// The array of samples can be accessed with the getSamples()
+ /// function.
///
/// \return Number of samples
///
+ /// \see getSamples
+ ///
////////////////////////////////////////////////////////////
- std::size_t GetSamplesCount() const;
+ std::size_t getSampleCount() const;
////////////////////////////////////////////////////////////
- /// Get the sample rate
+ /// \brief Get the sample rate of the sound
+ ///
+ /// The sample rate is the number of samples played per second.
+ /// The higher, the better the quality (for example, 44100
+ /// samples/s is CD quality).
+ ///
+ /// \return Sample rate (number of samples per second)
///
- /// \return Sound frequency (number of samples per second)
+ /// \see getChannelCount, getDuration
///
////////////////////////////////////////////////////////////
- unsigned int GetSampleRate() const;
+ unsigned int getSampleRate() const;
////////////////////////////////////////////////////////////
- /// Return the number of channels (1 = mono, 2 = stereo, ...)
+ /// \brief Get the number of channels used by the sound
+ ///
+ /// If the sound is mono then the number of channels will
+ /// be 1, 2 for stereo, etc.
///
/// \return Number of channels
///
+ /// \see getSampleRate, getDuration
+ ///
////////////////////////////////////////////////////////////
- unsigned int GetChannelsCount() const;
+ unsigned int getChannelCount() const;
////////////////////////////////////////////////////////////
- /// Get the sound duration
+ /// \brief Get the total duration of the sound
///
- /// \return Sound duration, in seconds
+ /// \return Sound duration
+ ///
+ /// \see getSampleRate, getChannelCount
///
////////////////////////////////////////////////////////////
- float GetDuration() const;
+ Time getDuration() const;
////////////////////////////////////////////////////////////
- /// Assignment operator
+ /// \brief Overload of assignment operator
///
- /// \param Other : Instance to assign
+ /// \param right Instance to assign
///
- /// \return Reference to the sound buffer
+ /// \return Reference to self
///
////////////////////////////////////////////////////////////
- SoundBuffer& operator =(const SoundBuffer& Other);
+ SoundBuffer& operator =(const SoundBuffer& right);
private :
friend class Sound;
////////////////////////////////////////////////////////////
- /// Update the internal buffer with the audio samples
+ /// \brief Initialize the internal state after loading a new sound
+ ///
+ /// \param file Sound file providing access to the new loaded sound
+ ///
+ /// \return True on succesful initialization, false on failure
+ ///
+ ////////////////////////////////////////////////////////////
+ bool initialize(priv::SoundFile& file);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Update the internal buffer with the cached audio samples
///
- /// \param ChannelsCount : Number of channels
- /// \param SampleRate : Sample rate
+ /// \param channelCount Number of channels
+ /// \param sampleRate Sample rate (number of samples per second)
///
- /// \return True on success
+ /// \return True on success, false if any error happened
///
////////////////////////////////////////////////////////////
- bool Update(unsigned int ChannelsCount, unsigned int SampleRate);
+ bool update(unsigned int channelCount, unsigned int sampleRate);
////////////////////////////////////////////////////////////
- /// Add a sound to the list of sounds that use this buffer
+ /// \brief Add a sound to the list of sounds that use this buffer
///
- /// \param Instance : Sound object to attach
+ /// \param sound Sound instance to attach
///
////////////////////////////////////////////////////////////
- void AttachSound(Sound* Instance) const;
+ void attachSound(Sound* sound) const;
////////////////////////////////////////////////////////////
- /// Remove a sound from the list of sounds that use this buffer
+ /// \brief Remove a sound from the list of sounds that use this buffer
///
- /// \param Instance : Sound object to detach
+ /// \param sound Sound instance to detach
///
////////////////////////////////////////////////////////////
- void DetachSound(Sound* Instance) const;
+ void detachSound(Sound* sound) const;
////////////////////////////////////////////////////////////
// Types
@@ -201,13 +279,81 @@ private : ////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- unsigned int myBuffer; ///< OpenAL buffer identifier
- std::vector<Int16> mySamples; ///< Samples buffer
- float myDuration; ///< Sound duration, in seconds
- mutable SoundList mySounds; ///< List of sounds that are using this buffer
+ unsigned int m_buffer; ///< OpenAL buffer identifier
+ std::vector<Int16> m_samples; ///< Samples buffer
+ Time m_duration; ///< Sound duration
+ mutable SoundList m_sounds; ///< List of sounds that are using this buffer
};
} // namespace sf
#endif // SFML_SOUNDBUFFER_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::SoundBuffer
+/// \ingroup audio
+///
+/// A sound buffer holds the data of a sound, which is
+/// an array of audio samples. A sample is a 16 bits signed integer
+/// that defines the amplitude of the sound at a given time.
+/// The sound is then restituted by playing these samples at
+/// a high rate (for example, 44100 samples per second is the
+/// standard rate used for playing CDs). In short, audio samples
+/// are like texture pixels, and a sf::SoundBuffer is similar to
+/// a sf::Texture.
+///
+/// A sound buffer can be loaded from a file (see loadFromFile()
+/// for the complete list of supported formats), from memory, from
+/// a custom stream (see sf::InputStream) or directly from an array
+/// of samples. It can also be saved back to a file.
+///
+/// Sound buffers alone are not very useful: they hold the audio data
+/// but cannot be played. To do so, you need to use the sf::Sound class,
+/// which provides functions to play/pause/stop the sound as well as
+/// changing the way it is outputted (volume, pitch, 3D position, ...).
+/// This separation allows more flexibility and better performances:
+/// indeed a sf::SoundBuffer is a heavy resource, and any operation on it
+/// is slow (often too slow for real-time applications). On the other
+/// side, a sf::Sound is a lightweight object, which can use the audio data
+/// of a sound buffer and change the way it is played without actually
+/// modifying that data. Note that it is also possible to bind
+/// several sf::Sound instances to the same sf::SoundBuffer.
+///
+/// It is important to note that the sf::Sound instance doesn't
+/// copy the buffer that it uses, it only keeps a reference to it.
+/// Thus, a sf::SoundBuffer must not be destructed while it is
+/// used by a sf::Sound (i.e. never write a function that
+/// uses a local sf::SoundBuffer instance for loading a sound).
+///
+/// Usage example:
+/// \code
+/// // Declare a new sound buffer
+/// sf::SoundBuffer buffer;
+///
+/// // Load it from a file
+/// if (!buffer.loadFromFile("sound.wav"))
+/// {
+/// // error...
+/// }
+///
+/// // Create a sound source and bind it to the buffer
+/// sf::Sound sound1;
+/// sound1.setBuffer(buffer);
+///
+/// // Play the sound
+/// sound1.play();
+///
+/// // Create another sound source bound to the same buffer
+/// sf::Sound sound2;
+/// sound2.setBuffer(buffer);
+///
+/// // Play it with a higher pitch -- the first sound remains unchanged
+/// sound2.setPitch(2);
+/// sound2.play();
+/// \endcode
+///
+/// \see sf::Sound, sf::SoundBufferRecorder
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Audio/SoundBufferRecorder.hpp b/include/SFML/Audio/SoundBufferRecorder.hpp index e949a1c..fa4ac4c 100755..100644 --- a/include/SFML/Audio/SoundBufferRecorder.hpp +++ b/include/SFML/Audio/SoundBufferRecorder.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,6 +28,7 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
+#include <SFML/Audio/Export.hpp>
#include <SFML/Audio/SoundBuffer.hpp>
#include <SFML/Audio/SoundRecorder.hpp>
#include <vector>
@@ -36,48 +37,102 @@ namespace sf
{
////////////////////////////////////////////////////////////
-/// Specialized SoundRecorder which saves the captured
-/// audio data into a sound buffer
+/// \brief Specialized SoundRecorder which stores the captured
+/// audio data into a sound buffer
+///
////////////////////////////////////////////////////////////
-class SFML_API SoundBufferRecorder : public SoundRecorder
+class SFML_AUDIO_API SoundBufferRecorder : public SoundRecorder
{
public :
////////////////////////////////////////////////////////////
- /// Get the sound buffer containing the captured audio data
+ /// \brief Get the sound buffer containing the captured audio data
///
- /// \return Constant reference to the sound buffer
+ /// The sound buffer is valid only after the capture has ended.
+ /// This function provides a read-only access to the internal
+ /// sound buffer, but it can be copied if you need to
+ /// make any modification to it.
+ ///
+ /// \return Read-only access to the sound buffer
///
////////////////////////////////////////////////////////////
- const SoundBuffer& GetBuffer() const;
+ const SoundBuffer& getBuffer() const;
-private :
+protected:
////////////////////////////////////////////////////////////
- /// /see SoundBuffer::OnStart
+ /// \brief Start capturing audio data
+ ///
+ /// \return True to start the capture, or false to abort it
///
////////////////////////////////////////////////////////////
- virtual bool OnStart();
+ virtual bool onStart();
////////////////////////////////////////////////////////////
- /// /see SoundBuffer::OnProcessSamples
+ /// \brief Process a new chunk of recorded samples
+ ///
+ /// \param samples Pointer to the new chunk of recorded samples
+ /// \param sampleCount Number of samples pointed by \a samples
+ ///
+ /// \return True to continue the capture, or false to stop it
///
////////////////////////////////////////////////////////////
- virtual bool OnProcessSamples(const Int16* Samples, std::size_t SamplesCount);
+ virtual bool onProcessSamples(const Int16* samples, std::size_t sampleCount);
////////////////////////////////////////////////////////////
- /// /see SoundBuffer::OnStop
+ /// \brief Stop capturing audio data
///
////////////////////////////////////////////////////////////
- virtual void OnStop();
+ virtual void onStop();
+
+private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- std::vector<Int16> mySamples; ///< Temporary sample buffer to hold the recorded data
- SoundBuffer myBuffer; ///< Sound buffer that will contain the recorded data
+ std::vector<Int16> m_samples; ///< Temporary sample buffer to hold the recorded data
+ SoundBuffer m_buffer; ///< Sound buffer that will contain the recorded data
};
} // namespace sf
#endif // SFML_SOUNDBUFFERRECORDER_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::SoundBufferRecorder
+/// \ingroup audio
+///
+/// sf::SoundBufferRecorder allows to access a recorded sound
+/// through a sf::SoundBuffer, so that it can be played, saved
+/// to a file, etc.
+///
+/// It has the same simple interface as its base class (start(), stop())
+/// and adds a function to retrieve the recorded sound buffer
+/// (getBuffer()).
+///
+/// As usual, don't forget to call the isAvailable() function
+/// before using this class (see sf::SoundRecorder for more details
+/// about this).
+///
+/// Usage example:
+/// \code
+/// if (sf::SoundBufferRecorder::isAvailable())
+/// {
+/// // Record some audio data
+/// sf::SoundBufferRecorder recorder;
+/// recorder.start();
+/// ...
+/// recorder.stop();
+///
+/// // Get the buffer containing the captured audio data
+/// const sf::SoundBuffer& buffer = recorder.getBuffer();
+///
+/// // Save it to a file (for example...)
+/// buffer.saveToFile("my_record.ogg");
+/// }
+/// \endcode
+///
+/// \see sf::SoundRecorder
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Audio/SoundRecorder.hpp b/include/SFML/Audio/SoundRecorder.hpp index 551a4b9..eddf48e 100755..100644 --- a/include/SFML/Audio/SoundRecorder.hpp +++ b/include/SFML/Audio/SoundRecorder.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,6 +28,7 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
+#include <SFML/Audio/Export.hpp>
#include <SFML/System/Thread.hpp>
#include <vector>
@@ -35,114 +36,235 @@ namespace sf
{
////////////////////////////////////////////////////////////
-/// SoundRecorder is an interface for capturing sound data,
-/// it is meant to be used as a base class
+/// \brief Abstract base class for capturing sound data
+///
////////////////////////////////////////////////////////////
-class SFML_API SoundRecorder : private Thread
+class SFML_AUDIO_API SoundRecorder
{
public :
////////////////////////////////////////////////////////////
- /// Virtual destructor
+ /// \brief destructor
///
////////////////////////////////////////////////////////////
virtual ~SoundRecorder();
////////////////////////////////////////////////////////////
- /// Start the capture.
- /// Warning : only one capture can happen at the same time
+ /// \brief Start the capture
///
- /// \param SampleRate : Sound frequency (the more samples, the higher the quality)
- /// (44100 by default = CD quality)
+ /// The \a sampleRate parameter defines the number of audio samples
+ /// captured per second. The higher, the better the quality
+ /// (for example, 44100 samples/sec is CD quality).
+ /// This function uses its own thread so that it doesn't block
+ /// the rest of the program while the capture runs.
+ /// Please note that only one capture can happen at the same time.
+ ///
+ /// \param sampleRate Desired capture rate, in number of samples per second
+ ///
+ /// \see stop
///
////////////////////////////////////////////////////////////
- void Start(unsigned int SampleRate = 44100);
+ void start(unsigned int sampleRate = 44100);
////////////////////////////////////////////////////////////
- /// Stop the capture
+ /// \brief Stop the capture
+ ///
+ /// \see start
///
////////////////////////////////////////////////////////////
- void Stop();
+ void stop();
////////////////////////////////////////////////////////////
- /// Get the sample rate
+ /// \brief Get the sample rate
///
- /// \return Frequency, in samples per second
+ /// The sample rate defines the number of audio samples
+ /// captured per second. The higher, the better the quality
+ /// (for example, 44100 samples/sec is CD quality).
+ ///
+ /// \return Sample rate, in samples per second
///
////////////////////////////////////////////////////////////
- unsigned int GetSampleRate() const;
+ unsigned int getSampleRate() const;
////////////////////////////////////////////////////////////
- /// Tell if the system supports sound capture.
- /// If not, this class won't be usable
+ /// \brief Check if the system supports audio capture
+ ///
+ /// This function should always be called before using
+ /// the audio capture features. If it returns false, then
+ /// any attempt to use sf::SoundRecorder or one of its derived
+ /// classes will fail.
///
- /// \return True if audio capture is supported
+ /// \return True if audio capture is supported, false otherwise
///
////////////////////////////////////////////////////////////
- static bool CanCapture();
+ static bool isAvailable();
protected :
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
+ ///
+ /// This constructor is only meant to be called by derived classes.
///
////////////////////////////////////////////////////////////
SoundRecorder();
-private :
-
////////////////////////////////////////////////////////////
- /// Start recording audio data
+ /// \brief Start capturing audio data
///
- /// \return False to abort recording audio data, true to start
+ /// This virtual function may be overriden by a derived class
+ /// if something has to be done every time a new capture
+ /// starts. If not, this function can be ignored; the default
+ /// implementation does nothing.
+ ///
+ /// \return True to start the capture, or false to abort it
///
////////////////////////////////////////////////////////////
- virtual bool OnStart();
+ virtual bool onStart();
////////////////////////////////////////////////////////////
- /// Process a new chunk of recorded samples
+ /// \brief Process a new chunk of recorded samples
+ ///
+ /// This virtual function is called every time a new chunk of
+ /// recorded data is available. The derived class can then do
+ /// whatever it wants with it (storing it, playing it, sending
+ /// it over the network, etc.).
///
- /// \param Samples : Pointer to the new chunk of recorded samples
- /// \param SamplesCount : Number of samples pointed by Samples
+ /// \param samples Pointer to the new chunk of recorded samples
+ /// \param sampleCount Number of samples pointed by \a samples
///
- /// \return False to stop recording audio data, true to continue
+ /// \return True to continue the capture, or false to stop it
///
////////////////////////////////////////////////////////////
- virtual bool OnProcessSamples(const Int16* Samples, std::size_t SamplesCount) = 0;
+ virtual bool onProcessSamples(const Int16* samples, std::size_t sampleCount) = 0;
////////////////////////////////////////////////////////////
- /// Stop recording audio data
+ /// \brief Stop capturing audio data
+ ///
+ /// This virtual function may be overriden by a derived class
+ /// if something has to be done every time the capture
+ /// ends. If not, this function can be ignored; the default
+ /// implementation does nothing.
///
////////////////////////////////////////////////////////////
- virtual void OnStop();
+ virtual void onStop();
+
+private :
////////////////////////////////////////////////////////////
- /// /see Thread::Run
+ /// \brief Function called as the entry point of the thread
+ ///
+ /// This function starts the recording loop, and returns
+ /// only when the capture is stopped.
///
////////////////////////////////////////////////////////////
- virtual void Run();
+ void record();
////////////////////////////////////////////////////////////
- /// Get the available captured samples and process them
+ /// \brief Get the new available audio samples and process them
+ ///
+ /// This function is called continuously during the
+ /// capture loop. It retrieves the captured samples and
+ /// forwards them to the derived class.
///
////////////////////////////////////////////////////////////
- void ProcessCapturedSamples();
+ void processCapturedSamples();
////////////////////////////////////////////////////////////
- /// Clean up the recorder internal resources
+ /// \brief Clean up the recorder's internal resources
+ ///
+ /// This function is called when the capture stops.
///
////////////////////////////////////////////////////////////
- void CleanUp();
+ void cleanup();
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- std::vector<Int16> mySamples; ///< Buffer to store captured samples
- unsigned int mySampleRate; ///< Sample rate
- bool myIsCapturing; ///< Capturing state
+ Thread m_thread; ///< Thread running the background recording task
+ std::vector<Int16> m_samples; ///< Buffer to store captured samples
+ unsigned int m_sampleRate; ///< Sample rate
+ bool m_isCapturing; ///< Capturing state
};
} // namespace sf
#endif // SFML_SOUNDRECORDER_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::SoundRecorder
+/// \ingroup audio
+///
+/// sf::SoundBuffer provides a simple interface to access
+/// the audio recording capabilities of the computer
+/// (the microphone). As an abstract base class, it only cares
+/// about capturing sound samples, the task of making something
+/// useful with them is left to the derived class. Note that
+/// SFML provides a built-in specialization for saving the
+/// captured data to a sound buffer (see sf::SoundBufferRecorder).
+///
+/// A derived class has only one virtual function to override:
+/// \li onProcessSamples provides the new chunks of audio samples while the capture happens
+///
+/// Moreover, two additionnal virtual functions can be overriden
+/// as well if necessary:
+/// \li onStart is called before the capture happens, to perform custom initializations
+/// \li onStop is called after the capture ends, to perform custom cleanup
+///
+/// The audio capture feature may not be supported or activated
+/// on every platform, thus it is recommended to check its
+/// availability with the isAvailable() function. If it returns
+/// false, then any attempt to use an audio recorder will fail.
+///
+/// It is important to note that the audio capture happens in a
+/// separate thread, so that it doesn't block the rest of the
+/// program. In particular, the onProcessSamples and onStop
+/// virtual functions (but not onStart) will be called
+/// from this separate thread. It is important to keep this in
+/// mind, because you may have to take care of synchronization
+/// issues if you share data between threads.
+///
+/// Usage example:
+/// \code
+/// class CustomRecorder : public sf::SoundRecorder
+/// {
+/// virtual bool onStart() // optional
+/// {
+/// // Initialize whatever has to be done before the capture starts
+/// ...
+///
+/// // Return true to start playing
+/// return true;
+/// }
+///
+/// virtual bool onProcessSamples(const Int16* samples, std::size_t sampleCount)
+/// {
+/// // Do something with the new chunk of samples (store them, send them, ...)
+/// ...
+///
+/// // Return true to continue playing
+/// return true;
+/// }
+///
+/// virtual void onStop() // optional
+/// {
+/// // Clean up whatever has to be done after the capture ends
+/// ...
+/// }
+/// }
+///
+/// // Usage
+/// if (CustomRecorder::isAvailable())
+/// {
+/// CustomRecorder recorder;
+/// recorder.start();
+/// ...
+/// recorder.stop();
+/// }
+/// \endcode
+///
+/// \see sf::SoundBufferRecorder
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Audio/SoundSource.hpp b/include/SFML/Audio/SoundSource.hpp new file mode 100644 index 0000000..8ccc0b7 --- /dev/null +++ b/include/SFML/Audio/SoundSource.hpp @@ -0,0 +1,286 @@ +////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+// you must not claim that you wrote the original software.
+// If you use this software in a product, an acknowledgment
+// in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+// and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_SOUNDSOURCE_HPP
+#define SFML_SOUNDSOURCE_HPP
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Audio/Export.hpp>
+#include <SFML/System/Vector3.hpp>
+
+
+namespace sf
+{
+////////////////////////////////////////////////////////////
+/// \brief Base class defining a sound's properties
+///
+////////////////////////////////////////////////////////////
+class SFML_AUDIO_API SoundSource
+{
+public :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Enumeration of the sound source states
+ ///
+ ////////////////////////////////////////////////////////////
+ enum Status
+ {
+ Stopped, ///< Sound is not playing
+ Paused, ///< Sound is paused
+ Playing ///< Sound is playing
+ };
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Copy constructor
+ ///
+ /// \param copy Instance to copy
+ ///
+ ////////////////////////////////////////////////////////////
+ SoundSource(const SoundSource& copy);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Destructor
+ ///
+ ////////////////////////////////////////////////////////////
+ virtual ~SoundSource();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Set the pitch of the sound
+ ///
+ /// The pitch represents the perceived fundamental frequency
+ /// of a sound; thus you can make a sound more acute or grave
+ /// by changing its pitch. A side effect of changing the pitch
+ /// is to modify the playing speed of the sound as well.
+ /// The default value for the pitch is 1.
+ ///
+ /// \param pitch New pitch to apply to the sound
+ ///
+ /// \see getPitch
+ ///
+ ////////////////////////////////////////////////////////////
+ void setPitch(float pitch);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Set the volume of the sound
+ ///
+ /// The volume is a value between 0 (mute) and 100 (full volume).
+ /// The default value for the volume is 100.
+ ///
+ /// \param volume Volume of the sound
+ ///
+ /// \see getVolume
+ ///
+ ////////////////////////////////////////////////////////////
+ void setVolume(float volume);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Set the 3D position of the sound in the audio scene
+ ///
+ /// Only sounds with one channel (mono sounds) can be
+ /// spatialized.
+ /// The default position of a sound is (0, 0, 0).
+ ///
+ /// \param x X coordinate of the position of the sound in the scene
+ /// \param y Y coordinate of the position of the sound in the scene
+ /// \param z Z coordinate of the position of the sound in the scene
+ ///
+ /// \see getPosition
+ ///
+ ////////////////////////////////////////////////////////////
+ void setPosition(float x, float y, float z);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Set the 3D position of the sound in the audio scene
+ ///
+ /// Only sounds with one channel (mono sounds) can be
+ /// spatialized.
+ /// The default position of a sound is (0, 0, 0).
+ ///
+ /// \param position Position of the sound in the scene
+ ///
+ /// \see getPosition
+ ///
+ ////////////////////////////////////////////////////////////
+ void setPosition(const Vector3f& position);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Make the sound's position relative to the listener or absolute
+ ///
+ /// Making a sound relative to the listener will ensure that it will always
+ /// be played the same way regardless the position of the listener.
+ /// This can be useful for non-spatialized sounds, sounds that are
+ /// produced by the listener, or sounds attached to it.
+ /// The default value is false (position is absolute).
+ ///
+ /// \param relative True to set the position relative, false to set it absolute
+ ///
+ /// \see isRelativeToListener
+ ///
+ ////////////////////////////////////////////////////////////
+ void setRelativeToListener(bool relative);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Set the minimum distance of the sound
+ ///
+ /// The "minimum distance" of a sound is the maximum
+ /// distance at which it is heard at its maximum volume. Further
+ /// than the minimum distance, it will start to fade out according
+ /// to its attenuation factor. A value of 0 ("inside the head
+ /// of the listener") is an invalid value and is forbidden.
+ /// The default value of the minimum distance is 1.
+ ///
+ /// \param distance New minimum distance of the sound
+ ///
+ /// \see getMinDistance, setAttenuation
+ ///
+ ////////////////////////////////////////////////////////////
+ void setMinDistance(float distance);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Set the attenuation factor of the sound
+ ///
+ /// The attenuation is a multiplicative factor which makes
+ /// the sound more or less loud according to its distance
+ /// from the listener. An attenuation of 0 will produce a
+ /// non-attenuated sound, i.e. its volume will always be the same
+ /// whether it is heard from near or from far. On the other hand,
+ /// an attenuation value such as 100 will make the sound fade out
+ /// very quickly as it gets further from the listener.
+ /// The default value of the attenuation is 1.
+ ///
+ /// \param attenuation New attenuation factor of the sound
+ ///
+ /// \see getAttenuation, setMinDistance
+ ///
+ ////////////////////////////////////////////////////////////
+ void setAttenuation(float attenuation);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the pitch of the sound
+ ///
+ /// \return Pitch of the sound
+ ///
+ /// \see setPitch
+ ///
+ ////////////////////////////////////////////////////////////
+ float getPitch() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the volume of the sound
+ ///
+ /// \return Volume of the sound, in the range [0, 100]
+ ///
+ /// \see setVolume
+ ///
+ ////////////////////////////////////////////////////////////
+ float getVolume() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the 3D position of the sound in the audio scene
+ ///
+ /// \return Position of the sound
+ ///
+ /// \see setPosition
+ ///
+ ////////////////////////////////////////////////////////////
+ Vector3f getPosition() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Tell whether the sound's position is relative to the
+ /// listener or is absolute
+ ///
+ /// \return True if the position is relative, false if it's absolute
+ ///
+ /// \see setRelativeToListener
+ ///
+ ////////////////////////////////////////////////////////////
+ bool isRelativeToListener() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the minimum distance of the sound
+ ///
+ /// \return Minimum distance of the sound
+ ///
+ /// \see setMinDistance, getAttenuation
+ ///
+ ////////////////////////////////////////////////////////////
+ float getMinDistance() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the attenuation factor of the sound
+ ///
+ /// \return Attenuation factor of the sound
+ ///
+ /// \see setAttenuation, getMinDistance
+ ///
+ ////////////////////////////////////////////////////////////
+ float getAttenuation() const;
+
+protected :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Default constructor
+ ///
+ /// This constructor is meant ot be called by derived classes only.
+ ///
+ ////////////////////////////////////////////////////////////
+ SoundSource();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the current status of the sound (stopped, paused, playing)
+ ///
+ /// \return Current status of the sound
+ ///
+ ////////////////////////////////////////////////////////////
+ Status getStatus() const;
+
+ ////////////////////////////////////////////////////////////
+ // Member data
+ ////////////////////////////////////////////////////////////
+ unsigned int m_source; ///< OpenAL source identifier
+};
+
+} // namespace sf
+
+
+#endif // SFML_SOUNDSOURCE_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::SoundSource
+/// \ingroup audio
+///
+/// sf::SoundSource is not meant to be used directly, it
+/// only serves as a common base for all audio objects
+/// that can live in the audio environment.
+///
+/// It defines several properties for the sound: pitch,
+/// volume, position, attenuation, etc. All of them can be
+/// changed at any time with no impact on performances.
+///
+/// \see sf::Sound, sf::SoundStream
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Audio/SoundStream.hpp b/include/SFML/Audio/SoundStream.hpp index 67b2bab..461dd92 100755..100644 --- a/include/SFML/Audio/SoundStream.hpp +++ b/include/SFML/Audio/SoundStream.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,201 +28,350 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/Audio/Sound.hpp>
+#include <SFML/Audio/Export.hpp>
+#include <SFML/Audio/SoundSource.hpp>
#include <SFML/System/Thread.hpp>
+#include <SFML/System/Time.hpp>
#include <cstdlib>
namespace sf
{
////////////////////////////////////////////////////////////
-/// SoundStream is a streamed sound, ie samples are acquired
-/// while the sound is playing. Use it for big sounds that would
-/// require hundreds of MB in memory (see Music),
-/// or for streaming sound from the network
+/// \brief Abstract base class for streamed audio sources
+///
////////////////////////////////////////////////////////////
-class SFML_API SoundStream : private Thread, private Sound
+class SFML_AUDIO_API SoundStream : public SoundSource
{
public :
- using Sound::Status;
- using Sound::Stopped;
- using Sound::Paused;
- using Sound::Playing;
- using Sound::Pause;
- using Sound::SetPitch;
- using Sound::SetVolume;
- using Sound::SetPosition;
- using Sound::SetRelativeToListener;
- using Sound::SetMinDistance;
- using Sound::SetAttenuation;
- using Sound::GetPitch;
- using Sound::GetVolume;
- using Sound::GetPosition;
- using Sound::IsRelativeToListener;
- using Sound::GetMinDistance;
- using Sound::GetAttenuation;
-
- ////////////////////////////////////////////////////////////
- /// Structure defining a chunk of audio data to stream
+ ////////////////////////////////////////////////////////////
+ /// \brief Structure defining a chunk of audio data to stream
+ ///
////////////////////////////////////////////////////////////
struct Chunk
{
- const Int16* Samples; ///< Pointer to the audio samples
- std::size_t NbSamples; ///< Number of samples pointed by Samples
+ const Int16* samples; ///< Pointer to the audio samples
+ std::size_t sampleCount; ///< Number of samples pointed by Samples
};
////////////////////////////////////////////////////////////
- /// Virtual destructor
+ /// \brief Destructor
///
////////////////////////////////////////////////////////////
virtual ~SoundStream();
////////////////////////////////////////////////////////////
- /// Start playing the audio stream
+ /// \brief Start or resume playing the audio stream
+ ///
+ /// This function starts the stream if it was stopped, resumes
+ /// it if it was paused, and restarts it from beginning if it
+ /// was it already playing.
+ /// This function uses its own thread so that it doesn't block
+ /// the rest of the program while the stream is played.
+ ///
+ /// \see pause, stop
+ ///
+ ////////////////////////////////////////////////////////////
+ void play();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Pause the audio stream
+ ///
+ /// This function pauses the stream if it was playing,
+ /// otherwise (stream already paused or stopped) it has no effect.
+ ///
+ /// \see play, stop
///
////////////////////////////////////////////////////////////
- void Play();
+ void pause();
////////////////////////////////////////////////////////////
- /// Stop playing the audio stream
+ /// \brief Stop playing the audio stream
+ ///
+ /// This function stops the stream if it was playing or paused,
+ /// and does nothing if it was already stopped.
+ /// It also resets the playing position (unlike pause()).
+ ///
+ /// \see play, pause
///
////////////////////////////////////////////////////////////
- void Stop();
+ void stop();
////////////////////////////////////////////////////////////
- /// Return the number of channels (1 = mono, 2 = stereo)
+ /// \brief Return the number of channels of the stream
+ ///
+ /// 1 channel means a mono sound, 2 means stereo, etc.
///
/// \return Number of channels
///
////////////////////////////////////////////////////////////
- unsigned int GetChannelsCount() const;
+ unsigned int getChannelCount() const;
////////////////////////////////////////////////////////////
- /// Get the stream sample rate
+ /// \brief Get the stream sample rate of the stream
+ ///
+ /// The sample rate is the number of audio samples played per
+ /// second. The higher, the better the quality.
///
- /// \return Stream frequency (number of samples per second)
+ /// \return Sample rate, in number of samples per second
///
////////////////////////////////////////////////////////////
- unsigned int GetSampleRate() const;
+ unsigned int getSampleRate() const;
////////////////////////////////////////////////////////////
- /// Get the status of the stream (stopped, paused, playing)
+ /// \brief Get the current status of the stream (stopped, paused, playing)
///
- /// \return Current status of the sound
+ /// \return Current status
///
////////////////////////////////////////////////////////////
- Status GetStatus() const;
+ Status getStatus() const;
////////////////////////////////////////////////////////////
- /// Get the current playing position of the stream
+ /// \brief Change the current playing position of the stream
+ ///
+ /// The playing position can be changed when the stream is
+ /// either paused or playing.
///
- /// \return Current playing position, expressed in seconds
+ /// \param timeOffset New playing position, from the beginning of the stream
+ ///
+ /// \see getPlayingOffset
///
////////////////////////////////////////////////////////////
- float GetPlayingOffset() const;
+ void setPlayingOffset(Time timeOffset);
////////////////////////////////////////////////////////////
- /// Set the stream loop state.
- /// This parameter is disabled by default
+ /// \brief Get the current playing position of the stream
+ ///
+ /// \return Current playing position, from the beginning of the stream
///
- /// \param Loop : True to play in loop, false to play once
+ /// \see setPlayingOffset
///
////////////////////////////////////////////////////////////
- void SetLoop(bool Loop);
+ Time getPlayingOffset() const;
////////////////////////////////////////////////////////////
- /// Tell whether or not the stream is looping
+ /// \brief Set whether or not the stream should loop after reaching the end
+ ///
+ /// If set, the stream will restart from beginning after
+ /// reaching the end and so on, until it is stopped or
+ /// setLoop(false) is called.
+ /// The default looping state for streams is false.
///
- /// \return True if the music is looping, false otherwise
+ /// \param loop True to play in loop, false to play once
+ ///
+ /// \see getLoop
///
////////////////////////////////////////////////////////////
- bool GetLoop() const;
+ void setLoop(bool loop);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Tell whether or not the stream is in loop mode
+ ///
+ /// \return True if the stream is looping, false otherwise
+ ///
+ /// \see setLoop
+ ///
+ ////////////////////////////////////////////////////////////
+ bool getLoop() const;
protected :
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
+ ///
+ /// This constructor is only meant to be called by derived classes.
///
////////////////////////////////////////////////////////////
SoundStream();
////////////////////////////////////////////////////////////
- /// Set the audio stream parameters, you must call it before Play()
+ /// \brief Define the audio stream parameters
+ ///
+ /// This function must be called by derived classes as soon
+ /// as they know the audio settings of the stream to play.
+ /// Any attempt to manipulate the stream (play(), ...) before
+ /// calling this function will fail.
+ /// It can be called multiple times if the settings of the
+ /// audio stream change, but only when the stream is stopped.
///
- /// \param ChannelsCount : Number of channels
- /// \param SampleRate : Sample rate
+ /// \param channelCount Number of channels of the stream
+ /// \param sampleRate Sample rate, in samples per second
///
////////////////////////////////////////////////////////////
- void Initialize(unsigned int ChannelsCount, unsigned int SampleRate);
-
-private :
+ void initialize(unsigned int channelCount, unsigned int sampleRate);
////////////////////////////////////////////////////////////
- /// /see Thread::Run
+ /// \brief Request a new chunk of audio samples from the stream source
+ ///
+ /// This function must be overriden by derived classes to provide
+ /// the audio samples to play. It is called continuously by the
+ /// streaming loop, in a separate thread.
+ /// The source can choose to stop the streaming loop at any time, by
+ /// returning false to the caller.
+ ///
+ /// \param data Chunk of data to fill
+ ///
+ /// \return True to continue playback, false to stop
///
////////////////////////////////////////////////////////////
- virtual void Run();
+ virtual bool onGetData(Chunk& data) = 0;
////////////////////////////////////////////////////////////
- /// Called when the sound restarts
+ /// \brief Change the current playing position in the stream source
///
- /// \return If false is returned, the playback is aborted
+ /// This function must be overriden by derived classes to
+ /// allow random seeking into the stream source.
+ ///
+ /// \param timeOffset New playing position, relative to the beginning of the stream
///
////////////////////////////////////////////////////////////
- virtual bool OnStart();
+ virtual void onSeek(Time timeOffset) = 0;
+
+private :
////////////////////////////////////////////////////////////
- /// Called each time new audio data is needed to feed the stream
+ /// \brief Function called as the entry point of the thread
///
- /// \param Data : New chunk of data to stream
- ///
- /// \return True to continue playback, false to stop
+ /// This function starts the streaming loop, and returns
+ /// only when the sound is stopped.
///
////////////////////////////////////////////////////////////
- virtual bool OnGetData(Chunk& Data) = 0;
+ void streamData();
////////////////////////////////////////////////////////////
- /// Fill a new buffer with audio data, and push it to the
- /// playing queue
+ /// \brief Fill a new buffer with audio samples, and append
+ /// it to the playing queue
+ ///
+ /// This function is called as soon as a buffer has been fully
+ /// consumed; it fills it again and inserts it back into the
+ /// playing queue.
///
- /// \param Buffer : Number of the buffer to fill (in [0, BuffersCount])
+ /// \param buffer Number of the buffer to fill (in [0, BufferCount])
///
- /// \return True if the derived class has requested to stop
+ /// \return True if the stream source has requested to stop, false otherwise
///
////////////////////////////////////////////////////////////
- bool FillAndPushBuffer(unsigned int BufferNum);
+ bool fillAndPushBuffer(unsigned int bufferNum);
////////////////////////////////////////////////////////////
- /// Fill the buffers queue with all available buffers
+ /// \brief Fill the audio buffers and put them all into the playing queue
///
- /// \return True if the derived class has requested to stop
+ /// This function is called when playing starts and the
+ /// playing queue is empty.
+ ///
+ /// \return True if the derived class has requested to stop, false otherwise
///
////////////////////////////////////////////////////////////
- bool FillQueue();
+ bool fillQueue();
////////////////////////////////////////////////////////////
- /// Clear the queue of any remaining buffers
+ /// \brief Clear all the audio buffers and empty the playing queue
+ ///
+ /// This function is called when the stream is stopped.
///
////////////////////////////////////////////////////////////
- void ClearQueue();
+ void clearQueue();
- enum {BuffersCount = 3};
+ enum
+ {
+ BufferCount = 3 ///< Number of audio buffers used by the streaming loop
+ };
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- bool myIsStreaming; ///< Streaming state (true = playing, false = stopped)
- unsigned int myBuffers[BuffersCount]; ///< Sound buffers used to store temporary audio data
- unsigned int myChannelsCount; ///< Number of channels (1 = mono, 2 = stereo, ...)
- unsigned int mySampleRate; ///< Frequency (samples / second)
- unsigned long myFormat; ///< Format of the internal sound buffers
- bool myLoop; ///< Loop flag (true to loop, false to play once)
- unsigned int mySamplesProcessed; ///< Number of buffers processed since beginning of the stream
- bool myEndBuffers[BuffersCount]; ///< Each buffer is marked as "end buffer" or not, for proper duration calculation
+ Thread m_thread; ///< Thread running the background tasks
+ bool m_isStreaming; ///< Streaming state (true = playing, false = stopped)
+ unsigned int m_buffers[BufferCount]; ///< Sound buffers used to store temporary audio data
+ unsigned int m_channelCount; ///< Number of channels (1 = mono, 2 = stereo, ...)
+ unsigned int m_sampleRate; ///< Frequency (samples / second)
+ Uint32 m_format; ///< Format of the internal sound buffers
+ bool m_loop; ///< Loop flag (true to loop, false to play once)
+ Uint64 m_samplesProcessed; ///< Number of buffers processed since beginning of the stream
+ bool m_endBuffers[BufferCount]; ///< Each buffer is marked as "end buffer" or not, for proper duration calculation
};
} // namespace sf
#endif // SFML_SOUNDSTREAM_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::SoundStream
+/// \ingroup audio
+///
+/// Unlike audio buffers (see sf::SoundBuffer), audio streams
+/// are never completely loaded in memory. Instead, the audio
+/// data is acquired continuously while the stream is playing.
+/// This behaviour allows to play a sound with no loading delay,
+/// and keeps the memory consumption very low.
+///
+/// Sound sources that need to be streamed are usually big files
+/// (compressed audio musics that would eat hundreds of MB in memory)
+/// or files that would take a lot of time to be received
+/// (sounds played over the network).
+///
+/// sf::SoundStream is a base class that doesn't care about the
+/// stream source, which is left to the derived class. SFML provides
+/// a built-in specialization for big files (see sf::Music).
+/// No network stream source is provided, but you can write your own
+/// by combining this class with the network module.
+///
+/// A derived class has to override two virtual functions:
+/// \li onGetData fills a new chunk of audio data to be played
+/// \li onSeek changes the current playing position in the source
+///
+/// It is important to note that each SoundStream is played in its
+/// own separate thread, so that the streaming loop doesn't block the
+/// rest of the program. In particular, the OnGetData and OnSeek
+/// virtual functions may sometimes be called from this separate thread.
+/// It is important to keep this in mind, because you may have to take
+/// care of synchronization issues if you share data between threads.
+///
+/// Usage example:
+/// \code
+/// class CustomStream : public sf::SoundStream
+/// {
+/// public :
+///
+/// bool open(const std::string& location)
+/// {
+/// // Open the source and get audio settings
+/// ...
+/// unsigned int channelCount = ...;
+/// unsigned int sampleRate = ...;
+///
+/// // Initialize the stream -- important!
+/// initialize(channelCount, sampleRate);
+/// }
+///
+/// private :
+///
+/// virtual bool onGetData(Chunk& data)
+/// {
+/// // Fill the chunk with audio data from the stream source
+/// data.samples = ...;
+/// data.sampleCount = ...;
+///
+/// // Return true to continue playing
+/// return true;
+/// }
+///
+/// virtual void onSeek(Uint32 timeOffset)
+/// {
+/// // Change the current position in the stream source
+/// ...
+/// }
+/// }
+///
+/// // Usage
+/// CustomStream stream;
+/// stream.open("path/to/stream");
+/// stream.play();
+/// \endcode
+///
+/// \see sf::Music
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Config.hpp b/include/SFML/Config.hpp index 84ec60f..933cd11 100755..100644 --- a/include/SFML/Config.hpp +++ b/include/SFML/Config.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -25,6 +25,14 @@ #ifndef SFML_CONFIG_HPP
#define SFML_CONFIG_HPP
+
+////////////////////////////////////////////////////////////
+// Define the SFML version
+////////////////////////////////////////////////////////////
+#define SFML_VERSION_MAJOR 2
+#define SFML_VERSION_MINOR 1
+
+
////////////////////////////////////////////////////////////
// Identify the operating system
////////////////////////////////////////////////////////////
@@ -32,9 +40,6 @@ // Windows
#define SFML_SYSTEM_WINDOWS
- #ifndef WIN32_LEAN_AND_MEAN
- #define WIN32_LEAN_AND_MEAN
- #endif
#ifndef NOMINMAX
#define NOMINMAX
#endif
@@ -73,45 +78,47 @@ ////////////////////////////////////////////////////////////
-// Define portable import / export macros
+// Define helpers to create portable import / export macros for each module
////////////////////////////////////////////////////////////
-#if defined(SFML_SYSTEM_WINDOWS)
+#if !defined(SFML_STATIC)
- #ifdef SFML_DYNAMIC
+ #if defined(SFML_SYSTEM_WINDOWS)
- // Windows platforms
- #ifdef SFML_EXPORTS
+ // Windows compilers need specific (and different) keywords for export and import
+ #define SFML_API_EXPORT __declspec(dllexport)
+ #define SFML_API_IMPORT __declspec(dllimport)
- // From DLL side, we must export
- #define SFML_API __declspec(dllexport)
-
- #else
+ // For Visual C++ compilers, we also need to turn off this annoying C4251 warning
+ #ifdef _MSC_VER
- // From client application side, we must import
- #define SFML_API __declspec(dllimport)
+ #pragma warning(disable : 4251)
#endif
- // For Visual C++ compilers, we also need to turn off this annoying C4251 warning.
- // You can read lots ot different things about it, but the point is the code will
- // just work fine, and so the simplest way to get rid of this warning is to disable it
- #ifdef _MSC_VER
+ #else // Linux, FreeBSD, Mac OS X
- #pragma warning(disable : 4251)
+ #if __GNUC__ >= 4
- #endif
+ // GCC 4 has special keywords for showing/hidding symbols,
+ // the same keyword is used for both importing and exporting
+ #define SFML_API_EXPORT __attribute__ ((__visibility__ ("default")))
+ #define SFML_API_IMPORT __attribute__ ((__visibility__ ("default")))
- #else
+ #else
- // No specific directive needed for static build
- #define SFML_API
+ // GCC < 4 has no mechanism to explicitely hide symbols, everything's exported
+ #define SFML_API_EXPORT
+ #define SFML_API_IMPORT
+
+ #endif
#endif
#else
- // Other platforms don't need to define anything
- #define SFML_API
+ // Static build doesn't need import/export macros
+ #define SFML_API_EXPORT
+ #define SFML_API_IMPORT
#endif
@@ -119,44 +126,31 @@ ////////////////////////////////////////////////////////////
// Define portable fixed-size types
////////////////////////////////////////////////////////////
-#include <climits>
-
namespace sf
{
+ // All "common" platforms use the same size for char, short and int
+ // (basically there are 3 types for 3 sizes, so no other match is possible),
+ // we can use them without doing any kind of check
+
// 8 bits integer types
- #if UCHAR_MAX == 0xFF
- typedef signed char Int8;
- typedef unsigned char Uint8;
- #else
- #error No 8 bits integer type for this platform
- #endif
+ typedef signed char Int8;
+ typedef unsigned char Uint8;
// 16 bits integer types
- #if USHRT_MAX == 0xFFFF
- typedef signed short Int16;
- typedef unsigned short Uint16;
- #elif UINT_MAX == 0xFFFF
- typedef signed int Int16;
- typedef unsigned int Uint16;
- #elif ULONG_MAX == 0xFFFF
- typedef signed long Int16;
- typedef unsigned long Uint16;
- #else
- #error No 16 bits integer type for this platform
- #endif
+ typedef signed short Int16;
+ typedef unsigned short Uint16;
// 32 bits integer types
- #if USHRT_MAX == 0xFFFFFFFF
- typedef signed short Int32;
- typedef unsigned short Uint32;
- #elif UINT_MAX == 0xFFFFFFFF
- typedef signed int Int32;
- typedef unsigned int Uint32;
- #elif ULONG_MAX == 0xFFFFFFFF
- typedef signed long Int32;
- typedef unsigned long Uint32;
+ typedef signed int Int32;
+ typedef unsigned int Uint32;
+
+ // 64 bits integer types
+ #if defined(_MSC_VER)
+ typedef signed __int64 Int64;
+ typedef unsigned __int64 Uint64;
#else
- #error No 32 bits integer type for this platform
+ typedef signed long long Int64;
+ typedef unsigned long long Uint64;
#endif
} // namespace sf
diff --git a/include/SFML/Graphics.hpp b/include/SFML/Graphics.hpp index ea4d846..0dc6534 100755..100644 --- a/include/SFML/Graphics.hpp +++ b/include/SFML/Graphics.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -30,16 +30,33 @@ ////////////////////////////////////////////////////////////
#include <SFML/Window.hpp>
+#include <SFML/Graphics/BlendMode.hpp>
#include <SFML/Graphics/Color.hpp>
#include <SFML/Graphics/Font.hpp>
#include <SFML/Graphics/Glyph.hpp>
#include <SFML/Graphics/Image.hpp>
-#include <SFML/Graphics/PostFX.hpp>
+#include <SFML/Graphics/RenderStates.hpp>
+#include <SFML/Graphics/RenderTexture.hpp>
#include <SFML/Graphics/RenderWindow.hpp>
+#include <SFML/Graphics/Shader.hpp>
#include <SFML/Graphics/Shape.hpp>
+#include <SFML/Graphics/CircleShape.hpp>
+#include <SFML/Graphics/RectangleShape.hpp>
+#include <SFML/Graphics/ConvexShape.hpp>
#include <SFML/Graphics/Sprite.hpp>
-#include <SFML/Graphics/String.hpp>
+#include <SFML/Graphics/Text.hpp>
+#include <SFML/Graphics/Texture.hpp>
+#include <SFML/Graphics/Transform.hpp>
+#include <SFML/Graphics/Vertex.hpp>
+#include <SFML/Graphics/VertexArray.hpp>
#include <SFML/Graphics/View.hpp>
#endif // SFML_GRAPHICS_HPP
+
+////////////////////////////////////////////////////////////
+/// \defgroup graphics Graphics module
+///
+/// 2D graphics module: sprites, text, shapes, ...
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Graphics/BlendMode.hpp b/include/SFML/Graphics/BlendMode.hpp new file mode 100644 index 0000000..4b12e11 --- /dev/null +++ b/include/SFML/Graphics/BlendMode.hpp @@ -0,0 +1,46 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_BLENDMODE_HPP +#define SFML_BLENDMODE_HPP + +namespace sf +{ +//////////////////////////////////////////////////////////// +/// \ingroup graphics +/// \brief Available blending modes for drawing +/// +//////////////////////////////////////////////////////////// +enum BlendMode +{ + BlendAlpha, ///< Pixel = Source * Source.a + Dest * (1 - Source.a) + BlendAdd, ///< Pixel = Source + Dest + BlendMultiply, ///< Pixel = Source * Dest + BlendNone ///< Pixel = Source +}; + +} // namespace sf + + +#endif // SFML_BLENDMODE_HPP diff --git a/include/SFML/Graphics/CircleShape.hpp b/include/SFML/Graphics/CircleShape.hpp new file mode 100644 index 0000000..b82539e --- /dev/null +++ b/include/SFML/Graphics/CircleShape.hpp @@ -0,0 +1,151 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_CIRCLESHAPE_HPP +#define SFML_CIRCLESHAPE_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.hpp> +#include <SFML/Graphics/Shape.hpp> + + +namespace sf +{ +//////////////////////////////////////////////////////////// +/// \brief Specialized shape representing a circle +/// +//////////////////////////////////////////////////////////// +class SFML_GRAPHICS_API CircleShape : public Shape +{ +public : + + //////////////////////////////////////////////////////////// + /// \brief Default constructor + /// + /// \param radius Radius of the circle + /// \param pointCount Number of points composing the circle + /// + //////////////////////////////////////////////////////////// + explicit CircleShape(float radius = 0, unsigned int pointCount = 30); + + //////////////////////////////////////////////////////////// + /// \brief Set the radius of the circle + /// + /// \param radius New radius of the circle + /// + /// \see getRadius + /// + //////////////////////////////////////////////////////////// + void setRadius(float radius); + + //////////////////////////////////////////////////////////// + /// \brief Get the radius of the circle + /// + /// \return Radius of the circle + /// + /// \see setRadius + /// + //////////////////////////////////////////////////////////// + float getRadius() const; + + //////////////////////////////////////////////////////////// + /// \brief Set the number of points of the circle + /// + /// \param count New number of points of the circle + /// + /// \see getPointCount + /// + //////////////////////////////////////////////////////////// + void setPointCount(unsigned int count); + + //////////////////////////////////////////////////////////// + /// \brief Get the number of points of the shape + /// + /// \return Number of points of the shape + /// + /// \see setPointCount + /// + //////////////////////////////////////////////////////////// + virtual unsigned int getPointCount() const; + + //////////////////////////////////////////////////////////// + /// \brief Get a point of the shape + /// + /// The result is undefined if \a index is out of the valid range. + /// + /// \param index Index of the point to get, in range [0 .. getPointCount() - 1] + /// + /// \return Index-th point of the shape + /// + //////////////////////////////////////////////////////////// + virtual Vector2f getPoint(unsigned int index) const; + +private : + + //////////////////////////////////////////////////////////// + // Member data + //////////////////////////////////////////////////////////// + float m_radius; ///< Radius of the circle + unsigned int m_pointCount; ///< Number of points composing the circle +}; + +} // namespace sf + + +#endif // SFML_CIRCLESHAPE_HPP + + +//////////////////////////////////////////////////////////// +/// \class sf::CircleShape +/// \ingroup graphics +/// +/// This class inherits all the functions of sf::Transformable +/// (position, rotation, scale, bounds, ...) as well as the +/// functions of sf::Shape (outline, color, texture, ...). +/// +/// Usage example: +/// \code +/// sf::CircleShape circle; +/// circle.setRadius(150); +/// circle.setOutlineColor(sf::Color::Red); +/// circle.setOutlineThickness(5); +/// circle.setPosition(10, 20); +/// ... +/// window.draw(circle); +/// \endcode +/// +/// Since the graphics card can't draw perfect circles, we have to +/// fake them with multiple triangles connected to each other. The +/// "points count" property of sf::CircleShape defines how many of these +/// triangles to use, and therefore defines the quality of the circle. +/// +/// The number of points can also be used for another purpose; with +/// small numbers you can create any regular polygon shape: +/// equilateral triangle, square, pentagon, hexagon, ... +/// +/// \see sf::Shape, sf::RectangleShape, sf::ConvexShape +/// +//////////////////////////////////////////////////////////// diff --git a/include/SFML/Graphics/Color.hpp b/include/SFML/Graphics/Color.hpp index 5f4d4d7..fb2aa2d 100755..100644 --- a/include/SFML/Graphics/Color.hpp +++ b/include/SFML/Graphics/Color.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,87 +28,51 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
+#include <SFML/Graphics/Export.hpp>
namespace sf
{
////////////////////////////////////////////////////////////
-/// Color is an utility class for manipulating
-/// 32-bits RGBA colors
+/// \brief Utility class for manpulating RGBA colors
+///
////////////////////////////////////////////////////////////
-class SFML_API Color
+class SFML_GRAPHICS_API Color
{
public :
////////////////////////////////////////////////////////////
- /// Default constructor
- ///
- ////////////////////////////////////////////////////////////
- Color();
-
- ////////////////////////////////////////////////////////////
- /// Construct the color from its 4 RGBA components
- ///
- /// \param R : Red component (0 .. 255)
- /// \param G : Green component (0 .. 255)
- /// \param B : Blue component (0 .. 255)
- /// \param A : Alpha component (0 .. 255) (255 by default)
- ///
- ////////////////////////////////////////////////////////////
- Color(Uint8 R, Uint8 G, Uint8 B, Uint8 A = 255);
-
- ////////////////////////////////////////////////////////////
- /// Operator += overload to add a color
- ///
- /// \param Other : Color to add
- ///
- /// \return Component-wise saturated addition of the two colors
- ///
- ////////////////////////////////////////////////////////////
- Color& operator +=(const Color& Other);
-
- ////////////////////////////////////////////////////////////
- /// Operator *= overload to modulate a color
+ /// \brief Default constructor
///
- /// \param Other : Color to modulate
+ /// Constructs an opaque black color. It is equivalent to
+ /// sf::Color(0, 0, 0, 255).
///
- /// \return Component-wise multiplication of the two colors
- ///
- ////////////////////////////////////////////////////////////
- Color& operator *=(const Color& Other);
-
////////////////////////////////////////////////////////////
- /// Compare two colors (for equality)
- ///
- /// \param Other : Color to compare
- ///
- /// \return True if colors are equal
- ///
- ////////////////////////////////////////////////////////////
- bool operator ==(const Color& Other) const;
+ Color();
////////////////////////////////////////////////////////////
- /// Compare two colors (for difference)
- ///
- /// \param Other : Color to compare
+ /// \brief Construct the color from its 4 RGBA components
///
- /// \return True if colors are different
+ /// \param red Red component (in the range [0, 255])
+ /// \param green Green component (in the range [0, 255])
+ /// \param blue Blue component (in the range [0, 255])
+ /// \param alpha Alpha (opacity) component (in the range [0, 255])
///
////////////////////////////////////////////////////////////
- bool operator !=(const Color& Other) const;
+ Color(Uint8 red, Uint8 green, Uint8 blue, Uint8 alpha = 255);
////////////////////////////////////////////////////////////
// Static member data
////////////////////////////////////////////////////////////
- static const Color Black; ///< Black predefined color
- static const Color White; ///< White predefined color
- static const Color Red; ///< Red predefined color
- static const Color Green; ///< Green predefined color
- static const Color Blue; ///< Blue predefined color
- static const Color Yellow; ///< Yellow predefined color
- static const Color Magenta; ///< Magenta predefined color
- static const Color Cyan; ///< Cyan predefined color
+ static const Color Black; ///< Black predefined color
+ static const Color White; ///< White predefined color
+ static const Color Red; ///< Red predefined color
+ static const Color Green; ///< Green predefined color
+ static const Color Blue; ///< Blue predefined color
+ static const Color Yellow; ///< Yellow predefined color
+ static const Color Magenta; ///< Magenta predefined color
+ static const Color Cyan; ///< Cyan predefined color
+ static const Color Transparent; ///< Transparent (black) predefined color
////////////////////////////////////////////////////////////
// Member data
@@ -116,32 +80,149 @@ public : Uint8 r; ///< Red component
Uint8 g; ///< Green component
Uint8 b; ///< Blue component
- Uint8 a; ///< Alpha (transparency) component
+ Uint8 a; ///< Alpha (opacity) component
};
////////////////////////////////////////////////////////////
-/// Operator + overload to add two colors
+/// \relates Color
+/// \brief Overload of the == operator
///
-/// \param Color1 : First color
-/// \param Color2 : Second color
+/// This operator compares two colors and check if they are equal.
///
-/// \return Component-wise saturated addition of the two colors
+/// \param left Left operand
+/// \param right Right operand
+///
+/// \return True if colors are equal, false if they are different
///
////////////////////////////////////////////////////////////
-SFML_API Color operator +(const Color& Color1, const Color& Color2);
+SFML_GRAPHICS_API bool operator ==(const Color& left, const Color& right);
////////////////////////////////////////////////////////////
-/// Operator * overload to modulate two colors
+/// \relates Color
+/// \brief Overload of the != operator
+///
+/// This operator compares two colors and check if they are different.
///
-/// \param Color1 : First color
-/// \param Color2 : Second color
+/// \param left Left operand
+/// \param right Right operand
///
-/// \return Component-wise multiplication of the two colors
+/// \return True if colors are different, false if they are equal
///
////////////////////////////////////////////////////////////
-SFML_API Color operator *(const Color& Color1, const Color& Color2);
+SFML_GRAPHICS_API bool operator !=(const Color& left, const Color& right);
+
+////////////////////////////////////////////////////////////
+/// \relates Color
+/// \brief Overload of the binary + operator
+///
+/// This operator returns the component-wise sum of two colors.
+/// Components that exceed 255 are clamped to 255.
+///
+/// \param left Left operand
+/// \param right Right operand
+///
+/// \return Result of \a left + \a right
+///
+////////////////////////////////////////////////////////////
+SFML_GRAPHICS_API Color operator +(const Color& left, const Color& right);
+
+////////////////////////////////////////////////////////////
+/// \relates Color
+/// \brief Overload of the binary * operator
+///
+/// This operator returns the component-wise multiplication
+/// (also called "modulation") of two colors.
+/// Components are then divided by 255 so that the result is
+/// still in the range [0, 255].
+///
+/// \param left Left operand
+/// \param right Right operand
+///
+/// \return Result of \a left * \a right
+///
+////////////////////////////////////////////////////////////
+SFML_GRAPHICS_API Color operator *(const Color& left, const Color& right);
+
+////////////////////////////////////////////////////////////
+/// \relates Color
+/// \brief Overload of the binary += operator
+///
+/// This operator computes the component-wise sum of two colors,
+/// and assigns the result to the left operand.
+/// Components that exceed 255 are clamped to 255.
+///
+/// \param left Left operand
+/// \param right Right operand
+///
+/// \return Reference to \a left
+///
+////////////////////////////////////////////////////////////
+SFML_GRAPHICS_API Color& operator +=(Color& left, const Color& right);
+
+////////////////////////////////////////////////////////////
+/// \relates Color
+/// \brief Overload of the binary *= operator
+///
+/// This operator returns the component-wise multiplication
+/// (also called "modulation") of two colors, and assigns
+/// the result to the left operand.
+/// Components are then divided by 255 so that the result is
+/// still in the range [0, 255].
+///
+/// \param left Left operand
+/// \param right Right operand
+///
+/// \return Reference to \a left
+///
+////////////////////////////////////////////////////////////
+SFML_GRAPHICS_API Color& operator *=(Color& left, const Color& right);
} // namespace sf
#endif // SFML_COLOR_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Color
+/// \ingroup graphics
+///
+/// sf::Color is a simple color class composed of 4 components:
+/// \li Red
+/// \li Green
+/// \li Blue
+/// \li Alpha (opacity)
+///
+/// Each component is a public member, an unsigned integer in
+/// the range [0, 255]. Thus, colors can be constructed and
+/// manipulated very easily:
+///
+/// \code
+/// sf::Color color(255, 0, 0); // red
+/// color.r = 0; // make it black
+/// color.b = 128; // make it dark blue
+/// \endcode
+///
+/// The fourth component of colors, named "alpha", represents
+/// the opacity of the color. A color with an alpha value of
+/// 255 will be fully opaque, while an alpha value of 0 will
+/// make a color fully transparent, whatever the value of the
+/// other components is.
+///
+/// The most common colors are already defined as static variables:
+/// \code
+/// sf::Color black = sf::Color::Black;
+/// sf::Color white = sf::Color::White;
+/// sf::Color red = sf::Color::Red;
+/// sf::Color green = sf::Color::Green;
+/// sf::Color blue = sf::Color::Blue;
+/// sf::Color yellow = sf::Color::Yellow;
+/// sf::Color magenta = sf::Color::Magenta;
+/// sf::Color cyan = sf::Color::Cyan;
+/// sf::Color transparent = sf::Color::Transparent;
+/// \endcode
+///
+/// Colors can also be added and modulated (multiplied) using the
+/// overloaded operators + and *.
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Graphics/ConvexShape.hpp b/include/SFML/Graphics/ConvexShape.hpp new file mode 100644 index 0000000..03af57f --- /dev/null +++ b/include/SFML/Graphics/ConvexShape.hpp @@ -0,0 +1,150 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_CONVEXSHAPE_HPP +#define SFML_CONVEXSHAPE_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.hpp> +#include <SFML/Graphics/Shape.hpp> +#include <vector> + + +namespace sf +{ +//////////////////////////////////////////////////////////// +/// \brief Specialized shape representing a convex polygon +/// +//////////////////////////////////////////////////////////// +class SFML_GRAPHICS_API ConvexShape : public Shape +{ +public : + + //////////////////////////////////////////////////////////// + /// \brief Default constructor + /// + /// \param pointCount Number of points of the polygon + /// + //////////////////////////////////////////////////////////// + explicit ConvexShape(unsigned int pointCount = 0); + + //////////////////////////////////////////////////////////// + /// \brief Set the number of points of the polygon + /// + /// \a count must be greater than 2 to define a valid shape. + /// + /// \param count New number of points of the polygon + /// + /// \see getPointCount + /// + //////////////////////////////////////////////////////////// + void setPointCount(unsigned int count); + + //////////////////////////////////////////////////////////// + /// \brief Get the number of points of the polygon + /// + /// \return Number of points of the polygon + /// + /// \see setPointCount + /// + //////////////////////////////////////////////////////////// + virtual unsigned int getPointCount() const; + + //////////////////////////////////////////////////////////// + /// \brief Set the position of a point + /// + /// Don't forget that the polygon must remain convex, and + /// the points need to stay ordered! + /// setPointCount must be called first in order to set the total + /// number of points. The result is undefined if \a index is out + /// of the valid range. + /// + /// \param index Index of the point to change, in range [0 .. getPointCount() - 1] + /// \param point New position of the point + /// + /// \see getPoint + /// + //////////////////////////////////////////////////////////// + void setPoint(unsigned int index, const Vector2f& point); + + //////////////////////////////////////////////////////////// + /// \brief Get the position of a point + /// + /// The result is undefined if \a index is out of the valid range. + /// + /// \param index Index of the point to get, in range [0 .. getPointCount() - 1] + /// + /// \return Position of the index-th point of the polygon + /// + /// \see setPoint + /// + //////////////////////////////////////////////////////////// + virtual Vector2f getPoint(unsigned int index) const; + +private : + + //////////////////////////////////////////////////////////// + // Member data + //////////////////////////////////////////////////////////// + std::vector<Vector2f> m_points; ///< Points composing the convex polygon +}; + +} // namespace sf + + +#endif // SFML_CONVEXSHAPE_HPP + + +//////////////////////////////////////////////////////////// +/// \class sf::ConvexShape +/// \ingroup graphics +/// +/// This class inherits all the functions of sf::Transformable +/// (position, rotation, scale, bounds, ...) as well as the +/// functions of sf::Shape (outline, color, texture, ...). +/// +/// It is important to keep in mind that a convex shape must +/// always be... convex, otherwise it may not be drawn correctly. +/// Moreover, the points must be defined in order; using a random +/// order would result in an incorrect shape. +/// +/// Usage example: +/// \code +/// sf::ConvexShape polygon; +/// polygon.setPointCount(3); +/// polygon.setPoint(0, sf::Vector2f(0, 0)); +/// polygon.setPoint(1, sf::Vector2f(0, 10)); +/// polygon.setPoint(2, sf::Vector2f(25, 5)); +/// polygon.setOutlineColor(sf::Color::Red); +/// polygon.setOutlineThickness(5); +/// polygon.setPosition(10, 20); +/// ... +/// window.draw(polygon); +/// \endcode +/// +/// \see sf::Shape, sf::RectangleShape, sf::CircleShape +/// +//////////////////////////////////////////////////////////// diff --git a/include/SFML/Graphics/Drawable.hpp b/include/SFML/Graphics/Drawable.hpp index a93ec57..accebfc 100755..100644 --- a/include/SFML/Graphics/Drawable.hpp +++ b/include/SFML/Graphics/Drawable.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,9 +28,8 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/System/Vector2.hpp>
-#include <SFML/Graphics/Color.hpp>
-#include <SFML/Graphics/Matrix3.hpp>
+#include <SFML/Graphics/Export.hpp>
+#include <SFML/Graphics/RenderStates.hpp>
namespace sf
@@ -38,324 +37,90 @@ namespace sf class RenderTarget;
////////////////////////////////////////////////////////////
-/// Enumerate the blending modes for drawable objects
+/// \brief Abstract base class for objects that can be drawn
+/// to a render target
+///
////////////////////////////////////////////////////////////
-namespace Blend
-{
- enum Mode
- {
- Alpha, ///< Pixel = Src * a + Dest * (1 - a)
- Add, ///< Pixel = Src + Dest
- Multiply, ///< Pixel = Src * Dest
- None ///< No blending
- };
-}
-
-////////////////////////////////////////////////////////////
-/// Abstract base class for every object that can be drawn
-/// into a render window
-////////////////////////////////////////////////////////////
-class SFML_API Drawable
+class SFML_GRAPHICS_API Drawable
{
public :
////////////////////////////////////////////////////////////
- /// Default constructor
- ///
- /// \param Position : Position of the object (0, 0 by default)
- /// \param Scale : Scale factor (1, 1 by default)
- /// \param Rotation : Orientation, in degrees (0 by default)
- /// \param Col : Color of the object (white by default)
- ///
- ////////////////////////////////////////////////////////////
- Drawable(const Vector2f& Position = Vector2f(0, 0), const Vector2f& Scale = Vector2f(1, 1), float Rotation = 0.f, const Color& Col = Color(255, 255, 255, 255));
-
- ////////////////////////////////////////////////////////////
- /// Virtual destructor
- ///
- ////////////////////////////////////////////////////////////
- virtual ~Drawable();
-
- ////////////////////////////////////////////////////////////
- /// Set the position of the object (take 2 values)
- ///
- /// \param X : New X coordinate
- /// \param Y : New Y coordinate
- ///
- ////////////////////////////////////////////////////////////
- void SetPosition(float X, float Y);
-
- ////////////////////////////////////////////////////////////
- /// Set the position of the object (take a 2D vector)
- ///
- /// \param Position : New position
- ///
- ////////////////////////////////////////////////////////////
- void SetPosition(const Vector2f& Position);
-
- ////////////////////////////////////////////////////////////
- /// Set the X position of the object
- ///
- /// \param X : New X coordinate
- ///
- ////////////////////////////////////////////////////////////
- void SetX(float X);
-
- ////////////////////////////////////////////////////////////
- /// Set the Y position of the object
- ///
- /// \param Y : New Y coordinate
- ///
- ////////////////////////////////////////////////////////////
- void SetY(float Y);
-
- ////////////////////////////////////////////////////////////
- /// Set the scale of the object (take 2 values)
- ///
- /// \param ScaleX : New horizontal scale (must be strictly positive)
- /// \param ScaleY : New vertical scale (must be strictly positive)
- ///
- ////////////////////////////////////////////////////////////
- void SetScale(float ScaleX, float ScaleY);
-
- ////////////////////////////////////////////////////////////
- /// Set the scale of the object (take a 2D vector)
- ///
- /// \param Scale : New scale (both values must be strictly positive)
- ///
- ////////////////////////////////////////////////////////////
- void SetScale(const Vector2f& Scale);
-
- ////////////////////////////////////////////////////////////
- /// Set the X scale factor of the object
- ///
- /// \param X : New X scale factor
+ /// \brief Virtual destructor
///
////////////////////////////////////////////////////////////
- void SetScaleX(float FactorX);
-
- ////////////////////////////////////////////////////////////
- /// Set the Y scale factor of the object
- ///
- /// \param Y : New Y scale factor
- ///
- ////////////////////////////////////////////////////////////
- void SetScaleY(float FactorY);
-
- ////////////////////////////////////////////////////////////
- /// Set the center of the object, in coordinates relative to the
- /// top-left of the object (take 2 values).
- /// The default center is (0, 0)
- ///
- /// \param CenterX : X coordinate of the center
- /// \param CenterY : Y coordinate of the center
- ///
- ////////////////////////////////////////////////////////////
- void SetCenter(float CenterX, float CenterY);
-
- ////////////////////////////////////////////////////////////
- /// Set the center of the object, in coordinates relative to the
- /// top-left of the object (take a 2D vector).
- /// The default center is (0, 0)
- ///
- /// \param Center : New center
- ///
- ////////////////////////////////////////////////////////////
- void SetCenter(const Vector2f& Center);
-
- ////////////////////////////////////////////////////////////
- /// Set the orientation of the object
- ///
- /// \param Rotation : Angle of rotation, in degrees
- ///
- ////////////////////////////////////////////////////////////
- void SetRotation(float Rotation);
-
- ////////////////////////////////////////////////////////////
- /// Set the color of the object.
- /// The default color is white
- ///
- /// \param Col : New color
- ///
- ////////////////////////////////////////////////////////////
- void SetColor(const Color& Col);
-
- ////////////////////////////////////////////////////////////
- /// Set the blending mode for the object.
- /// The default blend mode is Blend::Alpha
- ///
- /// \param Mode : New blending mode
- ///
- ////////////////////////////////////////////////////////////
- void SetBlendMode(Blend::Mode Mode);
-
- ////////////////////////////////////////////////////////////
- /// Get the position of the object
- ///
- /// \return Current position
- ///
- ////////////////////////////////////////////////////////////
- const Vector2f& GetPosition() const;
-
- ////////////////////////////////////////////////////////////
- /// Get the current scale of the object
- ///
- /// \return Current scale factor (always positive)
- ///
- ////////////////////////////////////////////////////////////
- const Vector2f& GetScale() const;
-
- ////////////////////////////////////////////////////////////
- /// Get the center of the object
- ///
- /// \return Current position of the center
- ///
- ////////////////////////////////////////////////////////////
- const Vector2f& GetCenter() const;
-
- ////////////////////////////////////////////////////////////
- /// Get the orientation of the object.
- /// Rotation is always in the range [0, 360]
- ///
- /// \return Current rotation, in degrees
- ///
- ////////////////////////////////////////////////////////////
- float GetRotation() const;
-
- ////////////////////////////////////////////////////////////
- /// Get the color of the object
- ///
- /// \return Current color
- ///
- ////////////////////////////////////////////////////////////
- const Color& GetColor() const;
-
- ////////////////////////////////////////////////////////////
- /// Get the current blending mode
- ///
- /// \return Current blending mode
- ///
- ////////////////////////////////////////////////////////////
- Blend::Mode GetBlendMode() const;
-
- ////////////////////////////////////////////////////////////
- /// Move the object of a given offset (take 2 values)
- ///
- /// \param OffsetX : X offset
- /// \param OffsetY : Y offset
- ///
- ////////////////////////////////////////////////////////////
- void Move(float OffsetX, float OffsetY);
-
- ////////////////////////////////////////////////////////////
- /// Move the object of a given offset (take a 2D vector)
- ///
- /// \param Offset : Amount of units to move the object of
- ///
- ////////////////////////////////////////////////////////////
- void Move(const Vector2f& Offset);
-
- ////////////////////////////////////////////////////////////
- /// Scale the object (take 2 values)
- ///
- /// \param FactorX : Scaling factor on X (must be strictly positive)
- /// \param FactorY : Scaling factor on Y (must be strictly positive)
- ///
- ////////////////////////////////////////////////////////////
- void Scale(float FactorX, float FactorY);
-
- ////////////////////////////////////////////////////////////
- /// Scale the object (take a 2D vector)
- ///
- /// \param Factor : Scaling factors (both values must be strictly positive)
- ///
- ////////////////////////////////////////////////////////////
- void Scale(const Vector2f& Factor);
-
- ////////////////////////////////////////////////////////////
- /// Rotate the object
- ///
- /// \param Angle : Angle of rotation, in degrees
- ///
- ////////////////////////////////////////////////////////////
- void Rotate(float Angle);
-
- ////////////////////////////////////////////////////////////
- /// Transform a point from global coordinates into local coordinates
- /// (ie it applies the inverse of object's center, translation, rotation and scale to the point)
- ///
- /// \param Point : Point to transform
- ///
- /// \return Transformed point
- ///
- ////////////////////////////////////////////////////////////
- sf::Vector2f TransformToLocal(const sf::Vector2f& Point) const;
-
- ////////////////////////////////////////////////////////////
- /// Transform a point from local coordinates into global coordinates
- /// (ie it applies the object's center, translation, rotation and scale to the point)
- ///
- /// \param Point : Point to transform
- ///
- /// \return Transformed point
- ///
- ////////////////////////////////////////////////////////////
- sf::Vector2f TransformToGlobal(const sf::Vector2f& Point) const;
+ virtual ~Drawable() {}
protected :
- ////////////////////////////////////////////////////////////
- /// Get the transform matrix of the drawable
- ///
- /// \return Transform matrix
- ///
- ////////////////////////////////////////////////////////////
- const Matrix3& GetMatrix() const;
-
- ////////////////////////////////////////////////////////////
- /// Get the inverse transform matrix of the drawable
- ///
- /// \return Inverse transform matrix
- ///
- ////////////////////////////////////////////////////////////
- const Matrix3& GetInverseMatrix() const;
-
-private :
-
friend class RenderTarget;
////////////////////////////////////////////////////////////
- /// Draw the object into the specified window
- ///
- /// \param Target : Target into which render the object
+ /// \brief Draw the object to a render target
///
- ////////////////////////////////////////////////////////////
- void Draw(RenderTarget& Target) const;
-
- ////////////////////////////////////////////////////////////
- /// Render the specific geometry of the object
+ /// This is a pure virtual function that has to be implemented
+ /// by the derived class to define how the drawable should be
+ /// drawn.
///
- /// \param Target : Target into which render the object
+ /// \param target Render target to draw to
+ /// \param states Current render states
///
////////////////////////////////////////////////////////////
- virtual void Render(RenderTarget& Target) const = 0;
-
- ////////////////////////////////////////////////////////////
- // Member data
- ////////////////////////////////////////////////////////////
- Vector2f myPosition; ///< Position of the object on screen
- Vector2f myScale; ///< Scale of the object
- Vector2f myCenter; ///< Origin of translation / rotation / scaling of the object
- float myRotation; ///< Orientation of the object, in degrees
- Color myColor; ///< Overlay color of the object
- Blend::Mode myBlendMode; ///< Blending mode
- mutable bool myNeedUpdate; ///< Do we need to recompute the transform matrix ?
- mutable bool myInvNeedUpdate; ///< Do we need to recompute the inverse transform matrix ?
- mutable Matrix3 myMatrix; ///< Precomputed transform matrix gathering the translation / rotation / scale / center
- mutable Matrix3 myInvMatrix; ///< Precomputed inverse transform matrix gathering the translation / rotation / scale / center
+ virtual void draw(RenderTarget& target, RenderStates states) const = 0;
};
} // namespace sf
#endif // SFML_DRAWABLE_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Drawable
+/// \ingroup graphics
+///
+/// sf::Drawable is a very simple base class that allows objects
+/// of derived classes to be drawn to a sf::RenderTarget.
+///
+/// All you have to do in your derived class is to override the
+/// draw virtual function.
+///
+/// Note that inheriting from sf::Drawable is not mandatory,
+/// but it allows this nice syntax "window.draw(object)" rather
+/// than "object.draw(window)", which is more consistent with other
+/// SFML classes.
+///
+/// Example:
+/// \code
+/// class MyDrawable : public sf::Drawable
+/// {
+/// public :
+///
+/// ...
+///
+/// private :
+///
+/// virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const
+/// {
+/// // You can draw other high-level objects
+/// target.draw(m_sprite, states);
+///
+/// // ... or use the low-level API
+/// states.texture = &m_texture;
+/// target.draw(m_vertices, states);
+///
+/// // ... or draw with OpenGL directly
+/// glBegin(GL_QUADS);
+/// ...
+/// glEnd();
+/// }
+///
+/// sf::Sprite m_sprite;
+/// sf::Texture m_texture;
+/// sf::VertexArray m_vertices;
+/// };
+/// \endcode
+///
+/// \see sf::RenderTarget
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Network/SocketHelper.hpp b/include/SFML/Graphics/Export.hpp index 166ce60..eb76ae8 100755..100644 --- a/include/SFML/Network/SocketHelper.hpp +++ b/include/SFML/Graphics/Export.hpp @@ -1,64 +1,48 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_SOCKETHELPER_HPP
-#define SFML_SOCKETHELPER_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
-
-
-namespace sf
-{
-namespace Socket
-{
- ////////////////////////////////////////////////////////////
- /// Enumeration of status returned by socket functions
- ////////////////////////////////////////////////////////////
- enum Status
- {
- Done, ///< The socket has sent / received the data
- NotReady, ///< The socket is not ready to send / receive data yet
- Disconnected, ///< The TCP socket has been disconnected
- Error ///< An unexpected error happened
- };
-}
-
-} // namespace sf
-
-
-#ifdef SFML_SYSTEM_WINDOWS
-
- #include <SFML/Network/Win32/SocketHelper.hpp>
-
-#else
-
- #include <SFML/Network/Unix/SocketHelper.hpp>
-
-#endif
-
-
-#endif // SFML_SOCKETHELPER_HPP
+//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_GRAPHICS_EXPORT_HPP +#define SFML_GRAPHICS_EXPORT_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Config.hpp> + + +//////////////////////////////////////////////////////////// +// Define portable import / export macros +//////////////////////////////////////////////////////////// +#if defined(SFML_GRAPHICS_EXPORTS) + + #define SFML_GRAPHICS_API SFML_API_EXPORT + +#else + + #define SFML_GRAPHICS_API SFML_API_IMPORT + +#endif + + +#endif // SFML_GRAPHICS_EXPORT_HPP diff --git a/include/SFML/Graphics/Font.hpp b/include/SFML/Graphics/Font.hpp index 866b974..d3b1955 100755..100644 --- a/include/SFML/Graphics/Font.hpp +++ b/include/SFML/Graphics/Font.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,118 +28,334 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/System/Resource.hpp>
-#include <SFML/System/Vector2.hpp>
-#include <SFML/System/Unicode.hpp>
+#include <SFML/Graphics/Export.hpp>
#include <SFML/Graphics/Glyph.hpp>
-#include <SFML/Graphics/Image.hpp>
+#include <SFML/Graphics/Texture.hpp>
#include <SFML/Graphics/Rect.hpp>
+#include <SFML/System/Vector2.hpp>
+#include <SFML/System/String.hpp>
#include <map>
#include <string>
+#include <vector>
namespace sf
{
-class String;
+class InputStream;
-namespace priv
-{
-class FontLoader;
-}
////////////////////////////////////////////////////////////
-/// Font is the low-level class for loading and
-/// manipulating character fonts. This class is meant to
-/// be used by sf::String
+/// \brief Class for loading and manipulating character fonts
+///
////////////////////////////////////////////////////////////
-class SFML_API Font : public Resource<Font>
+class SFML_GRAPHICS_API Font
{
public :
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
+ ///
+ /// This constructor defines an empty font
///
////////////////////////////////////////////////////////////
Font();
////////////////////////////////////////////////////////////
- /// Load the font from a file
+ /// \brief Copy constructor
+ ///
+ /// \param copy Instance to copy
+ ///
+ ////////////////////////////////////////////////////////////
+ Font(const Font& copy);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Destructor
+ ///
+ /// Cleans up all the internal resources used by the font
+ ///
+ ////////////////////////////////////////////////////////////
+ ~Font();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Load the font from a file
+ ///
+ /// The supported font formats are: TrueType, Type 1, CFF,
+ /// OpenType, SFNT, X11 PCF, Windows FNT, BDF, PFR and Type 42.
+ /// Note that this function know nothing about the standard
+ /// fonts installed on the user's system, thus you can't
+ /// load them directly.
+ ///
+ /// \param filename Path of the font file to load
+ ///
+ /// \return True if loading succeeded, false if it failed
+ ///
+ /// \see loadFromMemory, loadFromStream
+ ///
+ ////////////////////////////////////////////////////////////
+ bool loadFromFile(const std::string& filename);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Load the font from a file in memory
+ ///
+ /// The supported font formats are: TrueType, Type 1, CFF,
+ /// OpenType, SFNT, X11 PCF, Windows FNT, BDF, PFR and Type 42.
+ /// Warning: SFML cannot preload all the font data in this
+ /// function, so the buffer pointed by \a data has to remain
+ /// valid as long as the font is used.
+ ///
+ /// \param data Pointer to the file data in memory
+ /// \param sizeInBytes Size of the data to load, in bytes
///
- /// \param Filename : Font file to load
- /// \param CharSize : Size of characters in bitmap - the bigger, the higher quality (30 by default)
- /// \param Charset : Characters set to generate (by default, contains the ISO-8859-1 printable characters)
+ /// \return True if loading succeeded, false if it failed
///
- /// \return True if loading was successful
+ /// \see loadFromFile, loadFromStream
///
////////////////////////////////////////////////////////////
- bool LoadFromFile(const std::string& Filename, unsigned int CharSize = 30, const Unicode::Text& Charset = ourDefaultCharset);
+ bool loadFromMemory(const void* data, std::size_t sizeInBytes);
////////////////////////////////////////////////////////////
- /// Load the font from a file in memory
+ /// \brief Load the font from a custom stream
///
- /// \param Data : Pointer to the data to load
- /// \param SizeInBytes : Size of the data, in bytes
- /// \param CharSize : Size of characters in bitmap - the bigger, the higher quality (30 by default)
- /// \param Charset : Characters set to generate (by default, contains the ISO-8859-1 printable characters)
+ /// The supported font formats are: TrueType, Type 1, CFF,
+ /// OpenType, SFNT, X11 PCF, Windows FNT, BDF, PFR and Type 42.
+ /// Warning: SFML cannot preload all the font data in this
+ /// function, so the contents of \a stream have to remain
+ /// valid as long as the font is used.
///
- /// \return True if loading was successful
+ /// \param stream Source stream to read from
+ ///
+ /// \return True if loading succeeded, false if it failed
+ ///
+ /// \see loadFromFile, loadFromMemory
///
////////////////////////////////////////////////////////////
- bool LoadFromMemory(const char* Data, std::size_t SizeInBytes, unsigned int CharSize = 30, const Unicode::Text& Charset = ourDefaultCharset);
+ bool loadFromStream(InputStream& stream);
////////////////////////////////////////////////////////////
- /// Get the base size of characters in the font;
- /// All glyphs dimensions are based on this value
+ /// \brief Retrieve a glyph of the font
+ ///
+ /// \param codePoint Unicode code point of the character to get
+ /// \param characterSize Reference character size
+ /// \param bold Retrieve the bold version or the regular one?
///
- /// \return Base size of characters
+ /// \return The glyph corresponding to \a codePoint and \a characterSize
///
////////////////////////////////////////////////////////////
- unsigned int GetCharacterSize() const;
+ const Glyph& getGlyph(Uint32 codePoint, unsigned int characterSize, bool bold) const;
////////////////////////////////////////////////////////////
- /// Get the description of a glyph (character)
- /// given by its unicode value
+ /// \brief Get the kerning offset of two glyphs
///
- /// \param CodePoint : Unicode value of the character to get
+ /// The kerning is an extra offset (negative) to apply between two
+ /// glyphs when rendering them, to make the pair look more "natural".
+ /// For example, the pair "AV" have a special kerning to make them
+ /// closer than other characters. Most of the glyphs pairs have a
+ /// kerning offset of zero, though.
///
- /// \return Glyph's visual settings, or an invalid glyph if character not found
+ /// \param first Unicode code point of the first character
+ /// \param second Unicode code point of the second character
+ /// \param characterSize Reference character size
+ ///
+ /// \return Kerning value for \a first and \a second, in pixels
///
////////////////////////////////////////////////////////////
- const Glyph& GetGlyph(Uint32 CodePoint) const;
+ int getKerning(Uint32 first, Uint32 second, unsigned int characterSize) const;
////////////////////////////////////////////////////////////
- /// Get the image containing the rendered characters (glyphs)
+ /// \brief Get the line spacing
+ ///
+ /// Line spacing is the vertical offset to apply between two
+ /// consecutive lines of text.
///
- /// \return Image containing glyphs
+ /// \param characterSize Reference character size
+ ///
+ /// \return Line spacing, in pixels
///
////////////////////////////////////////////////////////////
- const Image& GetImage() const;
+ int getLineSpacing(unsigned int characterSize) const;
////////////////////////////////////////////////////////////
- /// Get the SFML default built-in font (Arial)
+ /// \brief Retrieve the texture containing the loaded glyphs of a certain size
+ ///
+ /// The contents of the returned texture changes as more glyphs
+ /// are requested, thus it is not very relevant. It is mainly
+ /// used internally by sf::Text.
+ ///
+ /// \param characterSize Reference character size
+ ///
+ /// \return Texture containing the glyphs of the requested size
+ ///
+ ////////////////////////////////////////////////////////////
+ const Texture& getTexture(unsigned int characterSize) const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Overload of assignment operator
+ ///
+ /// \param right Instance to assign
///
- /// \return Instance of the default font
+ /// \return Reference to self
///
////////////////////////////////////////////////////////////
- static const Font& GetDefaultFont();
+ Font& operator =(const Font& right);
private :
- friend class priv::FontLoader;
+ ////////////////////////////////////////////////////////////
+ /// \brief Structure defining a row of glyphs
+ ///
+ ////////////////////////////////////////////////////////////
+ struct Row
+ {
+ Row(unsigned int rowTop, unsigned int rowHeight) : width(0), top(rowTop), height(rowHeight) {}
+
+ unsigned int width; ///< Current width of the row
+ unsigned int top; ///< Y position of the row into the texture
+ unsigned int height; ///< Height of the row
+ };
+
+ ////////////////////////////////////////////////////////////
+ // Types
+ ////////////////////////////////////////////////////////////
+ typedef std::map<Uint32, Glyph> GlyphTable; ///< Table mapping a codepoint to its glyph
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Structure defining a page of glyphs
+ ///
+ ////////////////////////////////////////////////////////////
+ struct Page
+ {
+ Page();
+
+ GlyphTable glyphs; ///< Table mapping code points to their corresponding glyph
+ sf::Texture texture; ///< Texture containing the pixels of the glyphs
+ unsigned int nextRow; ///< Y position of the next new row in the texture
+ std::vector<Row> rows; ///< List containing the position of all the existing rows
+ };
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Free all the internal resources
+ ///
+ ////////////////////////////////////////////////////////////
+ void cleanup();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Load a new glyph and store it in the cache
+ ///
+ /// \param codePoint Unicode code point of the character to load
+ /// \param characterSize Reference character size
+ /// \param bold Retrieve the bold version or the regular one?
+ ///
+ /// \return The glyph corresponding to \a codePoint and \a characterSize
+ ///
+ ////////////////////////////////////////////////////////////
+ Glyph loadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold) const;
////////////////////////////////////////////////////////////
- // Static member data
+ /// \brief Find a suitable rectangle within the texture for a glyph
+ ///
+ /// \param page Page of glyphs to search in
+ /// \param width Width of the rectangle
+ /// \param height Height of the rectangle
+ ///
+ /// \return Found rectangle within the texture
+ ///
////////////////////////////////////////////////////////////
- static Uint32 ourDefaultCharset[]; ///< The default charset (all printable ISO-8859-1 characters)
+ IntRect findGlyphRect(Page& page, unsigned int width, unsigned int height) const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Make sure that the given size is the current one
+ ///
+ /// \param characterSize Reference character size
+ ///
+ /// \return True on success, false if any error happened
+ ///
+ ////////////////////////////////////////////////////////////
+ bool setCurrentSize(unsigned int characterSize) const;
+
+ ////////////////////////////////////////////////////////////
+ // Types
+ ////////////////////////////////////////////////////////////
+ typedef std::map<unsigned int, Page> PageTable; ///< Table mapping a character size to its page (texture)
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- Image myTexture; ///< Texture holding the bitmap font
- unsigned int myCharSize; ///< Size of characters in the bitmap font
- std::map<Uint32, Glyph> myGlyphs; ///< Rendering settings of each character (glyph)
+ void* m_library; ///< Pointer to the internal library interface (it is typeless to avoid exposing implementation details)
+ void* m_face; ///< Pointer to the internal font face (it is typeless to avoid exposing implementation details)
+ void* m_streamRec; ///< Pointer to the stream rec instance (it is typeless to avoid exposing implementation details)
+ int* m_refCount; ///< Reference counter used by implicit sharing
+ mutable PageTable m_pages; ///< Table containing the glyphs pages by character size
+ mutable std::vector<Uint8> m_pixelBuffer; ///< Pixel buffer holding a glyph's pixels before being written to the texture
};
} // namespace sf
#endif // SFML_FONT_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Font
+/// \ingroup graphics
+///
+/// Fonts can be loaded from a file, from memory or from a custom
+/// stream, and supports the most common types of fonts. See
+/// the loadFromFile function for the complete list of supported formats.
+///
+/// Once it is loaded, a sf::Font instance provides three
+/// types of information about the font:
+/// \li Global metrics, such as the line spacing
+/// \li Per-glyph metrics, such as bounding box or kerning
+/// \li Pixel representation of glyphs
+///
+/// Fonts alone are not very useful: they hold the font data
+/// but cannot make anything useful of it. To do so you need to
+/// use the sf::Text class, which is able to properly output text
+/// with several options such as character size, style, color,
+/// position, rotation, etc.
+/// This separation allows more flexibility and better performances:
+/// indeed a sf::Font is a heavy resource, and any operation on it
+/// is slow (often too slow for real-time applications). On the other
+/// side, a sf::Text is a lightweight object which can combine the
+/// glyphs data and metrics of a sf::Font to display any text on a
+/// render target.
+/// Note that it is also possible to bind several sf::Text instances
+/// to the same sf::Font.
+///
+/// It is important to note that the sf::Text instance doesn't
+/// copy the font that it uses, it only keeps a reference to it.
+/// Thus, a sf::Font must not be destructed while it is
+/// used by a sf::Text (i.e. never write a function that
+/// uses a local sf::Font instance for creating a text).
+///
+/// Usage example:
+/// \code
+/// // Declare a new font
+/// sf::Font font;
+///
+/// // Load it from a file
+/// if (!font.loadFromFile("arial.ttf"))
+/// {
+/// // error...
+/// }
+///
+/// // Create a text which uses our font
+/// sf::Text text1;
+/// text1.setFont(font);
+/// text1.setCharacterSize(30);
+/// text1.setStyle(sf::Text::Regular);
+///
+/// // Create another text using the same font, but with different parameters
+/// sf::Text text2;
+/// text2.setFont(font);
+/// text2.setCharacterSize(50);
+/// text1.setStyle(sf::Text::Italic);
+/// \endcode
+///
+/// Apart from loading font files, and passing them to instances
+/// of sf::Text, you should normally not have to deal directly
+/// with this class. However, it may be useful to access the
+/// font metrics or rasterized glyphs for advanced usage.
+///
+/// \see sf::Text
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Graphics/Glyph.hpp b/include/SFML/Graphics/Glyph.hpp index ec1b886..d97616f 100755..100644 --- a/include/SFML/Graphics/Glyph.hpp +++ b/include/SFML/Graphics/Glyph.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,34 +28,52 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
+#include <SFML/Graphics/Export.hpp>
#include <SFML/Graphics/Rect.hpp>
namespace sf
{
////////////////////////////////////////////////////////////
-/// Structure describing a glyph (a visual character)
+/// \brief Structure describing a glyph
+///
////////////////////////////////////////////////////////////
-class SFML_API Glyph
+class SFML_GRAPHICS_API Glyph
{
public :
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
///
////////////////////////////////////////////////////////////
- Glyph() : Advance(0) {}
+ Glyph() : advance(0) {}
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- int Advance; ///< Offset to move horizontically to the next character
- IntRect Rectangle; ///< Bounding rectangle of the glyph, in relative coordinates
- FloatRect TexCoords; ///< Texture coordinates of the glyph inside the bitmap font
+ int advance; ///< Offset to move horizontically to the next character
+ IntRect bounds; ///< Bounding rectangle of the glyph, in coordinates relative to the baseline
+ IntRect textureRect; ///< Texture coordinates of the glyph inside the font's texture
};
} // namespace sf
#endif // SFML_GLYPH_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Glyph
+/// \ingroup graphics
+///
+/// A glyph is the visual representation of a character.
+///
+/// The sf::Glyph structure provides the information needed
+/// to handle the glyph:
+/// \li its coordinates in the font's texture
+/// \li its bounding rectangle
+/// \li the offset to apply to get the starting position of the next glyph
+///
+/// \see sf::Font
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Graphics/Image.hpp b/include/SFML/Graphics/Image.hpp index c2f5c89..0b61d6c 100755..100644 --- a/include/SFML/Graphics/Image.hpp +++ b/include/SFML/Graphics/Image.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,7 +28,7 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/System/Resource.hpp>
+#include <SFML/Graphics/Export.hpp>
#include <SFML/Graphics/Color.hpp>
#include <SFML/Graphics/Rect.hpp>
#include <string>
@@ -37,296 +37,282 @@ namespace sf
{
-class RenderWindow;
+class InputStream;
////////////////////////////////////////////////////////////
-/// Image is the low-level class for loading and
-/// manipulating images
+/// \brief Class for loading, manipulating and saving images
+///
////////////////////////////////////////////////////////////
-class SFML_API Image : public Resource<Image>
+class SFML_GRAPHICS_API Image
{
public :
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
+ ///
+ /// Creates an empty image.
///
////////////////////////////////////////////////////////////
Image();
////////////////////////////////////////////////////////////
- /// Copy constructor
+ /// \brief Create the image and fill it with a unique color
///
- /// \param Copy : instance to copy
+ /// \param width Width of the image
+ /// \param height Height of the image
+ /// \param color Fill color
///
////////////////////////////////////////////////////////////
- Image(const Image& Copy);
+ void create(unsigned int width, unsigned int height, const Color& color = Color(0, 0, 0));
////////////////////////////////////////////////////////////
- /// Construct an empty image
- ///
- /// \param Width : Image width
- /// \param Height : Image height
- /// \param Col : Image color (black by default)
+ /// \brief Create the image from an array of pixels
///
- ////////////////////////////////////////////////////////////
- Image(unsigned int Width, unsigned int Height, const Color& Col = Color(0, 0, 0, 255));
-
- ////////////////////////////////////////////////////////////
- /// Construct the image from pixels in memory
+ /// The \a pixel array is assumed to contain 32-bits RGBA pixels,
+ /// and have the given \a width and \a height. If not, this is
+ /// an undefined behaviour.
+ /// If \a pixels is null, an empty image is created.
///
- /// \param Width : Image width
- /// \param Height : Image height
- /// \param Data : Pointer to the pixels in memory (assumed format is RGBA)
+ /// \param width Width of the image
+ /// \param height Height of the image
+ /// \param pixels Array of pixels to copy to the image
///
////////////////////////////////////////////////////////////
- Image(unsigned int Width, unsigned int Height, const Uint8* Data);
+ void create(unsigned int width, unsigned int height, const Uint8* pixels);
////////////////////////////////////////////////////////////
- /// Destructor
+ /// \brief Load the image from a file on disk
///
- ////////////////////////////////////////////////////////////
- ~Image();
-
- ////////////////////////////////////////////////////////////
- /// Load the image from a file
+ /// The supported image formats are bmp, png, tga, jpg, gif,
+ /// psd, hdr and pic. Some format options are not supported,
+ /// like progressive jpeg.
+ /// If this function fails, the image is left unchanged.
///
- /// \param Filename : Path of the image file to load
+ /// \param filename Path of the image file to load
///
/// \return True if loading was successful
///
- ////////////////////////////////////////////////////////////
- bool LoadFromFile(const std::string& Filename);
-
- ////////////////////////////////////////////////////////////
- /// Load the image from a file in memory
- ///
- /// \param Data : Pointer to the file data in memory
- /// \param SizeInBytes : Size of the data to load, in bytes
- ///
- /// \return True if loading was successful
+ /// \see loadFromMemory, loadFromStream, saveToFile
///
////////////////////////////////////////////////////////////
- bool LoadFromMemory(const char* Data, std::size_t SizeInBytes);
+ bool loadFromFile(const std::string& filename);
////////////////////////////////////////////////////////////
- /// Load the image directly from an array of pixels
+ /// \brief Load the image from a file in memory
///
- /// \param Width : Image width
- /// \param Height : Image height
- /// \param Data : Pointer to the pixels in memory (assumed format is RGBA)
+ /// The supported image formats are bmp, png, tga, jpg, gif,
+ /// psd, hdr and pic. Some format options are not supported,
+ /// like progressive jpeg.
+ /// If this function fails, the image is left unchanged.
///
- /// \return True if loading was successful
+ /// \param data Pointer to the file data in memory
+ /// \param size Size of the data to load, in bytes
///
- ////////////////////////////////////////////////////////////
- bool LoadFromPixels(unsigned int Width, unsigned int Height, const Uint8* Data);
-
- ////////////////////////////////////////////////////////////
- /// Save the content of the image to a file
- ///
- /// \param Filename : Path of the file to save (overwritten if already exist)
+ /// \return True if loading was successful
///
- /// \return True if saving was successful
+ /// \see loadFromFile, loadFromStream
///
////////////////////////////////////////////////////////////
- bool SaveToFile(const std::string& Filename) const;
+ bool loadFromMemory(const void* data, std::size_t size);
////////////////////////////////////////////////////////////
- /// Create an empty image
+ /// \brief Load the image from a custom stream
///
- /// \param Width : Image width
- /// \param Height : Image height
- /// \param Col : Image color (black by default)
- ///
- /// \return True if creation was successful
- ///
- ////////////////////////////////////////////////////////////
- bool Create(unsigned int Width, unsigned int Height, Color Col = Color(0, 0, 0, 255));
-
- ////////////////////////////////////////////////////////////
- /// Create transparency mask from a specified colorkey
+ /// The supported image formats are bmp, png, tga, jpg, gif,
+ /// psd, hdr and pic. Some format options are not supported,
+ /// like progressive jpeg.
+ /// If this function fails, the image is left unchanged.
///
- /// \param ColorKey : Color to become transparent
- /// \param Alpha : Alpha value to use for transparent pixels (0 by default)
+ /// \param stream Source stream to read from
///
- ////////////////////////////////////////////////////////////
- void CreateMaskFromColor(Color ColorKey, Uint8 Alpha = 0);
-
- ////////////////////////////////////////////////////////////
- /// Copy pixels from another image onto this one.
- /// This function does a slow pixel copy and should only
- /// be used at initialization time
+ /// \return True if loading was successful
///
- /// \param Source : Source image to copy
- /// \param DestX : X coordinate of the destination position
- /// \param DestY : Y coordinate of the destination position
- /// \param SourceRect : Sub-rectangle of the source image to copy (empty by default - entire image)
- /// \param ApplyAlpha : Should the copy take in account the source transparency? (false by default)
+ /// \see loadFromFile, loadFromMemory
///
////////////////////////////////////////////////////////////
- void Copy(const Image& Source, unsigned int DestX, unsigned int DestY, const IntRect& SourceRect = IntRect(0, 0, 0, 0), bool ApplyAlpha = false);
+ bool loadFromStream(InputStream& stream);
////////////////////////////////////////////////////////////
- /// Create the image from the current contents of the
- /// given window
+ /// \brief Save the image to a file on disk
///
- /// \param Window : Window to capture
- /// \param SourceRect : Sub-rectangle of the screen to copy (empty by default - entire image)
+ /// The format of the image is automatically deduced from
+ /// the extension. The supported image formats are bmp, png,
+ /// tga and jpg. The destination file is overwritten
+ /// if it already exists. This function fails if the image is empty.
///
- /// \return True if copy was successful
+ /// \param filename Path of the file to save
///
- ////////////////////////////////////////////////////////////
- bool CopyScreen(RenderWindow& Window, const IntRect& SourceRect = IntRect(0, 0, 0, 0));
-
- ////////////////////////////////////////////////////////////
- /// Change the color of a pixel
+ /// \return True if saving was successful
///
- /// \param X : X coordinate of pixel in the image
- /// \param Y : Y coordinate of pixel in the image
- /// \param Col : New color for pixel (X, Y)
+ /// \see create, loadFromFile, loadFromMemory
///
////////////////////////////////////////////////////////////
- void SetPixel(unsigned int X, unsigned int Y, const Color& Col);
+ bool saveToFile(const std::string& filename) const;
////////////////////////////////////////////////////////////
- /// Get a pixel from the image
- ///
- /// \param X : X coordinate of pixel in the image
- /// \param Y : Y coordinate of pixel in the image
+ /// \brief Return the size (width and height) of the image
///
- /// \return Color of pixel (X, Y)
+ /// \return Size of the image, in pixels
///
////////////////////////////////////////////////////////////
- const Color& GetPixel(unsigned int X, unsigned int Y) const;
+ Vector2u getSize() const;
////////////////////////////////////////////////////////////
- /// Get a read-only pointer to the array of pixels (RGBA 8 bits integers components)
- /// Array size is GetWidth() x GetHeight() x 4
- /// This pointer becomes invalid if you reload or resize the image
+ /// \brief Create a transparency mask from a specified color-key
///
- /// \return Const pointer to the array of pixels
+ /// This function sets the alpha value of every pixel matching
+ /// the given color to \a alpha (0 by default), so that they
+ /// become transparent.
///
- ////////////////////////////////////////////////////////////
- const Uint8* GetPixelsPtr() const;
-
- ////////////////////////////////////////////////////////////
- /// Bind the image for rendering
+ /// \param color Color to make transparent
+ /// \param alpha Alpha value to assign to transparent pixels
///
////////////////////////////////////////////////////////////
- void Bind() const;
+ void createMaskFromColor(const Color& color, Uint8 alpha = 0);
////////////////////////////////////////////////////////////
- /// Enable or disable image smooth filter.
- /// This parameter is enabled by default
+ /// \brief Copy pixels from another image onto this one
///
- /// \param Smooth : True to enable smoothing filter, false to disable it
+ /// This function does a slow pixel copy and should not be
+ /// used intensively. It can be used to prepare a complex
+ /// static image from several others, but if you need this
+ /// kind of feature in real-time you'd better use sf::RenderTexture.
///
- ////////////////////////////////////////////////////////////
- void SetSmooth(bool Smooth);
-
- ////////////////////////////////////////////////////////////
- /// Return the width of the image
+ /// If \a sourceRect is empty, the whole image is copied.
+ /// If \a applyAlpha is set to true, the transparency of
+ /// source pixels is applied. If it is false, the pixels are
+ /// copied unchanged with their alpha value.
///
- /// \return Width in pixels
+ /// \param source Source image to copy
+ /// \param destX X coordinate of the destination position
+ /// \param destY Y coordinate of the destination position
+ /// \param sourceRect Sub-rectangle of the source image to copy
+ /// \param applyAlpha Should the copy take in account the source transparency?
///
////////////////////////////////////////////////////////////
- unsigned int GetWidth() const;
+ void copy(const Image& source, unsigned int destX, unsigned int destY, const IntRect& sourceRect = IntRect(0, 0, 0, 0), bool applyAlpha = false);
////////////////////////////////////////////////////////////
- /// Return the height of the image
+ /// \brief Change the color of a pixel
///
- /// \return Height in pixels
+ /// This function doesn't check the validity of the pixel
+ /// coordinates, using out-of-range values will result in
+ /// an undefined behaviour.
///
- ////////////////////////////////////////////////////////////
- unsigned int GetHeight() const;
-
- ////////////////////////////////////////////////////////////
- /// Tells whether the smooth filtering is enabled or not
+ /// \param x X coordinate of pixel to change
+ /// \param y Y coordinate of pixel to change
+ /// \param color New color of the pixel
///
- /// \return True if image smoothing is enabled
+ /// \see getPixel
///
////////////////////////////////////////////////////////////
- bool IsSmooth() const;
+ void setPixel(unsigned int x, unsigned int y, const Color& color);
////////////////////////////////////////////////////////////
- /// Convert a subrect expressed in pixels, into float
- /// texture coordinates
- ///
- /// \param Rect : Sub-rectangle of image to convert
+ /// \brief Get the color of a pixel
///
- /// \return Texture coordinates corresponding to the sub-rectangle
+ /// This function doesn't check the validity of the pixel
+ /// coordinates, using out-of-range values will result in
+ /// an undefined behaviour.
///
- ////////////////////////////////////////////////////////////
- FloatRect GetTexCoords(const IntRect& Rect) const;
-
- ////////////////////////////////////////////////////////////
- /// Get a valid texture size according to hardware support
+ /// \param x X coordinate of pixel to get
+ /// \param y Y coordinate of pixel to get
///
- /// \param Size : Size to convert
+ /// \return Color of the pixel at coordinates (x, y)
///
- /// \return Valid nearest size (greater than or equal to specified size)
+ /// \see setPixel
///
////////////////////////////////////////////////////////////
- static unsigned int GetValidTextureSize(unsigned int Size);
+ Color getPixel(unsigned int x, unsigned int y) const;
////////////////////////////////////////////////////////////
- /// Assignment operator
+ /// \brief Get a read-only pointer to the array of pixels
///
- /// \param Other : instance to assign
+ /// The returned value points to an array of RGBA pixels made of
+ /// 8 bits integers components. The size of the array is
+ /// width * height * 4 (getSize().x * getSize().y * 4).
+ /// Warning: the returned pointer may become invalid if you
+ /// modify the image, so you should never store it for too long.
+ /// If the image is empty, a null pointer is returned.
///
- /// \return Reference to the image
+ /// \return Read-only pointer to the array of pixels
///
////////////////////////////////////////////////////////////
- Image& operator =(const Image& Other);
-
-private :
+ const Uint8* getPixelsPtr() const;
////////////////////////////////////////////////////////////
- /// Create the OpenGL texture
- ///
- /// \return True if texture has been successfully created
+ /// \brief Flip the image horizontally (left <-> right)
///
////////////////////////////////////////////////////////////
- bool CreateTexture();
-
- ////////////////////////////////////////////////////////////
- /// Make sure the texture in video memory is updated with the
- /// array of pixels
- ////////////////////////////////////////////////////////////
- void EnsureTextureUpdate() const;
-
- ////////////////////////////////////////////////////////////
- /// Make sure the array of pixels is updated with the
- /// texture in video memory
- ////////////////////////////////////////////////////////////
- void EnsureArrayUpdate() const;
+ void flipHorizontally();
////////////////////////////////////////////////////////////
- /// Reset the image attributes
+ /// \brief Flip the image vertically (top <-> bottom)
///
////////////////////////////////////////////////////////////
- void Reset();
+ void flipVertically();
- ////////////////////////////////////////////////////////////
- /// Destroy the OpenGL texture
- ///
- ////////////////////////////////////////////////////////////
- void DestroyTexture();
+private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- unsigned int myWidth; ///< Image width
- unsigned int myHeight; ///< Image Height
- unsigned int myTextureWidth; ///< Actual texture width (can be greater than image width because of padding)
- unsigned int myTextureHeight; ///< Actual texture height (can be greater than image height because of padding)
- unsigned int myTexture; ///< Internal texture identifier
- bool myIsSmooth; ///< Status of the smooth filter
- mutable std::vector<Color> myPixels; ///< Pixels of the image
- mutable bool myNeedTextureUpdate; ///< Status of synchronization between pixels in central memory and the internal texture un video memory
- mutable bool myNeedArrayUpdate; ///< Status of synchronization between pixels in central memory and the internal texture un video memory
+ Vector2u m_size; ///< Image size
+ std::vector<Uint8> m_pixels; ///< Pixels of the image
};
} // namespace sf
#endif // SFML_IMAGE_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Image
+/// \ingroup graphics
+///
+/// sf::Image is an abstraction to manipulate images
+/// as bidimensional arrays of pixels. The class provides
+/// functions to load, read, write and save pixels, as well
+/// as many other useful functions.
+///
+/// sf::Image can handle a unique internal representation of
+/// pixels, which is RGBA 32 bits. This means that a pixel
+/// must be composed of 8 bits red, green, blue and alpha
+/// channels -- just like a sf::Color.
+/// All the functions that return an array of pixels follow
+/// this rule, and all parameters that you pass to sf::Image
+/// functions (such as loadFromPixels) must use this
+/// representation as well.
+///
+/// A sf::Image can be copied, but it is a heavy resource and
+/// if possible you should always use [const] references to
+/// pass or return them to avoid useless copies.
+///
+/// Usage example:
+/// \code
+/// // Load an image file from a file
+/// sf::Image background;
+/// if (!background.loadFromFile("background.jpg"))
+/// return -1;
+///
+/// // Create a 20x20 image filled with black color
+/// sf::Image image;
+/// image.create(20, 20, sf::Color::Black);
+///
+/// // Copy image1 on image2 at position (10, 10)
+/// image.copy(background, 10, 10);
+///
+/// // Make the top-left pixel transparent
+/// sf::Color color = image.getPixel(0, 0);
+/// color.a = 0;
+/// image.setPixel(0, 0, color);
+///
+/// // Save the image to a file
+/// if (!image.saveToFile("result.png"))
+/// return -1;
+/// \endcode
+///
+/// \see sf::Texture
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Graphics/Matrix3.hpp b/include/SFML/Graphics/Matrix3.hpp deleted file mode 100755 index eeea1b0..0000000 --- a/include/SFML/Graphics/Matrix3.hpp +++ /dev/null @@ -1,148 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_MATRIX3_HPP
-#define SFML_MATRIX3_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
-#include <SFML/System/Vector2.hpp>
-#include <math.h>
-
-
-namespace sf
-{
-////////////////////////////////////////////////////////////
-/// Utility class to manipulate 3x3 matrices representing
-/// 2D transformations
-////////////////////////////////////////////////////////////
-class SFML_API Matrix3
-{
-public :
-
- ////////////////////////////////////////////////////////////
- /// Default constructor (builds an identity matrix)
- ///
- ////////////////////////////////////////////////////////////
- Matrix3();
-
- ////////////////////////////////////////////////////////////
- /// Construct a matrix from its 9 elements
- ///
- ////////////////////////////////////////////////////////////
- Matrix3(float a00, float a01, float a02,
- float a10, float a11, float a12,
- float a20, float a21, float a22);
-
- ////////////////////////////////////////////////////////////
- /// Build a matrix from a set of transformations
- ///
- /// \param Center : Origin for the transformations
- /// \param Translation : Translation offset
- /// \param Rotation : Rotation angle in degrees
- /// \param Scale : Scaling factors
- ///
- ////////////////////////////////////////////////////////////
- void SetFromTransformations(const Vector2f& Center, const Vector2f& Translation, float Rotation, const Vector2f& Scale);
-
- ////////////////////////////////////////////////////////////
- /// Transform a point by the matrix
- ///
- /// \param Point : Point to transform
- ///
- /// \return Transformed point
- ///
- ////////////////////////////////////////////////////////////
- Vector2f Transform(const Vector2f& Point) const;
-
- ////////////////////////////////////////////////////////////
- /// Return the inverse of the matrix
- ///
- /// \return A new matrix which is the inverse of this
- ///
- ////////////////////////////////////////////////////////////
- Matrix3 GetInverse() const;
-
- ////////////////////////////////////////////////////////////
- /// Return the elements of the matrix as a 4x4,
- /// in an array of 16 floats
- ///
- /// \return Pointer to the 4x4 matrix elements
- ///
- ////////////////////////////////////////////////////////////
- const float* Get4x4Elements() const;
-
- ////////////////////////////////////////////////////////////
- /// Operator () overloads to access the matrix elements
- ///
- /// \param Row : Element row (0 based)
- /// \param Col : Element column (0 based)
- ///
- /// \return Matrix element (Row, Col)
- ///
- ////////////////////////////////////////////////////////////
- float operator ()(unsigned int Row, unsigned int Col) const;
- float& operator ()(unsigned int Row, unsigned int Col);
-
- ////////////////////////////////////////////////////////////
- /// Operator * overload to multiply two matrices
- ///
- /// \param Mat : Matrix to multiply
- ///
- /// \return this * Mat
- ///
- ////////////////////////////////////////////////////////////
- Matrix3 operator *(const Matrix3& Mat) const;
-
- ////////////////////////////////////////////////////////////
- /// Operator *= overload to multiply-assign two matrices
- ///
- /// \param Mat : Matrix to multiply
- ///
- /// \return this * Mat
- ///
- ////////////////////////////////////////////////////////////
- Matrix3& operator *=(const Matrix3& Mat);
-
- ////////////////////////////////////////////////////////////
- // Static member data
- ////////////////////////////////////////////////////////////
- static const Matrix3 Identity; ///< Identity matrix
-
-private :
-
- ////////////////////////////////////////////////////////////
- // Member data
- ////////////////////////////////////////////////////////////
- float myData[16]; /// Matrix elements (we directly store it as a 4x4 matrix for optimization purpose)
-};
-
-#include <SFML/Graphics/Matrix3.inl>
-
-} // namespace sf
-
-
-#endif // SFML_MATRIX3_HPP
diff --git a/include/SFML/Graphics/Matrix3.inl b/include/SFML/Graphics/Matrix3.inl deleted file mode 100755 index 4499415..0000000 --- a/include/SFML/Graphics/Matrix3.inl +++ /dev/null @@ -1,186 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFGE - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-
-////////////////////////////////////////////////////////////
-/// Default constructor (builds an identity matrix)
-////////////////////////////////////////////////////////////
-inline Matrix3::Matrix3()
-{
- myData[0] = 1.f; myData[4] = 0.f; myData[8] = 0.f; myData[12] = 0.f;
- myData[1] = 0.f; myData[5] = 1.f; myData[9] = 0.f; myData[13] = 0.f;
- myData[2] = 0.f; myData[6] = 0.f; myData[10] = 1.f; myData[14] = 0.f;
- myData[3] = 0.f; myData[7] = 0.f; myData[11] = 0.f; myData[15] = 1.f;
-}
-
-
-////////////////////////////////////////////////////////////
-/// Construct a matrix from its 9 elements
-////////////////////////////////////////////////////////////
-inline Matrix3::Matrix3(float a00, float a01, float a02,
- float a10, float a11, float a12,
- float a20, float a21, float a22)
-{
- myData[0] = a00; myData[4] = a01; myData[8] = 0.f; myData[12] = a02;
- myData[1] = a10; myData[5] = a11; myData[9] = 0.f; myData[13] = a12;
- myData[2] = 0.f; myData[6] = 0.f; myData[10] = 1.f; myData[14] = 0.f;
- myData[3] = a20; myData[7] = a21; myData[11] = 0.f; myData[15] = a22;
-}
-
-
-////////////////////////////////////////////////////////////
-/// Build a matrix from a set of transformations
-////////////////////////////////////////////////////////////
-inline void Matrix3::SetFromTransformations(const Vector2f& Center, const Vector2f& Translation, float Rotation, const Vector2f& Scale)
-{
- float Angle = Rotation * 3.141592654f / 180.f;
- float Cos = static_cast<float>(cos(Angle));
- float Sin = static_cast<float>(sin(Angle));
- float SxCos = Scale.x * Cos;
- float SyCos = Scale.y * Cos;
- float SxSin = Scale.x * Sin;
- float SySin = Scale.y * Sin;
- float Tx = -Center.x * SxCos - Center.y * SySin + Translation.x;
- float Ty = Center.x * SxSin - Center.y * SyCos + Translation.y;
-
- myData[0] = SxCos; myData[4] = SySin; myData[8] = 0.f; myData[12] = Tx;
- myData[1] = -SxSin; myData[5] = SyCos; myData[9] = 0.f; myData[13] = Ty;
- myData[2] = 0.f; myData[6] = 0.f; myData[10] = 1.f; myData[14] = 0.f;
- myData[3] = 0.f; myData[7] = 0.f; myData[11] = 0.f; myData[15] = 1.f;
-}
-
-
-////////////////////////////////////////////////////////////
-/// Transform a point by the matrix
-////////////////////////////////////////////////////////////
-inline Vector2f Matrix3::Transform(const Vector2f& Point) const
-{
- return Vector2f(myData[0] * Point.x + myData[4] * Point.y + myData[12],
- myData[1] * Point.x + myData[5] * Point.y + myData[13]);
-}
-
-
-////////////////////////////////////////////////////////////
-/// Return the inverse of the matrix
-////////////////////////////////////////////////////////////
-inline Matrix3 Matrix3::GetInverse() const
-{
- // Compute the determinant
- float Det = myData[0] * (myData[15] * myData[5] - myData[7] * myData[13]) -
- myData[1] * (myData[15] * myData[4] - myData[7] * myData[12]) +
- myData[3] * (myData[13] * myData[4] - myData[5] * myData[12]);
-
- // Compute the inverse if determinant is not zero
- if ((Det < -1E-7f) || (Det > 1E-7f))
- {
- return Matrix3( (myData[15] * myData[5] - myData[7] * myData[13]) / Det,
- -(myData[15] * myData[4] - myData[7] * myData[12]) / Det,
- (myData[13] * myData[4] - myData[5] * myData[12]) / Det,
- -(myData[15] * myData[1] - myData[3] * myData[13]) / Det,
- (myData[15] * myData[0] - myData[3] * myData[12]) / Det,
- -(myData[13] * myData[0] - myData[1] * myData[12]) / Det,
- (myData[7] * myData[1] - myData[3] * myData[5]) / Det,
- -(myData[7] * myData[0] - myData[3] * myData[4]) / Det,
- (myData[5] * myData[0] - myData[1] * myData[4]) / Det);
- }
- else
- {
- return Identity;
- }
-}
-
-
-////////////////////////////////////////////////////////////
-/// Return the elements of the matrix as a 4x4,
-/// in an array of 16 floats
-////////////////////////////////////////////////////////////
-inline const float* Matrix3::Get4x4Elements() const
-{
- return myData;
-}
-
-
-////////////////////////////////////////////////////////////
-/// Operator () overloads to access the matrix elements
-////////////////////////////////////////////////////////////
-inline float Matrix3::operator ()(unsigned int Row, unsigned int Col) const
-{
- switch (Row + Col * 3)
- {
- case 0 : return myData[0];
- case 1 : return myData[1];
- case 2 : return myData[3];
- case 3 : return myData[4];
- case 4 : return myData[5];
- case 5 : return myData[7];
- case 6 : return myData[12];
- case 7 : return myData[13];
- case 8 : return myData[15];
-
- default : return myData[0];
- }
-}
-inline float& Matrix3::operator ()(unsigned int Row, unsigned int Col)
-{
- switch (Row + Col * 3)
- {
- case 0 : return myData[0];
- case 1 : return myData[1];
- case 2 : return myData[3];
- case 3 : return myData[4];
- case 4 : return myData[5];
- case 5 : return myData[7];
- case 6 : return myData[12];
- case 7 : return myData[13];
- case 8 : return myData[15];
-
- default : return myData[0];
- }
-}
-
-
-////////////////////////////////////////////////////////////
-/// Operator * overload to multiply two matrices
-////////////////////////////////////////////////////////////
-inline Matrix3 Matrix3::operator *(const Matrix3& Mat) const
-{
- return Matrix3(myData[0] * Mat.myData[0] + myData[4] * Mat.myData[1] + myData[12] * Mat.myData[3],
- myData[0] * Mat.myData[4] + myData[4] * Mat.myData[5] + myData[12] * Mat.myData[7],
- myData[0] * Mat.myData[12] + myData[4] * Mat.myData[13] + myData[12] * Mat.myData[15],
- myData[1] * Mat.myData[0] + myData[5] * Mat.myData[1] + myData[13] * Mat.myData[3],
- myData[1] * Mat.myData[4] + myData[5] * Mat.myData[5] + myData[13] * Mat.myData[7],
- myData[1] * Mat.myData[12] + myData[5] * Mat.myData[13] + myData[13] * Mat.myData[15],
- myData[3] * Mat.myData[0] + myData[7] * Mat.myData[1] + myData[15] * Mat.myData[3],
- myData[3] * Mat.myData[4] + myData[7] * Mat.myData[5] + myData[15] * Mat.myData[7],
- myData[3] * Mat.myData[12] + myData[7] * Mat.myData[13] + myData[15] * Mat.myData[15]);
-}
-
-
-////////////////////////////////////////////////////////////
-/// Operator *= overload to multiply-assign two matrices
-////////////////////////////////////////////////////////////
-inline Matrix3& Matrix3::operator *=(const Matrix3& Mat)
-{
- return *this = *this * Mat;
-}
diff --git a/include/SFML/Graphics/PostFX.hpp b/include/SFML/Graphics/PostFX.hpp deleted file mode 100755 index c875377..0000000 --- a/include/SFML/Graphics/PostFX.hpp +++ /dev/null @@ -1,194 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_POSTFX_HPP
-#define SFML_POSTFX_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Drawable.hpp>
-#include <SFML/Graphics/Image.hpp>
-#include <istream>
-#include <map>
-#include <string>
-
-
-namespace sf
-{
-////////////////////////////////////////////////////////////
-/// PostFX is used to apply a post effect to a window
-////////////////////////////////////////////////////////////
-class SFML_API PostFX : public Drawable
-{
-public :
-
- ////////////////////////////////////////////////////////////
- /// Default constructor
- ///
- ////////////////////////////////////////////////////////////
- PostFX();
-
- ////////////////////////////////////////////////////////////
- /// Copy constructor
- ///
- /// \param Copy : Instance to copy
- ///
- ////////////////////////////////////////////////////////////
- PostFX(const PostFX& Copy);
-
- ////////////////////////////////////////////////////////////
- /// Destructor
- ///
- ////////////////////////////////////////////////////////////
- ~PostFX();
-
- ////////////////////////////////////////////////////////////
- /// Load the effect from a file
- ///
- /// \param Filename : Path of the effect file to load
- ///
- /// \return True on success
- ///
- ////////////////////////////////////////////////////////////
- bool LoadFromFile(const std::string& Filename);
-
- ////////////////////////////////////////////////////////////
- /// Load the effect from a text in memory
- ///
- /// \param Effect : String containing the effect code
- ///
- /// \return True on success
- ///
- ////////////////////////////////////////////////////////////
- bool LoadFromMemory(const std::string& Effect);
-
- ////////////////////////////////////////////////////////////
- /// Change a parameter of the effect (1 float)
- ///
- /// \param Name : Parameter name in the effect
- /// \param X : Value to assign
- ///
- ////////////////////////////////////////////////////////////
- void SetParameter(const std::string& Name, float X);
-
- ////////////////////////////////////////////////////////////
- /// Change a parameter of the effect (2 floats)
- ///
- /// \param Name : Parameter name in the effect
- /// \param X, Y : Values to assign
- ///
- ////////////////////////////////////////////////////////////
- void SetParameter(const std::string& Name, float X, float Y);
-
- ////////////////////////////////////////////////////////////
- /// Change a parameter of the effect (3 floats)
- ///
- /// \param Name : Parameter name in the effect
- /// \param X, Y, Z : Values to assign
- ///
- ////////////////////////////////////////////////////////////
- void SetParameter(const std::string& Name, float X, float Y, float Z);
-
- ////////////////////////////////////////////////////////////
- /// Change a parameter of the effect (4 floats)
- ///
- /// \param Name : Parameter name in the effect
- /// \param X, Y, Z, W : Values to assign
- ///
- ////////////////////////////////////////////////////////////
- void SetParameter(const std::string& Name, float X, float Y, float Z, float W);
-
- ////////////////////////////////////////////////////////////
- /// Set a texture parameter
- ///
- /// \param Name : Texture name in the effect
- /// \param Texture : Image to set (pass NULL to use content of current framebuffer)
- ///
- ////////////////////////////////////////////////////////////
- void SetTexture(const std::string& Name, Image* Texture);
-
- ////////////////////////////////////////////////////////////
- /// Assignment operator
- ///
- /// \param Other : Instance to assign
- ///
- /// \return Reference to the post-effect
- ///
- ////////////////////////////////////////////////////////////
- PostFX& operator =(const PostFX& Other);
-
- ////////////////////////////////////////////////////////////
- /// Tell whether or not the system supports post-effects
- ///
- /// \return True if the system can use post-effects
- ///
- ////////////////////////////////////////////////////////////
- static bool CanUsePostFX();
-
-protected :
-
- ////////////////////////////////////////////////////////////
- /// /see Drawable::Render
- ///
- ////////////////////////////////////////////////////////////
- virtual void Render(RenderTarget& Target) const;
-
-private :
-
- ////////////////////////////////////////////////////////////
- /// Preprocess a SFML effect file
- /// to convert it to a valid GLSL fragment shader
- ///
- /// \param File : Stream containing the code to process
- ///
- /// \return Valid fragment shader source code
- ///
- ////////////////////////////////////////////////////////////
- static std::string PreprocessEffect(std::istream& File);
-
- ////////////////////////////////////////////////////////////
- /// Create the program and attach the shaders
- ///
- ////////////////////////////////////////////////////////////
- void CreateProgram();
-
- ////////////////////////////////////////////////////////////
- // Types
- ////////////////////////////////////////////////////////////
- typedef std::map<std::string, const Image*> TextureTable;
-
- ////////////////////////////////////////////////////////////
- // Member data
- ////////////////////////////////////////////////////////////
- unsigned int myShaderProgram; ///< OpenGL identifier for the program
- TextureTable myTextures; ///< Texture variables in the effect
- std::string myFragmentShader; ///< Fragment shader source code
- mutable Image myFrameBuffer; ///< Texture containing the current frame buffer
-};
-
-} // namespace sf
-
-
-#endif // SFML_POSTFX_HPP
diff --git a/include/SFML/Graphics/PrimitiveType.hpp b/include/SFML/Graphics/PrimitiveType.hpp new file mode 100644 index 0000000..8f3cfb2 --- /dev/null +++ b/include/SFML/Graphics/PrimitiveType.hpp @@ -0,0 +1,53 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_PRIMITIVETYPE_HPP +#define SFML_PRIMITIVETYPE_HPP + +namespace sf +{ +//////////////////////////////////////////////////////////// +/// \ingroup graphics +/// \brief Types of primitives that a sf::VertexArray can render +/// +/// Points and lines have no area, therefore their thickness +/// will always be 1 pixel, regarldess the current transform +/// and view. +/// +//////////////////////////////////////////////////////////// +enum PrimitiveType +{ + Points, ///< List of individual points + Lines, ///< List of individual lines + LinesStrip, ///< List of connected lines, a point uses the previous point to form a line + Triangles, ///< List of individual triangles + TrianglesStrip, ///< List of connected triangles, a point uses the two previous points to form a triangle + TrianglesFan, ///< List of connected triangles, a point uses the common center and the previous point to form a triangle + Quads ///< List of individual quads +}; + +} // namespace sf + + +#endif // SFML_PRIMITIVETYPE_HPP diff --git a/include/SFML/Graphics/Rect.hpp b/include/SFML/Graphics/Rect.hpp index 5decd3c..3a3acc7 100755..100644 --- a/include/SFML/Graphics/Rect.hpp +++ b/include/SFML/Graphics/Rect.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,14 +28,15 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
+#include <SFML/System/Vector2.hpp>
#include <algorithm>
namespace sf
{
////////////////////////////////////////////////////////////
-/// Rect is an utility class for manipulating rectangles.
-/// Template parameter defines the type of coordinates (integer, float, ...)
+/// \brief Utility class for manipulating 2D axis aligned rectangles
+///
////////////////////////////////////////////////////////////
template <typename T>
class Rect
@@ -43,81 +44,149 @@ class Rect public :
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
+ ///
+ /// Creates an empty rectangle (it is equivalent to calling
+ /// Rect(0, 0, 0, 0)).
///
////////////////////////////////////////////////////////////
Rect();
////////////////////////////////////////////////////////////
- /// Construct the rectangle from its coordinates
+ /// \brief Construct the rectangle from its coordinates
+ ///
+ /// Be careful, the last two parameters are the width
+ /// and height, not the right and bottom coordinates!
+ ///
+ /// \param rectLeft Left coordinate of the rectangle
+ /// \param rectTop Top coordinate of the rectangle
+ /// \param rectWidth Width of the rectangle
+ /// \param rectHeight Height of the rectangle
+ ///
+ ////////////////////////////////////////////////////////////
+ Rect(T rectLeft, T rectTop, T rectWidth, T rectHeight);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Construct the rectangle from position and size
///
- /// \param LeftCoord : Left coordinate of the rectangle
- /// \param TopCoord : Top coordinate of the rectangle
- /// \param RightCoord : Right coordinate of the rectangle
- /// \param BottomCoord : Bottom coordinate of the rectangle
+ /// Be careful, the last parameter is the size,
+ /// not the bottom-right corner!
+ ///
+ /// \param position Position of the top-left corner of the rectangle
+ /// \param size Size of the rectangle
///
////////////////////////////////////////////////////////////
- Rect(T LeftCoord, T TopCoord, T RightCoord, T BottomCoord);
+ Rect(const Vector2<T>& position, const Vector2<T>& size);
////////////////////////////////////////////////////////////
- /// Get the width of the rectangle
+ /// \brief Construct the rectangle from another type of rectangle
+ ///
+ /// This constructor doesn't replace the copy constructor,
+ /// it's called only when U != T.
+ /// A call to this constructor will fail to compile if U
+ /// is not convertible to T.
///
- /// \return Width of rectangle
+ /// \param rectangle Rectangle to convert
///
////////////////////////////////////////////////////////////
- T GetWidth() const;
+ template <typename U>
+ explicit Rect(const Rect<U>& rectangle);
////////////////////////////////////////////////////////////
- /// Get the height of the rectangle
+ /// \brief Check if a point is inside the rectangle's area
+ ///
+ /// \param x X coordinate of the point to test
+ /// \param y Y coordinate of the point to test
+ ///
+ /// \return True if the point is inside, false otherwise
///
- /// \return Height of rectangle
+ /// \see intersects
///
////////////////////////////////////////////////////////////
- T GetHeight() const;
+ bool contains(T x, T y) const;
////////////////////////////////////////////////////////////
- /// Move the whole rectangle by the given offset
+ /// \brief Check if a point is inside the rectangle's area
///
- /// \param OffsetX : Horizontal offset
- /// \param OffsetY : Vertical offset
+ /// \param point Point to test
+ ///
+ /// \return True if the point is inside, false otherwise
+ ///
+ /// \see intersects
///
////////////////////////////////////////////////////////////
- void Offset(T OffsetX, T OffsetY);
+ bool contains(const Vector2<T>& point) const;
////////////////////////////////////////////////////////////
- /// Check if a point is inside the rectangle's area
+ /// \brief Check the intersection between two rectangles
+ ///
+ /// \param rectangle Rectangle to test
///
- /// \param X : X coordinate of the point to test
- /// \param Y : Y coordinate of the point to test
+ /// \return True if rectangles overlap, false otherwise
///
- /// \return True if the point is inside
+ /// \see contains
///
////////////////////////////////////////////////////////////
- bool Contains(T X, T Y) const;
+ bool intersects(const Rect<T>& rectangle) const;
////////////////////////////////////////////////////////////
- /// Check intersection between two rectangles
+ /// \brief Check the intersection between two rectangles
///
- /// \param Rectangle : Rectangle to test
- /// \param OverlappingRect : Rectangle to be filled with overlapping rect (NULL by default)
+ /// This overload returns the overlapped rectangle in the
+ /// \a intersection parameter.
///
- /// \return True if rectangles overlap
+ /// \param rectangle Rectangle to test
+ /// \param intersection Rectangle to be filled with the intersection
+ ///
+ /// \return True if rectangles overlap, false otherwise
+ ///
+ /// \see contains
///
////////////////////////////////////////////////////////////
- bool Intersects(const Rect<T>& Rectangle, Rect<T>* OverlappingRect = NULL) const;
+ bool intersects(const Rect<T>& rectangle, Rect<T>& intersection) const;
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- T Left; ///< Left coordinate of the rectangle
- T Top; ///< Top coordinate of the rectangle
- T Right; ///< Right coordinate of the rectangle
- T Bottom; ///< Bottom coordinate of the rectangle
+ T left; ///< Left coordinate of the rectangle
+ T top; ///< Top coordinate of the rectangle
+ T width; ///< Width of the rectangle
+ T height; ///< Height of the rectangle
};
+////////////////////////////////////////////////////////////
+/// \relates Rect
+/// \brief Overload of binary operator ==
+///
+/// This operator compares strict equality between two rectangles.
+///
+/// \param left Left operand (a rectangle)
+/// \param right Right operand (a rectangle)
+///
+/// \return True if \a left is equal to \a right
+///
+////////////////////////////////////////////////////////////
+template <typename T>
+bool operator ==(const Rect<T>& left, const Rect<T>& right);
+
+////////////////////////////////////////////////////////////
+/// \relates Rect
+/// \brief Overload of binary operator !=
+///
+/// This operator compares strict difference between two rectangles.
+///
+/// \param left Left operand (a rectangle)
+/// \param right Right operand (a rectangle)
+///
+/// \return True if \a left is not equal to \a right
+///
+////////////////////////////////////////////////////////////
+template <typename T>
+bool operator !=(const Rect<T>& left, const Rect<T>& right);
+
#include <SFML/Graphics/Rect.inl>
-// Define the most common types
+// Create typedefs for the most common types
typedef Rect<int> IntRect;
typedef Rect<float> FloatRect;
@@ -125,3 +194,55 @@ typedef Rect<float> FloatRect; #endif // SFML_RECT_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Rect
+/// \ingroup graphics
+///
+/// A rectangle is defined by its top-left corner and its size.
+/// It is a very simple class defined for convenience, so
+/// its member variables (left, top, width and height) are public
+/// and can be accessed directly, just like the vector classes
+/// (Vector2 and Vector3).
+///
+/// To keep things simple, sf::Rect doesn't define
+/// functions to emulate the properties that are not directly
+/// members (such as right, bottom, center, etc.), it rather
+/// only provides intersection functions.
+///
+/// sf::Rect uses the usual rules for its boundaries:
+/// \li The left and top edges are included in the rectangle's area
+/// \li The right (left + width) and bottom (top + height) edges are excluded from the rectangle's area
+///
+/// This means that sf::IntRect(0, 0, 1, 1) and sf::IntRect(1, 1, 1, 1)
+/// don't intersect.
+///
+/// sf::Rect is a template and may be used with any numeric type, but
+/// for simplicity the instanciations used by SFML are typedefed:
+/// \li sf::Rect<int> is sf::IntRect
+/// \li sf::Rect<float> is sf::FloatRect
+///
+/// So that you don't have to care about the template syntax.
+///
+/// Usage example:
+/// \code
+/// // Define a rectangle, located at (0, 0) with a size of 20x5
+/// sf::IntRect r1(0, 0, 20, 5);
+///
+/// // Define another rectangle, located at (4, 2) with a size of 18x10
+/// sf::Vector2i position(4, 2);
+/// sf::Vector2i size(18, 10);
+/// sf::IntRect r2(position, size);
+///
+/// // Test intersections with the point (3, 1)
+/// bool b1 = r1.contains(3, 1); // true
+/// bool b2 = r2.contains(3, 1); // false
+///
+/// // Test the intersection between r1 and r2
+/// sf::IntRect result;
+/// bool b3 = r1.intersects(r2, result); // true
+/// // result == (4, 2, 16, 3)
+/// \endcode
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Graphics/Rect.inl b/include/SFML/Graphics/Rect.inl index 6c5962d..0a97b99 100755..100644 --- a/include/SFML/Graphics/Rect.inl +++ b/include/SFML/Graphics/Rect.inl @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2012 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -24,99 +24,136 @@ ////////////////////////////////////////////////////////////
-/// Default constructor
-////////////////////////////////////////////////////////////
template <typename T>
Rect<T>::Rect() :
-Left (0),
-Top (0),
-Right (0),
-Bottom(0)
+left (0),
+top (0),
+width (0),
+height(0)
{
}
////////////////////////////////////////////////////////////
-/// Construct the color from its coordinates
-////////////////////////////////////////////////////////////
template <typename T>
-Rect<T>::Rect(T LeftCoord, T TopCoord, T RightCoord, T BottomCoord) :
-Left (LeftCoord),
-Top (TopCoord),
-Right (RightCoord),
-Bottom(BottomCoord)
+Rect<T>::Rect(T rectLeft, T rectTop, T rectWidth, T rectHeight) :
+left (rectLeft),
+top (rectTop),
+width (rectWidth),
+height(rectHeight)
{
}
////////////////////////////////////////////////////////////
-/// Get the width of the rectangle
-////////////////////////////////////////////////////////////
template <typename T>
-T Rect<T>::GetWidth() const
+Rect<T>::Rect(const Vector2<T>& position, const Vector2<T>& size) :
+left (position.x),
+top (position.y),
+width (size.x),
+height(size.y)
{
- return Right - Left;
+
}
////////////////////////////////////////////////////////////
-/// Get the height of the rectangle
-////////////////////////////////////////////////////////////
template <typename T>
-T Rect<T>::GetHeight() const
+template <typename U>
+Rect<T>::Rect(const Rect<U>& rectangle) :
+left (static_cast<T>(rectangle.left)),
+top (static_cast<T>(rectangle.top)),
+width (static_cast<T>(rectangle.width)),
+height(static_cast<T>(rectangle.height))
{
- return Bottom - Top;
}
////////////////////////////////////////////////////////////
-/// Move the whole rectangle by the given offset
-////////////////////////////////////////////////////////////
template <typename T>
-void Rect<T>::Offset(T OffsetX, T OffsetY)
+bool Rect<T>::contains(T x, T y) const
{
- Left += OffsetX;
- Right += OffsetX;
- Top += OffsetY;
- Bottom += OffsetY;
+ // Rectangles with negative dimensions are allowed, so we must handle them correctly
+
+ // Compute the real min and max of the rectangle on both axes
+ T minX = std::min(left, left + width);
+ T maxX = std::max(left, left + width);
+ T minY = std::min(top, top + height);
+ T maxY = std::max(top, top + height);
+
+ return (x >= minX) && (x < maxX) && (y >= minY) && (y < maxY);
}
////////////////////////////////////////////////////////////
-/// Check if a point is inside the rectangle's area
-////////////////////////////////////////////////////////////
template <typename T>
-bool Rect<T>::Contains(T X, T Y) const
+bool Rect<T>::contains(const Vector2<T>& point) const
{
- return (X >= Left) && (X <= Right) && (Y >= Top) && (Y <= Bottom);
+ return contains(point.x, point.y);
}
////////////////////////////////////////////////////////////
-/// Check intersection between two rectangles
+template <typename T>
+bool Rect<T>::intersects(const Rect<T>& rectangle) const
+{
+ Rect<T> intersection;
+ return intersects(rectangle, intersection);
+}
+
+
////////////////////////////////////////////////////////////
template <typename T>
-bool Rect<T>::Intersects(const Rect<T>& Rectangle, Rect<T>* OverlappingRect) const
+bool Rect<T>::intersects(const Rect<T>& rectangle, Rect<T>& intersection) const
{
- // Compute overlapping rect
- Rect Overlapping(std::max(Left, Rectangle.Left),
- std::max(Top, Rectangle.Top),
- std::min(Right, Rectangle.Right),
- std::min(Bottom, Rectangle.Bottom));
-
- // If overlapping rect is valid, then there is intersection
- if ((Overlapping.Left < Overlapping.Right) && (Overlapping.Top < Overlapping.Bottom))
+ // Rectangles with negative dimensions are allowed, so we must handle them correctly
+
+ // Compute the min and max of the first rectangle on both axes
+ T r1MinX = std::min(left, left + width);
+ T r1MaxX = std::max(left, left + width);
+ T r1MinY = std::min(top, top + height);
+ T r1MaxY = std::max(top, top + height);
+
+ // Compute the min and max of the second rectangle on both axes
+ T r2MinX = std::min(rectangle.left, rectangle.left + rectangle.width);
+ T r2MaxX = std::max(rectangle.left, rectangle.left + rectangle.width);
+ T r2MinY = std::min(rectangle.top, rectangle.top + rectangle.height);
+ T r2MaxY = std::max(rectangle.top, rectangle.top + rectangle.height);
+
+ // Compute the intersection boundaries
+ T interLeft = std::max(r1MinX, r2MinX);
+ T interTop = std::max(r1MinY, r2MinY);
+ T interRight = std::min(r1MaxX, r2MaxX);
+ T interBottom = std::min(r1MaxY, r2MaxY);
+
+ // If the intersection is valid (positive non zero area), then there is an intersection
+ if ((interLeft < interRight) && (interTop < interBottom))
{
- if (OverlappingRect)
- *OverlappingRect = Overlapping;
+ intersection = Rect<T>(interLeft, interTop, interRight - interLeft, interBottom - interTop);
return true;
}
else
{
- if (OverlappingRect)
- *OverlappingRect = Rect(0, 0, 0, 0);
+ intersection = Rect<T>(0, 0, 0, 0);
return false;
}
}
+
+
+////////////////////////////////////////////////////////////
+template <typename T>
+inline bool operator ==(const Rect<T>& left, const Rect<T>& right)
+{
+ return (left.left == right.left) && (left.width == right.width) &&
+ (left.top == right.top) && (left.height == right.height);
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename T>
+inline bool operator !=(const Rect<T>& left, const Rect<T>& right)
+{
+ return !(left == right);
+}
diff --git a/include/SFML/Network/SelectorBase.hpp b/include/SFML/Graphics/RectangleShape.hpp index 4b9e915..2140e91 100755..100644 --- a/include/SFML/Network/SelectorBase.hpp +++ b/include/SFML/Graphics/RectangleShape.hpp @@ -1,112 +1,128 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_SELECTORBASE_HPP
-#define SFML_SELECTORBASE_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
-#include <SFML/Network/SocketHelper.hpp>
-#include <map>
-
-
-namespace sf
-{
-////////////////////////////////////////////////////////////
-/// Private base class for selectors.
-/// As Selector is a template class, this base is needed so that
-/// every system call get compiled in SFML (not inlined)
-////////////////////////////////////////////////////////////
-class SFML_API SelectorBase
-{
-public :
-
- ////////////////////////////////////////////////////////////
- /// Default constructor
- ///
- ////////////////////////////////////////////////////////////
- SelectorBase();
-
- ////////////////////////////////////////////////////////////
- /// Add a socket to watch
- ///
- /// \param Socket : Socket to add
- ///
- ////////////////////////////////////////////////////////////
- void Add(SocketHelper::SocketType Socket);
-
- ////////////////////////////////////////////////////////////
- /// Remove a socket
- ///
- /// \param Socket : Socket to remove
- ///
- ////////////////////////////////////////////////////////////
- void Remove(SocketHelper::SocketType Socket);
-
- ////////////////////////////////////////////////////////////
- /// Remove all sockets
- ///
- ////////////////////////////////////////////////////////////
- void Clear();
-
- ////////////////////////////////////////////////////////////
- /// Wait and collect sockets which are ready for reading.
- /// This functions will return either when at least one socket
- /// is ready, or when the given time is out
- ///
- /// \param Timeout : Timeout, in seconds (0 by default : no timeout)
- ///
- /// \return Number of sockets ready to be read
- ///
- ////////////////////////////////////////////////////////////
- unsigned int Wait(float Timeout = 0.f);
-
- ////////////////////////////////////////////////////////////
- /// After a call to Wait(), get the Index-th socket which is
- /// ready for reading. The total number of sockets ready
- /// is the integer returned by the previous call to Wait()
- ///
- /// \param Index : Index of the socket to get
- ///
- /// \return The Index-th socket
- ///
- ////////////////////////////////////////////////////////////
- SocketHelper::SocketType GetSocketReady(unsigned int Index);
-
-private :
-
- ////////////////////////////////////////////////////////////
- // Member data
- ////////////////////////////////////////////////////////////
- fd_set mySet; ///< Set of socket to watch
- fd_set mySetReady; ///< Set of socket which are ready for reading
- int myMaxSocket; ///< Maximum socket index
-};
-
-} // namespace sf
-
-
-#endif // SFML_SELECTORBASE_HPP
+//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_RECTANGLESHAPE_HPP +#define SFML_RECTANGLESHAPE_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.hpp> +#include <SFML/Graphics/Shape.hpp> + + +namespace sf +{ +//////////////////////////////////////////////////////////// +/// \brief Specialized shape representing a rectangle +/// +//////////////////////////////////////////////////////////// +class SFML_GRAPHICS_API RectangleShape : public Shape +{ +public : + + //////////////////////////////////////////////////////////// + /// \brief Default constructor + /// + /// \param size Size of the rectangle + /// + //////////////////////////////////////////////////////////// + explicit RectangleShape(const Vector2f& size = Vector2f(0, 0)); + + //////////////////////////////////////////////////////////// + /// \brief Set the size of the rectangle + /// + /// \param size New size of the rectangle + /// + /// \see getSize + /// + //////////////////////////////////////////////////////////// + void setSize(const Vector2f& size); + + //////////////////////////////////////////////////////////// + /// \brief Get the size of the rectangle + /// + /// \return Size of the rectangle + /// + /// \see setSize + /// + //////////////////////////////////////////////////////////// + const Vector2f& getSize() const; + + //////////////////////////////////////////////////////////// + /// \brief Get the number of points defining the shape + /// + /// \return Number of points of the shape + /// + //////////////////////////////////////////////////////////// + virtual unsigned int getPointCount() const; + + //////////////////////////////////////////////////////////// + /// \brief Get a point of the shape + /// + /// The result is undefined if \a index is out of the valid range. + /// + /// \param index Index of the point to get, in range [0 .. getPointCount() - 1] + /// + /// \return Index-th point of the shape + /// + //////////////////////////////////////////////////////////// + virtual Vector2f getPoint(unsigned int index) const; + +private : + + //////////////////////////////////////////////////////////// + // Member data + //////////////////////////////////////////////////////////// + Vector2f m_size; ///< Size of the rectangle +}; + +} // namespace sf + + +#endif // SFML_RECTANGLESHAPE_HPP + + +//////////////////////////////////////////////////////////// +/// \class sf::RectangleShape +/// \ingroup graphics +/// +/// This class inherits all the functions of sf::Transformable +/// (position, rotation, scale, bounds, ...) as well as the +/// functions of sf::Shape (outline, color, texture, ...). +/// +/// Usage example: +/// \code +/// sf::RectangleShape rectangle; +/// rectangle.setSize(sf::Vector2f(100, 50)); +/// rectangle.setOutlineColor(sf::Color::Red); +/// rectangle.setOutlineThickness(5); +/// rectangle.setPosition(10, 20); +/// ... +/// window.draw(rectangle); +/// \endcode +/// +/// \see sf::Shape, sf::CircleShape, sf::ConvexShape +/// +//////////////////////////////////////////////////////////// diff --git a/include/SFML/Graphics/RenderStates.hpp b/include/SFML/Graphics/RenderStates.hpp new file mode 100644 index 0000000..bf4183c --- /dev/null +++ b/include/SFML/Graphics/RenderStates.hpp @@ -0,0 +1,174 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_RENDERSTATES_HPP +#define SFML_RENDERSTATES_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.hpp> +#include <SFML/Graphics/BlendMode.hpp> +#include <SFML/Graphics/Transform.hpp> + + +namespace sf +{ +class Shader; +class Texture; + +//////////////////////////////////////////////////////////// +/// \brief Define the states used for drawing to a RenderTarget +/// +//////////////////////////////////////////////////////////// +class SFML_GRAPHICS_API RenderStates +{ +public : + + //////////////////////////////////////////////////////////// + /// \brief Default constructor + /// + /// Constructing a default set of render states is equivalent + /// to using sf::RenderStates::Default. + /// The default set defines: + /// \li the BlendAlpha blend mode + /// \li the identity transform + /// \li a null texture + /// \li a null shader + /// + //////////////////////////////////////////////////////////// + RenderStates(); + + //////////////////////////////////////////////////////////// + /// \brief Construct a default set of render states with a custom blend mode + /// + /// \param theBlendMode Blend mode to use + /// + //////////////////////////////////////////////////////////// + RenderStates(BlendMode theBlendMode); + + //////////////////////////////////////////////////////////// + /// \brief Construct a default set of render states with a custom transform + /// + /// \param theTransform Transform to use + /// + //////////////////////////////////////////////////////////// + RenderStates(const Transform& theTransform); + + //////////////////////////////////////////////////////////// + /// \brief Construct a default set of render states with a custom texture + /// + /// \param theTexture Texture to use + /// + //////////////////////////////////////////////////////////// + RenderStates(const Texture* theTexture); + + //////////////////////////////////////////////////////////// + /// \brief Construct a default set of render states with a custom shader + /// + /// \param theShader Shader to use + /// + //////////////////////////////////////////////////////////// + RenderStates(const Shader* theShader); + + //////////////////////////////////////////////////////////// + /// \brief Construct a set of render states with all its attributes + /// + /// \param theBlendMode Blend mode to use + /// \param theTransform Transform to use + /// \param theTexture Texture to use + /// \param theShader Shader to use + /// + //////////////////////////////////////////////////////////// + RenderStates(BlendMode theBlendMode, const Transform& theTransform, + const Texture* theTexture, const Shader* theShader); + + //////////////////////////////////////////////////////////// + // Static member data + //////////////////////////////////////////////////////////// + static const RenderStates Default; ///< Special instance holding the default render states + + //////////////////////////////////////////////////////////// + // Member data + //////////////////////////////////////////////////////////// + BlendMode blendMode; ///< Blending mode + Transform transform; ///< Transform + const Texture* texture; ///< Texture + const Shader* shader; ///< Shader +}; + +} // namespace sf + + +#endif // SFML_RENDERSTATES_HPP + + +//////////////////////////////////////////////////////////// +/// \class sf::RenderStates +/// \ingroup graphics +/// +/// There are four global states that can be applied to +/// the drawn objects: +/// \li the blend mode: how pixels of the object are blended with the background +/// \li the transform: how the object is positioned/rotated/scaled +/// \li the texture: what image is mapped to the object +/// \li the shader: what custom effect is applied to the object +/// +/// High-level objects such as sprites or text force some of +/// these states when they are drawn. For example, a sprite +/// will set its own texture, so that you don't have to care +/// about it when drawing the sprite. +/// +/// The transform is a special case: sprites, texts and shapes +/// (and it's a good idea to do it with your own drawable classes +/// too) combine their transform with the one that is passed in the +/// RenderStates structure. So that you can use a "global" transform +/// on top of each object's transform. +/// +/// Most objects, especially high-level drawables, can be drawn +/// directly without defining render states explicitely -- the +/// default set of states is ok in most cases. +/// \code +/// window.Draw(sprite); +/// \endcode +/// +/// If you want to use a single specific render state, +/// for example a shader, you can pass it directly to the Draw +/// function: sf::RenderStates has an implicit one-argument +/// constructor for each state. +/// \code +/// window.draw(sprite, shader); +/// \endcode +/// +/// When you're inside the Draw function of a drawable +/// object (inherited from sf::Drawable), you can +/// either pass the render states unmodified, or change +/// some of them. +/// For example, a transformable object will combine the +/// current transform with its own transform. A sprite will +/// set its texture. Etc. +/// +/// \see sf::RenderTarget, sf::Drawable +/// +//////////////////////////////////////////////////////////// diff --git a/include/SFML/Graphics/RenderTarget.hpp b/include/SFML/Graphics/RenderTarget.hpp index ea303d9..5f69e7f 100755..100644 --- a/include/SFML/Graphics/RenderTarget.hpp +++ b/include/SFML/Graphics/RenderTarget.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,9 +28,16 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
+#include <SFML/Graphics/Export.hpp>
#include <SFML/Graphics/Color.hpp>
-#include <SFML/Graphics/View.hpp>
#include <SFML/Graphics/Rect.hpp>
+#include <SFML/Graphics/View.hpp>
+#include <SFML/Graphics/Transform.hpp>
+#include <SFML/Graphics/BlendMode.hpp>
+#include <SFML/Graphics/RenderStates.hpp>
+#include <SFML/Graphics/PrimitiveType.hpp>
+#include <SFML/Graphics/Vertex.hpp>
+#include <SFML/System/NonCopyable.hpp>
namespace sf
@@ -38,129 +45,407 @@ namespace sf class Drawable;
////////////////////////////////////////////////////////////
-/// Base class for all render targets (window, image, ...)
+/// \brief Base class for all render targets (window, texture, ...)
+///
////////////////////////////////////////////////////////////
-class SFML_API RenderTarget
+class SFML_GRAPHICS_API RenderTarget : NonCopyable
{
public :
////////////////////////////////////////////////////////////
- /// Destructor
+ /// \brief Destructor
///
////////////////////////////////////////////////////////////
virtual ~RenderTarget();
////////////////////////////////////////////////////////////
- /// Clear the entire target with a single color
+ /// \brief Clear the entire target with a single color
+ ///
+ /// This function is usually called once every frame,
+ /// to clear the previous contents of the target.
+ ///
+ /// \param color Fill color to use to clear the render target
+ ///
+ ////////////////////////////////////////////////////////////
+ void clear(const Color& color = Color(0, 0, 0, 255));
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Change the current active view
+ ///
+ /// The view is like a 2D camera, it controls which part of
+ /// the 2D scene is visible, and how it is viewed in the
+ /// render-target.
+ /// The new view will affect everything that is drawn, until
+ /// another view is set.
+ /// The render target keeps its own copy of the view object,
+ /// so it is not necessary to keep the original one alive
+ /// after calling this function.
+ /// To restore the original view of the target, you can pass
+ /// the result of getDefaultView() to this function.
+ ///
+ /// \param view New view to use
+ ///
+ /// \see getView, getDefaultView
+ ///
+ ////////////////////////////////////////////////////////////
+ void setView(const View& view);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the view currently in use in the render target
+ ///
+ /// \return The view object that is currently used
+ ///
+ /// \see setView, getDefaultView
+ ///
+ ////////////////////////////////////////////////////////////
+ const View& getView() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the default view of the render target
+ ///
+ /// The default view has the initial size of the render target,
+ /// and never changes after the target has been created.
+ ///
+ /// \return The default view of the render target
+ ///
+ /// \see setView, getView
+ ///
+ ////////////////////////////////////////////////////////////
+ const View& getDefaultView() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the viewport of a view, applied to this render target
+ ///
+ /// The viewport is defined in the view as a ratio, this function
+ /// simply applies this ratio to the current dimensions of the
+ /// render target to calculate the pixels rectangle that the viewport
+ /// actually covers in the target.
+ ///
+ /// \param view The view for which we want to compute the viewport
+ ///
+ /// \return Viewport rectangle, expressed in pixels
+ ///
+ ////////////////////////////////////////////////////////////
+ IntRect getViewport(const View& view) const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert a point from target coordinates to world
+ /// coordinates, using the current view
+ ///
+ /// This function is an overload of the mapPixelToCoords
+ /// function that implicitely uses the current view.
+ /// It is equivalent to:
+ /// \code
+ /// target.mapPixelToCoords(point, target.getView());
+ /// \endcode
+ ///
+ /// \param point Pixel to convert
+ ///
+ /// \return The converted point, in "world" coordinates
+ ///
+ /// \see mapCoordsToPixel
+ ///
+ ////////////////////////////////////////////////////////////
+ Vector2f mapPixelToCoords(const Vector2i& point) const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert a point from target coordinates to world coordinates
+ ///
+ /// This function finds the 2D position that matches the
+ /// given pixel of the render-target. In other words, it does
+ /// the inverse of what the graphics card does, to find the
+ /// initial position of a rendered pixel.
+ ///
+ /// Initially, both coordinate systems (world units and target pixels)
+ /// match perfectly. But if you define a custom view or resize your
+ /// render-target, this assertion is not true anymore, ie. a point
+ /// located at (10, 50) in your render-target may map to the point
+ /// (150, 75) in your 2D world -- if the view is translated by (140, 25).
+ ///
+ /// For render-windows, this function is typically used to find
+ /// which point (or object) is located below the mouse cursor.
+ ///
+ /// This version uses a custom view for calculations, see the other
+ /// overload of the function if you want to use the current view of the
+ /// render-target.
+ ///
+ /// \param point Pixel to convert
+ /// \param view The view to use for converting the point
+ ///
+ /// \return The converted point, in "world" units
+ ///
+ /// \see mapCoordsToPixel
+ ///
+ ////////////////////////////////////////////////////////////
+ Vector2f mapPixelToCoords(const Vector2i& point, const View& view) const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert a point from world coordinates to target
+ /// coordinates, using the current view
+ ///
+ /// This function is an overload of the mapCoordsToPixel
+ /// function that implicitely uses the current view.
+ /// It is equivalent to:
+ /// \code
+ /// target.mapCoordsToPixel(point, target.getView());
+ /// \endcode
+ ///
+ /// \param point Point to convert
///
- /// \param FillColor : Color to use to clear the render target
+ /// \return The converted point, in target coordinates (pixels)
+ ///
+ /// \see mapPixelToCoords
///
////////////////////////////////////////////////////////////
- void Clear(const Color& FillColor = Color(0, 0, 0));
+ Vector2i mapCoordsToPixel(const Vector2f& point) const;
////////////////////////////////////////////////////////////
- /// Draw something into the target
+ /// \brief Convert a point from world coordinates to target coordinates
+ ///
+ /// This function finds the pixel of the render-target that matches
+ /// the given 2D point. In other words, it goes through the same process
+ /// as the graphics card, to compute the final position of a rendered point.
+ ///
+ /// Initially, both coordinate systems (world units and target pixels)
+ /// match perfectly. But if you define a custom view or resize your
+ /// render-target, this assertion is not true anymore, ie. a point
+ /// located at (150, 75) in your 2D world may map to the pixel
+ /// (10, 50) of your render-target -- if the view is translated by (140, 25).
+ ///
+ /// This version uses a custom view for calculations, see the other
+ /// overload of the function if you want to use the current view of the
+ /// render-target.
+ ///
+ /// \param point Point to convert
+ /// \param view The view to use for converting the point
+ ///
+ /// \return The converted point, in target coordinates (pixels)
///
- /// \param Object : Object to draw
+ /// \see mapPixelToCoords
///
////////////////////////////////////////////////////////////
- virtual void Draw(const Drawable& Object);
+ Vector2i mapCoordsToPixel(const Vector2f& point, const View& view) const;
////////////////////////////////////////////////////////////
- /// Get the width of the rendering region of the target
+ /// \brief Draw a drawable object to the render-target
///
- /// \return Width in pixels
+ /// \param drawable Object to draw
+ /// \param states Render states to use for drawing
///
////////////////////////////////////////////////////////////
- virtual unsigned int GetWidth() const = 0;
+ void draw(const Drawable& drawable, const RenderStates& states = RenderStates::Default);
////////////////////////////////////////////////////////////
- /// Get the height of the rendering region of the target
+ /// \brief Draw primitives defined by an array of vertices
///
- /// \return Height in pixels
+ /// \param vertices Pointer to the vertices
+ /// \param vertexCount Number of vertices in the array
+ /// \param type Type of primitives to draw
+ /// \param states Render states to use for drawing
///
////////////////////////////////////////////////////////////
- virtual unsigned int GetHeight() const = 0;
+ void draw(const Vertex* vertices, unsigned int vertexCount,
+ PrimitiveType type, const RenderStates& states = RenderStates::Default);
////////////////////////////////////////////////////////////
- /// Change the current active view.
+ /// \brief Return the size of the rendering region of the target
///
- /// \param NewView : New view to use (pass GetDefaultView() to set the default view)
+ /// \return Size in pixels
///
////////////////////////////////////////////////////////////
- void SetView(const View& NewView);
+ virtual Vector2u getSize() const = 0;
////////////////////////////////////////////////////////////
- /// Get the current view
+ /// \brief Save the current OpenGL render states and matrices
///
- /// \return Current view active in the window
+ /// This function can be used when you mix SFML drawing
+ /// and direct OpenGL rendering. Combined with PopGLStates,
+ /// it ensures that:
+ /// \li SFML's internal states are not messed up by your OpenGL code
+ /// \li your OpenGL states are not modified by a call to a SFML function
+ ///
+ /// More specifically, it must be used around code that
+ /// calls Draw functions. Example:
+ /// \code
+ /// // OpenGL code here...
+ /// window.pushGLStates();
+ /// window.draw(...);
+ /// window.draw(...);
+ /// window.popGLStates();
+ /// // OpenGL code here...
+ /// \endcode
+ ///
+ /// Note that this function is quite expensive: it saves all the
+ /// possible OpenGL states and matrices, even the ones you
+ /// don't care about. Therefore it should be used wisely.
+ /// It is provided for convenience, but the best results will
+ /// be achieved if you handle OpenGL states yourself (because
+ /// you know which states have really changed, and need to be
+ /// saved and restored). Take a look at the ResetGLStates
+ /// function if you do so.
+ ///
+ /// \see popGLStates
///
////////////////////////////////////////////////////////////
- const View& GetView() const;
+ void pushGLStates();
////////////////////////////////////////////////////////////
- /// Get the default view of the window for read / write
+ /// \brief Restore the previously saved OpenGL render states and matrices
///
- /// \return Default view
+ /// See the description of pushGLStates to get a detailed
+ /// description of these functions.
+ ///
+ /// \see pushGLStates
///
////////////////////////////////////////////////////////////
- View& GetDefaultView();
+ void popGLStates();
////////////////////////////////////////////////////////////
- /// Tell SFML to preserve external OpenGL states, at the expense of
- /// more CPU charge. Use this function if you don't want SFML
- /// to mess up your own OpenGL states (if any).
- /// Don't enable state preservation if not needed, as it will allow
- /// SFML to do internal optimizations and improve performances.
- /// This parameter is false by default
+ /// \brief Reset the internal OpenGL states so that the target is ready for drawing
+ ///
+ /// This function can be used when you mix SFML drawing
+ /// and direct OpenGL rendering, if you choose not to use
+ /// pushGLStates/popGLStates. It makes sure that all OpenGL
+ /// states needed by SFML are set, so that subsequent draw()
+ /// calls will work as expected.
///
- /// \param Preserve : True to preserve OpenGL states, false to let SFML optimize
+ /// Example:
+ /// \code
+ /// // OpenGL code here...
+ /// glPushAttrib(...);
+ /// window.resetGLStates();
+ /// window.draw(...);
+ /// window.draw(...);
+ /// glPopAttrib(...);
+ /// // OpenGL code here...
+ /// \endcode
///
////////////////////////////////////////////////////////////
- void PreserveOpenGLStates(bool Preserve);
+ void resetGLStates();
protected :
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
///
////////////////////////////////////////////////////////////
RenderTarget();
////////////////////////////////////////////////////////////
- /// Called by the derived class when it's ready to be initialized
+ /// \brief Performs the common initialization step after creation
+ ///
+ /// The derived classes must call this function after the
+ /// target is created and ready for drawing.
///
////////////////////////////////////////////////////////////
- void Initialize();
+ void initialize();
-private :
+private:
////////////////////////////////////////////////////////////
- /// Activate the target for rendering
+ /// \brief Apply the current view
///
- /// \param Active : True to activate rendering, false to deactivate
+ ////////////////////////////////////////////////////////////
+ void applyCurrentView();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Apply a new blending mode
///
- /// \return True if activation succeeded
+ /// \param mode Blending mode to apply
///
////////////////////////////////////////////////////////////
- virtual bool Activate(bool Active) = 0;
+ void applyBlendMode(BlendMode mode);
////////////////////////////////////////////////////////////
- /// Set the OpenGL render states needed for the SFML rendering
+ /// \brief Apply a new transform
+ ///
+ /// \param transform Transform to apply
///
////////////////////////////////////////////////////////////
- void SetRenderStates();
+ void applyTransform(const Transform& transform);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Apply a new texture
+ ///
+ /// \param texture Texture to apply
+ ///
+ ////////////////////////////////////////////////////////////
+ void applyTexture(const Texture* texture);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Apply a new shader
+ ///
+ /// \param shader Shader to apply
+ ///
+ ////////////////////////////////////////////////////////////
+ void applyShader(const Shader* shader);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Activate the target for rendering
+ ///
+ /// This function must be implemented by derived classes to make
+ /// their OpenGL context current; it is called by the base class
+ /// everytime it's going to use OpenGL calls.
+ ///
+ /// \param active True to make the target active, false to deactivate it
+ ///
+ /// \return True if the function succeeded
+ ///
+ ////////////////////////////////////////////////////////////
+ virtual bool activate(bool active) = 0;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Render states cache
+ ///
+ ////////////////////////////////////////////////////////////
+ struct StatesCache
+ {
+ enum {VertexCacheSize = 4};
+
+ bool glStatesSet; ///< Are our internal GL states set yet?
+ bool viewChanged; ///< Has the current view changed since last draw?
+ BlendMode lastBlendMode; ///< Cached blending mode
+ Uint64 lastTextureId; ///< Cached texture
+ bool useVertexCache; ///< Did we previously use the vertex cache?
+ Vertex vertexCache[VertexCacheSize]; ///< Pre-transformed vertices cache
+ };
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- View myDefaultView; ///< Default view
- const View* myCurrentView; ///< Current active view
- bool myPreserveStates; ///< Should we preserve external OpenGL states ?
- bool myIsDrawing; ///< True when Draw is called from inside, to allow some renderstates optimizations
+ View m_defaultView; ///< Default view
+ View m_view; ///< Current view
+ StatesCache m_cache; ///< Render states cache
};
} // namespace sf
#endif // SFML_RENDERTARGET_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::RenderTarget
+/// \ingroup graphics
+///
+/// sf::RenderTarget defines the common behaviour of all the
+/// 2D render targets usable in the graphics module. It makes
+/// it possible to draw 2D entities like sprites, shapes, text
+/// without using any OpenGL command directly.
+///
+/// A sf::RenderTarget is also able to use views (sf::View),
+/// which are a kind of 2D cameras. With views you can globally
+/// scroll, rotate or zoom everything that is drawn,
+/// without having to transform every single entity. See the
+/// documentation of sf::View for more details and sample pieces of
+/// code about this class.
+///
+/// On top of that, render targets are still able to render direct
+/// OpenGL stuff. It is even possible to mix together OpenGL calls
+/// and regular SFML drawing commands. When doing so, make sure that
+/// OpenGL states are not messed up by calling the
+/// pushGLStates/popGLStates functions.
+///
+/// \see sf::RenderWindow, sf::RenderTexture, sf::View
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Graphics/RenderTexture.hpp b/include/SFML/Graphics/RenderTexture.hpp new file mode 100644 index 0000000..384e459 --- /dev/null +++ b/include/SFML/Graphics/RenderTexture.hpp @@ -0,0 +1,280 @@ +////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+// you must not claim that you wrote the original software.
+// If you use this software in a product, an acknowledgment
+// in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+// and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_RENDERTEXTURE_HPP
+#define SFML_RENDERTEXTURE_HPP
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Graphics/Export.hpp>
+#include <SFML/Graphics/Texture.hpp>
+#include <SFML/Graphics/RenderTarget.hpp>
+
+
+namespace sf
+{
+namespace priv
+{
+ class RenderTextureImpl;
+}
+
+////////////////////////////////////////////////////////////
+/// \brief Target for off-screen 2D rendering into a texture
+///
+////////////////////////////////////////////////////////////
+class SFML_GRAPHICS_API RenderTexture : public RenderTarget
+{
+public :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Default constructor
+ ///
+ /// Constructs an empty, invalid render-texture. You must
+ /// call create to have a valid render-texture.
+ ///
+ /// \see create
+ ///
+ ////////////////////////////////////////////////////////////
+ RenderTexture();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Destructor
+ ///
+ ////////////////////////////////////////////////////////////
+ virtual ~RenderTexture();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Create the render-texture
+ ///
+ /// Before calling this function, the render-texture is in
+ /// an invalid state, thus it is mandatory to call it before
+ /// doing anything with the render-texture.
+ /// The last parameter, \a depthBuffer, is useful if you want
+ /// to use the render-texture for 3D OpenGL rendering that requires
+ /// a depth-buffer. Otherwise it is unnecessary, and you should
+ /// leave this parameter to false (which is its default value).
+ ///
+ /// \param width Width of the render-texture
+ /// \param height Height of the render-texture
+ /// \param depthBuffer Do you want this render-texture to have a depth buffer?
+ ///
+ /// \return True if creation has been successful
+ ///
+ ////////////////////////////////////////////////////////////
+ bool create(unsigned int width, unsigned int height, bool depthBuffer = false);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Enable or disable texture smoothing
+ ///
+ /// This function is similar to Texture::setSmooth.
+ /// This parameter is disabled by default.
+ ///
+ /// \param smooth True to enable smoothing, false to disable it
+ ///
+ /// \see isSmooth
+ ///
+ ////////////////////////////////////////////////////////////
+ void setSmooth(bool smooth);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Tell whether the smooth filtering is enabled or not
+ ///
+ /// \return True if texture smoothing is enabled
+ ///
+ /// \see setSmooth
+ ///
+ ////////////////////////////////////////////////////////////
+ bool isSmooth() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Enable or disable texture repeating
+ ///
+ /// This function is similar to Texture::setRepeated.
+ /// This parameter is disabled by default.
+ ///
+ /// \param repeated True to enable repeating, false to disable it
+ ///
+ /// \see isRepeated
+ ///
+ ////////////////////////////////////////////////////////////
+ void setRepeated(bool repeated);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Tell whether the texture is repeated or not
+ ///
+ /// \return True if texture is repeated
+ ///
+ /// \see setRepeated
+ ///
+ ////////////////////////////////////////////////////////////
+ bool isRepeated() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Activate of deactivate the render-texture for rendering
+ ///
+ /// This function makes the render-texture's context current for
+ /// future OpenGL rendering operations (so you shouldn't care
+ /// about it if you're not doing direct OpenGL stuff).
+ /// Only one context can be current in a thread, so if you
+ /// want to draw OpenGL geometry to another render target
+ /// (like a RenderWindow) don't forget to activate it again.
+ ///
+ /// \param active True to activate, false to deactivate
+ ///
+ /// \return True if operation was successful, false otherwise
+ ///
+ ////////////////////////////////////////////////////////////
+ bool setActive(bool active = true);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Update the contents of the target texture
+ ///
+ /// This function updates the target texture with what
+ /// has been drawn so far. Like for windows, calling this
+ /// function is mandatory at the end of rendering. Not calling
+ /// it may leave the texture in an undefined state.
+ ///
+ ////////////////////////////////////////////////////////////
+ void display();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Return the size of the rendering region of the texture
+ ///
+ /// The returned value is the size that you passed to
+ /// the create function.
+ ///
+ /// \return Size in pixels
+ ///
+ ////////////////////////////////////////////////////////////
+ virtual Vector2u getSize() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get a read-only reference to the target texture
+ ///
+ /// After drawing to the render-texture and calling Display,
+ /// you can retrieve the updated texture using this function,
+ /// and draw it using a sprite (for example).
+ /// The internal sf::Texture of a render-texture is always the
+ /// same instance, so that it is possible to call this function
+ /// once and keep a reference to the texture even after it is
+ /// modified.
+ ///
+ /// \return Const reference to the texture
+ ///
+ ////////////////////////////////////////////////////////////
+ const Texture& getTexture() const;
+
+private :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Activate the target for rendering
+ ///
+ /// This function is called by the base class
+ /// everytime it's going to use OpenGL calls.
+ ///
+ /// \param active True to make the target active, false to deactivate it
+ ///
+ /// \return True if the function succeeded
+ ///
+ ////////////////////////////////////////////////////////////
+ virtual bool activate(bool active);
+
+ ////////////////////////////////////////////////////////////
+ // Member data
+ ////////////////////////////////////////////////////////////
+ priv::RenderTextureImpl* m_impl; ///< Platform/hardware specific implementation
+ Texture m_texture; ///< Target texture to draw on
+};
+
+} // namespace sf
+
+
+#endif // SFML_RENDERTEXTURE_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::RenderTexture
+/// \ingroup graphics
+///
+/// sf::RenderTexture is the little brother of sf::RenderWindow.
+/// It implements the same 2D drawing and OpenGL-related functions
+/// (see their base class sf::RenderTarget for more details),
+/// the difference is that the result is stored in an off-screen
+/// texture rather than being show in a window.
+///
+/// Rendering to a texture can be useful in a variety of situations:
+/// \li precomputing a complex static texture (like a level's background from multiple tiles)
+/// \li applying post-effects to the whole scene with shaders
+/// \li creating a sprite from a 3D object rendered with OpenGL
+/// \li etc.
+///
+/// Usage example:
+///
+/// \code
+/// // Create a new render-window
+/// sf::RenderWindow window(sf::VideoMode(800, 600), "SFML window");
+///
+/// // Create a new render-texture
+/// sf::RenderTexture texture;
+/// if (!texture.create(500, 500))
+/// return -1;
+///
+/// // The main loop
+/// while (window.isOpen())
+/// {
+/// // Event processing
+/// // ...
+///
+/// // Clear the whole texture with red color
+/// texture.clear(sf::Color::Red);
+///
+/// // Draw stuff to the texture
+/// texture.draw(sprite); // sprite is a sf::Sprite
+/// texture.draw(shape); // shape is a sf::Shape
+/// texture.draw(text); // text is a sf::Text
+///
+/// // We're done drawing to the texture
+/// texture.display();
+///
+/// // Now we start rendering to the window, clear it first
+/// window.clear();
+///
+/// // Draw the texture
+/// sf::Sprite sprite(texture.getTexture());
+/// window.draw(sprite);
+///
+/// // End the current frame and display its contents on screen
+/// window.display();
+/// }
+/// \endcode
+///
+/// Like sf::RenderWindow, sf::RenderTexture is still able to render direct
+/// OpenGL stuff. It is even possible to mix together OpenGL calls
+/// and regular SFML drawing commands. If you need a depth buffer for
+/// 3D rendering, don't forget to request it when calling RenderTexture::create.
+///
+/// \see sf::RenderTarget, sf::RenderWindow, sf::View, sf::Texture
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Graphics/RenderWindow.hpp b/include/SFML/Graphics/RenderWindow.hpp index 088e368..b069347 100755..100644 --- a/include/SFML/Graphics/RenderWindow.hpp +++ b/include/SFML/Graphics/RenderWindow.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,108 +28,239 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/Graphics/Image.hpp>
+#include <SFML/Graphics/Export.hpp>
#include <SFML/Graphics/RenderTarget.hpp>
+#include <SFML/Graphics/Image.hpp>
#include <SFML/Window/Window.hpp>
#include <string>
namespace sf
{
-class Drawable;
-
////////////////////////////////////////////////////////////
-/// Simple wrapper for sf::Window that allows easy
-/// 2D rendering
+/// \brief Window that can serve as a target for 2D drawing
+///
////////////////////////////////////////////////////////////
-class SFML_API RenderWindow : public Window, public RenderTarget
+class SFML_GRAPHICS_API RenderWindow : public Window, public RenderTarget
{
public :
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
+ ///
+ /// This constructor doesn't actually create the window,
+ /// use the other constructors or call "create" to do so.
///
////////////////////////////////////////////////////////////
RenderWindow();
////////////////////////////////////////////////////////////
- /// Construct the window
+ /// \brief Construct a new window
+ ///
+ /// This constructor creates the window with the size and pixel
+ /// depth defined in \a mode. An optional style can be passed to
+ /// customize the look and behaviour of the window (borders,
+ /// title bar, resizable, closable, ...).
+ ///
+ /// The fourth parameter is an optional structure specifying
+ /// advanced OpenGL context settings such as antialiasing,
+ /// depth-buffer bits, etc. You shouldn't care about these
+ /// parameters for a regular usage of the graphics module.
///
- /// \param Mode : Video mode to use
- /// \param Title : Title of the window
- /// \param WindowStyle : Window style, see sf::Style (Resize | Close by default)
- /// \param Params : Creation parameters (see default constructor for default values)
+ /// \param mode Video mode to use (defines the width, height and depth of the rendering area of the window)
+ /// \param title Title of the window
+ /// \param style Window style
+ /// \param settings Additional settings for the underlying OpenGL context
///
////////////////////////////////////////////////////////////
- RenderWindow(VideoMode Mode, const std::string& Title, unsigned long WindowStyle = Style::Resize | Style::Close, const WindowSettings& Params = WindowSettings());
+ RenderWindow(VideoMode mode, const String& title, Uint32 style = Style::Default, const ContextSettings& settings = ContextSettings());
////////////////////////////////////////////////////////////
- /// Construct the window from an existing control
+ /// \brief Construct the window from an existing control
///
- /// \param Handle : Platform-specific handle of the control
- /// \param Params : Creation parameters (see default constructor for default values)
+ /// Use this constructor if you want to create an SFML
+ /// rendering area into an already existing control.
+ ///
+ /// The fourth parameter is an optional structure specifying
+ /// advanced OpenGL context settings such as antialiasing,
+ /// depth-buffer bits, etc. You shouldn't care about these
+ /// parameters for a regular usage of the graphics module.
+ ///
+ /// \param handle Platform-specific handle of the control
+ /// \param settings Additional settings for the underlying OpenGL context
///
////////////////////////////////////////////////////////////
- RenderWindow(WindowHandle Handle, const WindowSettings& Params = WindowSettings());
+ explicit RenderWindow(WindowHandle handle, const ContextSettings& settings = ContextSettings());
////////////////////////////////////////////////////////////
- /// Destructor
+ /// \brief Destructor
+ ///
+ /// Closes the window and free all the resources attached to it.
///
////////////////////////////////////////////////////////////
virtual ~RenderWindow();
////////////////////////////////////////////////////////////
- /// Get the width of the rendering region of the window
+ /// \brief Get the size of the rendering region of the window
///
- /// \return Width in pixels
+ /// The size doesn't include the titlebar and borders
+ /// of the window.
+ ///
+ /// \return Size in pixels
///
////////////////////////////////////////////////////////////
- virtual unsigned int GetWidth() const;
+ virtual Vector2u getSize() const;
////////////////////////////////////////////////////////////
- /// Get the height of the rendering region of the window
+ /// \brief Copy the current contents of the window to an image
+ ///
+ /// This is a slow operation, whose main purpose is to make
+ /// screenshots of the application. If you want to update an
+ /// image with the contents of the window and then use it for
+ /// drawing, you should rather use a sf::Texture and its
+ /// update(Window&) function.
+ /// You can also draw things directly to a texture with the
+ /// sf::RenderTexture class.
///
- /// \return Height in pixels
+ /// \return Image containing the captured contents
///
////////////////////////////////////////////////////////////
- virtual unsigned int GetHeight() const;
+ Image capture() const;
+
+protected:
////////////////////////////////////////////////////////////
- /// Save the content of the window to an image
+ /// \brief Function called after the window has been created
///
- /// \return Image instance containing the contents of the screen
+ /// This function is called so that derived classes can
+ /// perform their own specific initialization as soon as
+ /// the window is created.
///
////////////////////////////////////////////////////////////
- Image Capture() const;
+ virtual void onCreate();
////////////////////////////////////////////////////////////
- /// Convert a point in window coordinates into view coordinates
- ///
- /// \param WindowX : X coordinate of the point to convert, relative to the window
- /// \param WindowY : Y coordinate of the point to convert, relative to the window
- /// \param TargetView : Target view to convert the point to (NULL by default -- uses the current view)
+ /// \brief Function called after the window has been resized
///
- /// \return Converted point
+ /// This function is called so that derived classes can
+ /// perform custom actions when the size of the window changes.
///
////////////////////////////////////////////////////////////
- sf::Vector2f ConvertCoords(unsigned int WindowX, unsigned int WindowY, const View* TargetView = NULL) const;
+ virtual void onResize();
private :
////////////////////////////////////////////////////////////
- /// /see Window::OnCreate
+ /// \brief Activate the target for rendering
///
- ////////////////////////////////////////////////////////////
- virtual void OnCreate();
-
- ////////////////////////////////////////////////////////////
- /// /see RenderTarget::Activate
+ /// \param active True to make the target active, false to deactivate it
+ ///
+ /// \return True if the function succeeded
///
////////////////////////////////////////////////////////////
- virtual bool Activate(bool Active);
+ virtual bool activate(bool active);
};
} // namespace sf
#endif // SFML_RENDERWINDOW_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::RenderWindow
+/// \ingroup graphics
+///
+/// sf::RenderWindow is the main class of the Graphics module.
+/// It defines an OS window that can be painted using the other
+/// classes of the graphics module.
+///
+/// sf::RenderWindow is derived from sf::Window, thus it inherits
+/// all its features: events, window management, OpenGL rendering,
+/// etc. See the documentation of sf::Window for a more complete
+/// description of all these features, as well as code examples.
+///
+/// On top of that, sf::RenderWindow adds more features related to
+/// 2D drawing with the graphics module (see its base class
+/// sf::RenderTarget for more details).
+/// Here is a typical rendering and event loop with a sf::RenderWindow:
+///
+/// \code
+/// // Declare and create a new render-window
+/// sf::RenderWindow window(sf::VideoMode(800, 600), "SFML window");
+///
+/// // Limit the framerate to 60 frames per second (this step is optional)
+/// window.setFramerateLimit(60);
+///
+/// // The main loop - ends as soon as the window is closed
+/// while (window.isOpen())
+/// {
+/// // Event processing
+/// sf::Event event;
+/// while (window.pollEvent(event))
+/// {
+/// // Request for closing the window
+/// if (event.type == sf::Event::Closed)
+/// window.close();
+/// }
+///
+/// // Clear the whole window before rendering a new frame
+/// window.clear();
+///
+/// // Draw some graphical entities
+/// window.draw(sprite);
+/// window.draw(circle);
+/// window.draw(text);
+///
+/// // End the current frame and display its contents on screen
+/// window.display();
+/// }
+/// \endcode
+///
+/// Like sf::Window, sf::RenderWindow is still able to render direct
+/// OpenGL stuff. It is even possible to mix together OpenGL calls
+/// and regular SFML drawing commands.
+///
+/// \code
+/// // Create the render window
+/// sf::RenderWindow window(sf::VideoMode(800, 600), "SFML OpenGL");
+///
+/// // Create a sprite and a text to display
+/// sf::Sprite sprite;
+/// sf::Text text;
+/// ...
+///
+/// // Perform OpenGL initializations
+/// glMatrixMode(GL_PROJECTION);
+/// ...
+///
+/// // Start the rendering loop
+/// while (window.isOpen())
+/// {
+/// // Process events
+/// ...
+///
+/// // Draw a background sprite
+/// window.pushGLStates();
+/// window.draw(sprite);
+/// window.popGLStates();
+///
+/// // Draw a 3D object using OpenGL
+/// glBegin(GL_QUADS);
+/// glVertex3f(...);
+/// ...
+/// glEnd();
+///
+/// // Draw text on top of the 3D object
+/// window.pushGLStates();
+/// window.draw(text);
+/// window.popGLStates();
+///
+/// // Finally, display the rendered frame on screen
+/// window.display();
+/// }
+/// \endcode
+///
+/// \see sf::Window, sf::RenderTarget, sf::RenderTexture, sf::View
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Graphics/Shader.hpp b/include/SFML/Graphics/Shader.hpp new file mode 100644 index 0000000..2fbbf6e --- /dev/null +++ b/include/SFML/Graphics/Shader.hpp @@ -0,0 +1,635 @@ +////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+// you must not claim that you wrote the original software.
+// If you use this software in a product, an acknowledgment
+// in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+// and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_SHADER_HPP
+#define SFML_SHADER_HPP
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Graphics/Export.hpp>
+#include <SFML/Graphics/Transform.hpp>
+#include <SFML/Graphics/Color.hpp>
+#include <SFML/Window/GlResource.hpp>
+#include <SFML/System/NonCopyable.hpp>
+#include <SFML/System/Vector2.hpp>
+#include <SFML/System/Vector3.hpp>
+#include <map>
+#include <string>
+
+
+namespace sf
+{
+class InputStream;
+class Texture;
+
+////////////////////////////////////////////////////////////
+/// \brief Shader class (vertex and fragment)
+///
+////////////////////////////////////////////////////////////
+class SFML_GRAPHICS_API Shader : GlResource, NonCopyable
+{
+public :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Types of shaders
+ ///
+ ////////////////////////////////////////////////////////////
+ enum Type
+ {
+ Vertex, ///< Vertex shader
+ Fragment ///< Fragment (pixel) shader
+ };
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Special type/value that can be passed to setParameter,
+ /// and that represents the texture of the object being drawn
+ ///
+ ////////////////////////////////////////////////////////////
+ struct CurrentTextureType {};
+ static CurrentTextureType CurrentTexture;
+
+public :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Default constructor
+ ///
+ /// This constructor creates an invalid shader.
+ ///
+ ////////////////////////////////////////////////////////////
+ Shader();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Destructor
+ ///
+ ////////////////////////////////////////////////////////////
+ ~Shader();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Load either the vertex or fragment shader from a file
+ ///
+ /// This function loads a single shader, either vertex or
+ /// fragment, identified by the second argument.
+ /// The source must be a text file containing a valid
+ /// shader in GLSL language. GLSL is a C-like language
+ /// dedicated to OpenGL shaders; you'll probably need to
+ /// read a good documentation for it before writing your
+ /// own shaders.
+ ///
+ /// \param filename Path of the vertex or fragment shader file to load
+ /// \param type Type of shader (vertex or fragment)
+ ///
+ /// \return True if loading succeeded, false if it failed
+ ///
+ /// \see loadFromMemory, loadFromStream
+ ///
+ ////////////////////////////////////////////////////////////
+ bool loadFromFile(const std::string& filename, Type type);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Load both the vertex and fragment shaders from files
+ ///
+ /// This function loads both the vertex and the fragment
+ /// shaders. If one of them fails to load, the shader is left
+ /// empty (the valid shader is unloaded).
+ /// The sources must be text files containing valid shaders
+ /// in GLSL language. GLSL is a C-like language dedicated to
+ /// OpenGL shaders; you'll probably need to read a good documentation
+ /// for it before writing your own shaders.
+ ///
+ /// \param vertexShaderFilename Path of the vertex shader file to load
+ /// \param fragmentShaderFilename Path of the fragment shader file to load
+ ///
+ /// \return True if loading succeeded, false if it failed
+ ///
+ /// \see loadFromMemory, loadFromStream
+ ///
+ ////////////////////////////////////////////////////////////
+ bool loadFromFile(const std::string& vertexShaderFilename, const std::string& fragmentShaderFilename);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Load either the vertex or fragment shader from a source code in memory
+ ///
+ /// This function loads a single shader, either vertex or
+ /// fragment, identified by the second argument.
+ /// The source code must be a valid shader in GLSL language.
+ /// GLSL is a C-like language dedicated to OpenGL shaders;
+ /// you'll probably need to read a good documentation for
+ /// it before writing your own shaders.
+ ///
+ /// \param shader String containing the source code of the shader
+ /// \param type Type of shader (vertex or fragment)
+ ///
+ /// \return True if loading succeeded, false if it failed
+ ///
+ /// \see loadFromFile, loadFromStream
+ ///
+ ////////////////////////////////////////////////////////////
+ bool loadFromMemory(const std::string& shader, Type type);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Load both the vertex and fragment shaders from source codes in memory
+ ///
+ /// This function loads both the vertex and the fragment
+ /// shaders. If one of them fails to load, the shader is left
+ /// empty (the valid shader is unloaded).
+ /// The sources must be valid shaders in GLSL language. GLSL is
+ /// a C-like language dedicated to OpenGL shaders; you'll
+ /// probably need to read a good documentation for it before
+ /// writing your own shaders.
+ ///
+ /// \param vertexShader String containing the source code of the vertex shader
+ /// \param fragmentShader String containing the source code of the fragment shader
+ ///
+ /// \return True if loading succeeded, false if it failed
+ ///
+ /// \see loadFromFile, loadFromStream
+ ///
+ ////////////////////////////////////////////////////////////
+ bool loadFromMemory(const std::string& vertexShader, const std::string& fragmentShader);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Load either the vertex or fragment shader from a custom stream
+ ///
+ /// This function loads a single shader, either vertex or
+ /// fragment, identified by the second argument.
+ /// The source code must be a valid shader in GLSL language.
+ /// GLSL is a C-like language dedicated to OpenGL shaders;
+ /// you'll probably need to read a good documentation for it
+ /// before writing your own shaders.
+ ///
+ /// \param stream Source stream to read from
+ /// \param type Type of shader (vertex or fragment)
+ ///
+ /// \return True if loading succeeded, false if it failed
+ ///
+ /// \see loadFromFile, loadFromMemory
+ ///
+ ////////////////////////////////////////////////////////////
+ bool loadFromStream(InputStream& stream, Type type);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Load both the vertex and fragment shaders from custom streams
+ ///
+ /// This function loads both the vertex and the fragment
+ /// shaders. If one of them fails to load, the shader is left
+ /// empty (the valid shader is unloaded).
+ /// The source codes must be valid shaders in GLSL language.
+ /// GLSL is a C-like language dedicated to OpenGL shaders;
+ /// you'll probably need to read a good documentation for
+ /// it before writing your own shaders.
+ ///
+ /// \param vertexShaderStream Source stream to read the vertex shader from
+ /// \param fragmentShaderStream Source stream to read the fragment shader from
+ ///
+ /// \return True if loading succeeded, false if it failed
+ ///
+ /// \see loadFromFile, loadFromMemory
+ ///
+ ////////////////////////////////////////////////////////////
+ bool loadFromStream(InputStream& vertexShaderStream, InputStream& fragmentShaderStream);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Change a float parameter of the shader
+ ///
+ /// \a name is the name of the variable to change in the shader.
+ /// The corresponding parameter in the shader must be a float
+ /// (float GLSL type).
+ ///
+ /// Example:
+ /// \code
+ /// uniform float myparam; // this is the variable in the shader
+ /// \endcode
+ /// \code
+ /// shader.setParameter("myparam", 5.2f);
+ /// \endcode
+ ///
+ /// \param name Name of the parameter in the shader
+ /// \param x Value to assign
+ ///
+ ////////////////////////////////////////////////////////////
+ void setParameter(const std::string& name, float x);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Change a 2-components vector parameter of the shader
+ ///
+ /// \a name is the name of the variable to change in the shader.
+ /// The corresponding parameter in the shader must be a 2x1 vector
+ /// (vec2 GLSL type).
+ ///
+ /// Example:
+ /// \code
+ /// uniform vec2 myparam; // this is the variable in the shader
+ /// \endcode
+ /// \code
+ /// shader.setParameter("myparam", 5.2f, 6.0f);
+ /// \endcode
+ ///
+ /// \param name Name of the parameter in the shader
+ /// \param x First component of the value to assign
+ /// \param y Second component of the value to assign
+ ///
+ ////////////////////////////////////////////////////////////
+ void setParameter(const std::string& name, float x, float y);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Change a 3-components vector parameter of the shader
+ ///
+ /// \a name is the name of the variable to change in the shader.
+ /// The corresponding parameter in the shader must be a 3x1 vector
+ /// (vec3 GLSL type).
+ ///
+ /// Example:
+ /// \code
+ /// uniform vec3 myparam; // this is the variable in the shader
+ /// \endcode
+ /// \code
+ /// shader.setParameter("myparam", 5.2f, 6.0f, -8.1f);
+ /// \endcode
+ ///
+ /// \param name Name of the parameter in the shader
+ /// \param x First component of the value to assign
+ /// \param y Second component of the value to assign
+ /// \param z Third component of the value to assign
+ ///
+ ////////////////////////////////////////////////////////////
+ void setParameter(const std::string& name, float x, float y, float z);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Change a 4-components vector parameter of the shader
+ ///
+ /// \a name is the name of the variable to change in the shader.
+ /// The corresponding parameter in the shader must be a 4x1 vector
+ /// (vec4 GLSL type).
+ ///
+ /// Example:
+ /// \code
+ /// uniform vec4 myparam; // this is the variable in the shader
+ /// \endcode
+ /// \code
+ /// shader.setParameter("myparam", 5.2f, 6.0f, -8.1f, 0.4f);
+ /// \endcode
+ ///
+ /// \param name Name of the parameter in the shader
+ /// \param x First component of the value to assign
+ /// \param y Second component of the value to assign
+ /// \param z Third component of the value to assign
+ /// \param w Fourth component of the value to assign
+ ///
+ ////////////////////////////////////////////////////////////
+ void setParameter(const std::string& name, float x, float y, float z, float w);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Change a 2-components vector parameter of the shader
+ ///
+ /// \a name is the name of the variable to change in the shader.
+ /// The corresponding parameter in the shader must be a 2x1 vector
+ /// (vec2 GLSL type).
+ ///
+ /// Example:
+ /// \code
+ /// uniform vec2 myparam; // this is the variable in the shader
+ /// \endcode
+ /// \code
+ /// shader.setParameter("myparam", sf::Vector2f(5.2f, 6.0f));
+ /// \endcode
+ ///
+ /// \param name Name of the parameter in the shader
+ /// \param vector Vector to assign
+ ///
+ ////////////////////////////////////////////////////////////
+ void setParameter(const std::string& name, const Vector2f& vector);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Change a 3-components vector parameter of the shader
+ ///
+ /// \a name is the name of the variable to change in the shader.
+ /// The corresponding parameter in the shader must be a 3x1 vector
+ /// (vec3 GLSL type).
+ ///
+ /// Example:
+ /// \code
+ /// uniform vec3 myparam; // this is the variable in the shader
+ /// \endcode
+ /// \code
+ /// shader.setParameter("myparam", sf::Vector3f(5.2f, 6.0f, -8.1f));
+ /// \endcode
+ ///
+ /// \param name Name of the parameter in the shader
+ /// \param vector Vector to assign
+ ///
+ ////////////////////////////////////////////////////////////
+ void setParameter(const std::string& name, const Vector3f& vector);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Change a color parameter of the shader
+ ///
+ /// \a name is the name of the variable to change in the shader.
+ /// The corresponding parameter in the shader must be a 4x1 vector
+ /// (vec4 GLSL type).
+ ///
+ /// It is important to note that the components of the color are
+ /// normalized before being passed to the shader. Therefore,
+ /// they are converted from range [0 .. 255] to range [0 .. 1].
+ /// For example, a sf::Color(255, 125, 0, 255) will be transformed
+ /// to a vec4(1.0, 0.5, 0.0, 1.0) in the shader.
+ ///
+ /// Example:
+ /// \code
+ /// uniform vec4 color; // this is the variable in the shader
+ /// \endcode
+ /// \code
+ /// shader.setParameter("color", sf::Color(255, 128, 0, 255));
+ /// \endcode
+ ///
+ /// \param name Name of the parameter in the shader
+ /// \param color Color to assign
+ ///
+ ////////////////////////////////////////////////////////////
+ void setParameter(const std::string& name, const Color& color);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Change a matrix parameter of the shader
+ ///
+ /// \a name is the name of the variable to change in the shader.
+ /// The corresponding parameter in the shader must be a 4x4 matrix
+ /// (mat4 GLSL type).
+ ///
+ /// Example:
+ /// \code
+ /// uniform mat4 matrix; // this is the variable in the shader
+ /// \endcode
+ /// \code
+ /// sf::Transform transform;
+ /// transform.translate(5, 10);
+ /// shader.setParameter("matrix", transform);
+ /// \endcode
+ ///
+ /// \param name Name of the parameter in the shader
+ /// \param transform Transform to assign
+ ///
+ ////////////////////////////////////////////////////////////
+ void setParameter(const std::string& name, const sf::Transform& transform);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Change a texture parameter of the shader
+ ///
+ /// \a name is the name of the variable to change in the shader.
+ /// The corresponding parameter in the shader must be a 2D texture
+ /// (sampler2D GLSL type).
+ ///
+ /// Example:
+ /// \code
+ /// uniform sampler2D the_texture; // this is the variable in the shader
+ /// \endcode
+ /// \code
+ /// sf::Texture texture;
+ /// ...
+ /// shader.setParameter("the_texture", texture);
+ /// \endcode
+ /// It is important to note that \a texture must remain alive as long
+ /// as the shader uses it, no copy is made internally.
+ ///
+ /// To use the texture of the object being draw, which cannot be
+ /// known in advance, you can pass the special value
+ /// sf::Shader::CurrentTexture:
+ /// \code
+ /// shader.setParameter("the_texture", sf::Shader::CurrentTexture).
+ /// \endcode
+ ///
+ /// \param name Name of the texture in the shader
+ /// \param texture Texture to assign
+ ///
+ ////////////////////////////////////////////////////////////
+ void setParameter(const std::string& name, const Texture& texture);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Change a texture parameter of the shader
+ ///
+ /// This overload maps a shader texture variable to the
+ /// texture of the object being drawn, which cannot be
+ /// known in advance. The second argument must be
+ /// sf::Shader::CurrentTexture.
+ /// The corresponding parameter in the shader must be a 2D texture
+ /// (sampler2D GLSL type).
+ ///
+ /// Example:
+ /// \code
+ /// uniform sampler2D current; // this is the variable in the shader
+ /// \endcode
+ /// \code
+ /// shader.setParameter("current", sf::Shader::CurrentTexture);
+ /// \endcode
+ ///
+ /// \param name Name of the texture in the shader
+ ///
+ ////////////////////////////////////////////////////////////
+ void setParameter(const std::string& name, CurrentTextureType);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Bind a shader for rendering
+ ///
+ /// This function is not part of the graphics API, it mustn't be
+ /// used when drawing SFML entities. It must be used only if you
+ /// mix sf::Shader with OpenGL code.
+ ///
+ /// \code
+ /// sf::Shader s1, s2;
+ /// ...
+ /// sf::Shader::bind(&s1);
+ /// // draw OpenGL stuff that use s1...
+ /// sf::Shader::bind(&s2);
+ /// // draw OpenGL stuff that use s2...
+ /// sf::Shader::bind(NULL);
+ /// // draw OpenGL stuff that use no shader...
+ /// \endcode
+ ///
+ /// \param shader Shader to bind, can be null to use no shader
+ ///
+ ////////////////////////////////////////////////////////////
+ static void bind(const Shader* shader);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Tell whether or not the system supports shaders
+ ///
+ /// This function should always be called before using
+ /// the shader features. If it returns false, then
+ /// any attempt to use sf::Shader will fail.
+ ///
+ /// \return True if shaders are supported, false otherwise
+ ///
+ ////////////////////////////////////////////////////////////
+ static bool isAvailable();
+
+private :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Compile the shader(s) and create the program
+ ///
+ /// If one of the arguments is NULL, the corresponding shader
+ /// is not created.
+ ///
+ /// \param vertexShaderCode Source code of the vertex shader
+ /// \param fragmentShaderCode Source code of the fragment shader
+ ///
+ /// \return True on success, false if any error happened
+ ///
+ ////////////////////////////////////////////////////////////
+ bool compile(const char* vertexShaderCode, const char* fragmentShaderCode);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Bind all the textures used by the shader
+ ///
+ /// This function each texture to a different unit, and
+ /// updates the corresponding variables in the shader accordingly.
+ ///
+ ////////////////////////////////////////////////////////////
+ void bindTextures() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the location ID of a shader parameter
+ ///
+ /// \param name Name of the parameter to search
+ ///
+ /// \return Location ID of the parameter, or -1 if not found
+ ///
+ ////////////////////////////////////////////////////////////
+ int getParamLocation(const std::string& name);
+
+ ////////////////////////////////////////////////////////////
+ // Types
+ ////////////////////////////////////////////////////////////
+ typedef std::map<int, const Texture*> TextureTable;
+ typedef std::map<std::string, int> ParamTable;
+
+ ////////////////////////////////////////////////////////////
+ // Member data
+ ////////////////////////////////////////////////////////////
+ unsigned int m_shaderProgram; ///< OpenGL identifier for the program
+ int m_currentTexture; ///< Location of the current texture in the shader
+ TextureTable m_textures; ///< Texture variables in the shader, mapped to their location
+ ParamTable m_params; ///< Parameters location cache
+};
+
+} // namespace sf
+
+
+#endif // SFML_SHADER_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Shader
+/// \ingroup graphics
+///
+/// Shaders are programs written using a specific language,
+/// executed directly by the graphics card and allowing
+/// to apply real-time operations to the rendered entities.
+///
+/// There are two kinds of shaders:
+/// \li Vertex shaders, that process vertices
+/// \li Fragment (pixel) shaders, that process pixels
+///
+/// A sf::Shader can be composed of either a vertex shader
+/// alone, a fragment shader alone, or both combined
+/// (see the variants of the load functions).
+///
+/// Shaders are written in GLSL, which is a C-like
+/// language dedicated to OpenGL shaders. You'll probably
+/// need to learn its basics before writing your own shaders
+/// for SFML.
+///
+/// Like any C/C++ program, a shader has its own variables
+/// that you can set from your C++ application. sf::Shader
+/// handles 5 different types of variables:
+/// \li floats
+/// \li vectors (2, 3 or 4 components)
+/// \li colors
+/// \li textures
+/// \li transforms (matrices)
+///
+/// The value of the variables can be changed at any time
+/// with the various overloads of the setParameter function:
+/// \code
+/// shader.setParameter("offset", 2.f);
+/// shader.setParameter("point", 0.5f, 0.8f, 0.3f);
+/// shader.setParameter("color", sf::Color(128, 50, 255));
+/// shader.setParameter("matrix", transform); // transform is a sf::Transform
+/// shader.setParameter("overlay", texture); // texture is a sf::Texture
+/// shader.setParameter("texture", sf::Shader::CurrentTexture);
+/// \endcode
+///
+/// The special Shader::CurrentTexture argument maps the
+/// given texture variable to the current texture of the
+/// object being drawn (which cannot be known in advance).
+///
+/// To apply a shader to a drawable, you must pass it as an
+/// additional parameter to the Draw function:
+/// \code
+/// window.draw(sprite, &shader);
+/// \endcode
+///
+/// ... which is in fact just a shortcut for this:
+/// \code
+/// sf::RenderStates states;
+/// states.shader = &shader;
+/// window.draw(sprite, states);
+/// \endcode
+///
+/// In the code above we pass a pointer to the shader, because it may
+/// be null (which means "no shader").
+///
+/// Shaders can be used on any drawable, but some combinations are
+/// not interesting. For example, using a vertex shader on a sf::Sprite
+/// is limited because there are only 4 vertices, the sprite would
+/// have to be subdivided in order to apply wave effects.
+/// Another bad example is a fragment shader with sf::Text: the texture
+/// of the text is not the actual text that you see on screen, it is
+/// a big texture containing all the characters of the font in an
+/// arbitrary order; thus, texture lookups on pixels other than the
+/// current one may not give you the expected result.
+///
+/// Shaders can also be used to apply global post-effects to the
+/// current contents of the target (like the old sf::PostFx class
+/// in SFML 1). This can be done in two different ways:
+/// \li draw everything to a sf::RenderTexture, then draw it to
+/// the main target using the shader
+/// \li draw everything directly to the main target, then use
+/// sf::Texture::update(Window&) to copy its contents to a texture
+/// and draw it to the main target using the shader
+///
+/// The first technique is more optimized because it doesn't involve
+/// retrieving the target's pixels to system memory, but the
+/// second one doesn't impact the rendering process and can be
+/// easily inserted anywhere without impacting all the code.
+///
+/// Like sf::Texture that can be used as a raw OpenGL texture,
+/// sf::Shader can also be used directly as a raw shader for
+/// custom OpenGL geometry.
+/// \code
+/// sf::Shader::bind(&shader);
+/// ... render OpenGL geometry ...
+/// sf::Shader::bind(NULL);
+/// \endcode
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Graphics/Shape.hpp b/include/SFML/Graphics/Shape.hpp index 37fb3c4..bc38775 100755..100644 --- a/include/SFML/Graphics/Shape.hpp +++ b/include/SFML/Graphics/Shape.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,283 +28,318 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
+#include <SFML/Graphics/Export.hpp>
#include <SFML/Graphics/Drawable.hpp>
+#include <SFML/Graphics/Transformable.hpp>
+#include <SFML/Graphics/VertexArray.hpp>
#include <SFML/System/Vector2.hpp>
-#include <vector>
namespace sf
{
////////////////////////////////////////////////////////////
-/// Shape defines a drawable convex shape ; it also defines
-/// helper functions to draw simple shapes like
-/// lines, rectangles, circles, etc.
+/// \brief Base class for textured shapes with outline
+///
////////////////////////////////////////////////////////////
-class SFML_API Shape : public sf::Drawable
+class SFML_GRAPHICS_API Shape : public Drawable, public Transformable
{
public :
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Virtual destructor
///
////////////////////////////////////////////////////////////
- Shape();
+ virtual ~Shape();
////////////////////////////////////////////////////////////
- /// Add a point to the shape
+ /// \brief Change the source texture of the shape
///
- /// \param X, Y : Position of the point
- /// \param Col : Color of the point (white by default)
- /// \param OutlineCol : Outline color of the point (black by default)
+ /// The \a texture argument refers to a texture that must
+ /// exist as long as the shape uses it. Indeed, the shape
+ /// doesn't store its own copy of the texture, but rather keeps
+ /// a pointer to the one that you passed to this function.
+ /// If the source texture is destroyed and the shape tries to
+ /// use it, the behaviour is undefined.
+ /// \a texture can be NULL to disable texturing.
+ /// If \a resetRect is true, the TextureRect property of
+ /// the shape is automatically adjusted to the size of the new
+ /// texture. If it is false, the texture rect is left unchanged.
///
- ////////////////////////////////////////////////////////////
- void AddPoint(float X, float Y, const Color& Col = Color(255, 255, 255), const Color& OutlineCol = Color(0, 0, 0));
-
- ////////////////////////////////////////////////////////////
- /// Add a point to the shape
+ /// \param texture New texture
+ /// \param resetRect Should the texture rect be reset to the size of the new texture?
///
- /// \param Position : Position of the point
- /// \param Col : Color of the point (white by default)
- /// \param OutlineCol : Outline color of the point (black by default)
+ /// \see getTexture, setTextureRect
///
////////////////////////////////////////////////////////////
- void AddPoint(const Vector2f& Position, const Color& Col = Color(255, 255, 255), const Color& OutlineCol = Color(0, 0, 0));
+ void setTexture(const Texture* texture, bool resetRect = false);
////////////////////////////////////////////////////////////
- /// Get the number of points composing the shape
+ /// \brief Set the sub-rectangle of the texture that the shape will display
///
- /// \param Total number of points
+ /// The texture rect is useful when you don't want to display
+ /// the whole texture, but rather a part of it.
+ /// By default, the texture rect covers the entire texture.
///
- ////////////////////////////////////////////////////////////
- unsigned int GetNbPoints() const;
-
- ////////////////////////////////////////////////////////////
- /// Enable or disable filling the shape.
- /// Fill is enabled by default
+ /// \param rect Rectangle defining the region of the texture to display
///
- /// \param Enable : True to enable, false to disable
+ /// \see getTextureRect, setTexture
///
////////////////////////////////////////////////////////////
- void EnableFill(bool Enable);
+ void setTextureRect(const IntRect& rect);
////////////////////////////////////////////////////////////
- /// Enable or disable drawing the shape outline.
- /// Outline is enabled by default
+ /// \brief Set the fill color of the shape
///
- /// \param Enable : True to enable, false to disable
+ /// This color is modulated (multiplied) with the shape's
+ /// texture if any. It can be used to colorize the shape,
+ /// or change its global opacity.
+ /// You can use sf::Color::Transparent to make the inside of
+ /// the shape transparent, and have the outline alone.
+ /// By default, the shape's fill color is opaque white.
///
- ////////////////////////////////////////////////////////////
- void EnableOutline(bool Enable);
-
- ////////////////////////////////////////////////////////////
- /// Set the position of a point
+ /// \param color New color of the shape
///
- /// \param Index : Index of the point, in range [0, GetNbPoints() - 1]
- /// \param Position : New position of the Index-th point
+ /// \see getFillColor, setOutlineColor
///
////////////////////////////////////////////////////////////
- void SetPointPosition(unsigned int Index, const Vector2f& Position);
+ void setFillColor(const Color& color);
////////////////////////////////////////////////////////////
- /// Set the position of a point
+ /// \brief Set the outline color of the shape
+ ///
+ /// By default, the shape's outline color is opaque white.
///
- /// \param Index : Index of the point, in range [0, GetNbPoints() - 1]
- /// \param X : New X coordinate of the Index-th point
- /// \param Y : New Y coordinate of the Index-th point
+ /// \param color New outline color of the shape
+ ///
+ /// \see getOutlineColor, setFillColor
///
////////////////////////////////////////////////////////////
- void SetPointPosition(unsigned int Index, float X, float Y);
+ void setOutlineColor(const Color& color);
////////////////////////////////////////////////////////////
- /// Set the color of a point
+ /// \brief Set the thickness of the shape's outline
+ ///
+ /// Note that negative values are allowed (so that the outline
+ /// expands towards the center of the shape), and using zero
+ /// disables the outline.
+ /// By default, the outline thickness is 0.
+ ///
+ /// \param thickness New outline thickness
///
- /// \param Index : Index of the point, in range [0, GetNbPoints() - 1]
- /// \param Col : New color of the Index-th point
+ /// \see getOutlineThickness
///
////////////////////////////////////////////////////////////
- void SetPointColor(unsigned int Index, const Color& Col);
+ void setOutlineThickness(float thickness);
////////////////////////////////////////////////////////////
- /// Set the outline color of a point
+ /// \brief Get the source texture of the shape
+ ///
+ /// If the shape has no source texture, a NULL pointer is returned.
+ /// The returned pointer is const, which means that you can't
+ /// modify the texture when you retrieve it with this function.
+ ///
+ /// \return Pointer to the shape's texture
///
- /// \param Index : Index of the point, in range [0, GetNbPoints() - 1]
- /// \param OutlineCol : New outline color of the Index-th point
+ /// \see setTexture
///
////////////////////////////////////////////////////////////
- void SetPointOutlineColor(unsigned int Index, const Color& OutlineCol);
+ const Texture* getTexture() const;
////////////////////////////////////////////////////////////
- /// Change the width of the shape outline
+ /// \brief Get the sub-rectangle of the texture displayed by the shape
///
- /// \param Width : New width
+ /// \return Texture rectangle of the shape
+ ///
+ /// \see setTextureRect
///
////////////////////////////////////////////////////////////
- void SetOutlineWidth(float Width);
+ const IntRect& getTextureRect() const;
////////////////////////////////////////////////////////////
- /// Get the position of a point
+ /// \brief Get the fill color of the shape
///
- /// \param Index : Index of the point, in range [0, GetNbPoints() - 1]
+ /// \return Fill color of the shape
///
- /// \return Position of the Index-th point
+ /// \see setFillColor
///
////////////////////////////////////////////////////////////
- const Vector2f& GetPointPosition(unsigned int Index) const;
+ const Color& getFillColor() const;
////////////////////////////////////////////////////////////
- /// Get the color of a point
+ /// \brief Get the outline color of the shape
///
- /// \param Index : Index of the point, in range [0, GetNbPoints() - 1]
+ /// \return Outline color of the shape
///
- /// \return Color of the Index-th point
+ /// \see setOutlineColor
///
////////////////////////////////////////////////////////////
- const Color& GetPointColor(unsigned int Index) const;
+ const Color& getOutlineColor() const;
////////////////////////////////////////////////////////////
- /// Get the outline color of a point
+ /// \brief Get the outline thickness of the shape
///
- /// \param Index : Index of the point, in range [0, GetNbPoints() - 1]
+ /// \return Outline thickness of the shape
///
- /// \return Outline color of the Index-th point
+ /// \see setOutlineThickness
///
////////////////////////////////////////////////////////////
- const Color& GetPointOutlineColor(unsigned int Index) const;
+ float getOutlineThickness() const;
////////////////////////////////////////////////////////////
- /// Get the width of the shape outline
+ /// \brief Get the total number of points of the shape
+ ///
+ /// \return Number of points of the shape
///
- /// \return Current outline width
+ /// \see getPoint
///
////////////////////////////////////////////////////////////
- float GetOutlineWidth() const;
+ virtual unsigned int getPointCount() const = 0;
////////////////////////////////////////////////////////////
- /// Create a shape made of a single line (use floats)
+ /// \brief Get a point of the shape
+ ///
+ /// The result is undefined if \a index is out of the valid range.
+ ///
+ /// \param index Index of the point to get, in range [0 .. getPointCount() - 1]
+ ///
+ /// \return Index-th point of the shape
///
- /// \param P1X, P1Y : Position of the first point
- /// \param P2X, P2Y : Position second point
- /// \param Thickness : Line thickness
- /// \param Col : Color used to draw the line
- /// \param Outline : Outline width (0 by default)
- /// \param OutlineCol : Color used to draw the outline (black by default)
+ /// \see getPointCount
///
////////////////////////////////////////////////////////////
- static Shape Line(float P1X, float P1Y, float P2X, float P2Y, float Thickness, const Color& Col, float Outline = 0.f, const Color& OutlineCol = sf::Color(0, 0, 0));
+ virtual Vector2f getPoint(unsigned int index) const = 0;
////////////////////////////////////////////////////////////
- /// Create a shape made of a single line (use vectors)
+ /// \brief Get the local bounding rectangle of the entity
///
- /// \param P1X, P1Y : Position of the first point
- /// \param P2X, P2Y : Position second point
- /// \param Thickness : Line thickness
- /// \param Col : Color used to draw the line
- /// \param Outline : Outline width (0 by default)
- /// \param OutlineCol : Color used to draw the outline (black by default)
+ /// The returned rectangle is in local coordinates, which means
+ /// that it ignores the transformations (translation, rotation,
+ /// scale, ...) that are applied to the entity.
+ /// In other words, this function returns the bounds of the
+ /// entity in the entity's coordinate system.
+ ///
+ /// \return Local bounding rectangle of the entity
///
////////////////////////////////////////////////////////////
- static Shape Line(const Vector2f& P1, const Vector2f& P2, float Thickness, const Color& Col, float Outline = 0.f, const Color& OutlineCol = sf::Color(0, 0, 0));
+ FloatRect getLocalBounds() const;
////////////////////////////////////////////////////////////
- /// Create a shape made of a single rectangle (use floats)
+ /// \brief Get the global bounding rectangle of the entity
+ ///
+ /// The returned rectangle is in global coordinates, which means
+ /// that it takes in account the transformations (translation,
+ /// rotation, scale, ...) that are applied to the entity.
+ /// In other words, this function returns the bounds of the
+ /// sprite in the global 2D world's coordinate system.
///
- /// \param P1X, P1Y : Position of the first point
- /// \param P2X, P2Y : Position second point
- /// \param Col : Color used to fill the rectangle
- /// \param Outline : Outline width (0 by default)
- /// \param OutlineCol : Color used to draw the outline (black by default)
+ /// \return Global bounding rectangle of the entity
///
////////////////////////////////////////////////////////////
- static Shape Rectangle(float P1X, float P1Y, float P2X, float P2Y, const Color& Col, float Outline = 0.f, const Color& OutlineCol = sf::Color(0, 0, 0));
+ FloatRect getGlobalBounds() const;
+
+protected :
////////////////////////////////////////////////////////////
- /// Create a shape made of a single rectangle (use vectors)
- ///
- /// \param P1 : Position of the first point
- /// \param P2 : Position second point
- /// \param Col : Color used to fill the rectangle
- /// \param Outline : Outline width (0 by default)
- /// \param OutlineCol : Color used to draw the outline (black by default)
+ /// \brief Default constructor
///
////////////////////////////////////////////////////////////
- static Shape Rectangle(const Vector2f& P1, const Vector2f& P2, const Color& Col, float Outline = 0.f, const Color& OutlineCol = sf::Color(0, 0, 0));
+ Shape();
////////////////////////////////////////////////////////////
- /// Create a shape made of a single circle (use floats)
+ /// \brief Recompute the internal geometry of the shape
///
- /// \param X, Y : Position of the center
- /// \param Radius : Radius
- /// \param Col : Color used to fill the circle
- /// \param Outline : Outline width (0 by default)
- /// \param OutlineCol : Color used to draw the outline (black by default)
+ /// This function must be called by the derived class everytime
+ /// the shape's points change (ie. the result of either
+ /// getPointCount or getPoint is different).
///
////////////////////////////////////////////////////////////
- static Shape Circle(float X, float Y, float Radius, const Color& Col, float Outline = 0.f, const Color& OutlineCol = sf::Color(0, 0, 0));
+ void update();
+
+private :
////////////////////////////////////////////////////////////
- /// Create a shape made of a single circle (use vectors)
+ /// \brief Draw the shape to a render target
///
- /// \param Center : Position of the center
- /// \param Radius : Radius
- /// \param Col : Color used to fill the circle
- /// \param Outline : Outline width (0 by default)
- /// \param OutlineCol : Color used to draw the outline (black by default)
+ /// \param target Render target to draw to
+ /// \param states Current render states
///
////////////////////////////////////////////////////////////
- static Shape Circle(const Vector2f& Center, float Radius, const Color& Col, float Outline = 0.f, const Color& OutlineCol = sf::Color(0, 0, 0));
-
-protected :
+ virtual void draw(RenderTarget& target, RenderStates states) const;
////////////////////////////////////////////////////////////
- /// /see Drawable::Render
+ /// \brief Update the fill vertices' color
///
////////////////////////////////////////////////////////////
- virtual void Render(RenderTarget& Target) const;
-
-private :
+ void updateFillColors();
////////////////////////////////////////////////////////////
- /// Compile the shape : compute its center and its outline
+ /// \brief Update the fill vertices' texture coordinates
///
////////////////////////////////////////////////////////////
- void Compile();
+ void updateTexCoords();
////////////////////////////////////////////////////////////
- /// Compute the normal of a given 2D segment
- ///
- /// \param P1 : First point of the segment
- /// \param P2 : Second point of the segment
- /// \param Normal : Calculated normal
- ///
- /// \return False if the normal couldn't be calculated (segment is null)
+ /// \brief Update the outline vertices' position
///
////////////////////////////////////////////////////////////
- static bool ComputeNormal(const Vector2f& P1, const Vector2f& P2, Vector2f& Normal);
+ void updateOutline();
////////////////////////////////////////////////////////////
- /// Defines a simple 2D point
+ /// \brief Update the outline vertices' color
+ ///
////////////////////////////////////////////////////////////
- struct Point
- {
- Point(const Vector2f& Pos = Vector2f(0, 0), const Color& C = Color(255, 255, 255), const Color& OutlineC = Color(255, 255, 255));
+ void updateOutlineColors();
- Vector2f Position; ///< Position
- Vector2f Normal; ///< Extruded normal
- Color Col; ///< Color of the point
- Color OutlineCol; ///< Outline color of the point
- };
+private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- std::vector<Point> myPoints; ///< Points composing the shape
- float myOutline; ///< Outline width
- bool myIsFillEnabled; ///< Should we draw the inside if the shape ?
- bool myIsOutlineEnabled; ///< Should we draw the outline if the shape ?
- bool myIsCompiled; ///< Compiled state of the shape
+ const Texture* m_texture; ///< Texture of the shape
+ IntRect m_textureRect; ///< Rectangle defining the area of the source texture to display
+ Color m_fillColor; ///< Fill color
+ Color m_outlineColor; ///< Outline color
+ float m_outlineThickness; ///< Thickness of the shape's outline
+ VertexArray m_vertices; ///< Vertex array containing the fill geometry
+ VertexArray m_outlineVertices; ///< Vertex array containing the outline geometry
+ FloatRect m_insideBounds; ///< Bounding rectangle of the inside (fill)
+ FloatRect m_bounds; ///< Bounding rectangle of the whole shape (outline + fill)
};
} // namespace sf
#endif // SFML_SHAPE_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Shape
+/// \ingroup graphics
+///
+/// sf::Shape is a drawable class that allows to define and
+/// display a custom convex shape on a render target.
+/// It's only an abstract base, it needs to be specialized for
+/// concrete types of shapes (circle, rectangle, convex polygon,
+/// star, ...).
+///
+/// In addition to the attributes provided by the specialized
+/// shape classes, a shape always has the following attributes:
+/// \li a texture
+/// \li a texture rectangle
+/// \li a fill color
+/// \li an outline color
+/// \li an outline thickness
+///
+/// Each feature is optional, and can be disabled easily:
+/// \li the texture can be null
+/// \li the fill/outline colors can be sf::Color::Transparent
+/// \li the outline thickness can be zero
+///
+/// You can write your own derived shape class, there are only
+/// two virtual functions to override:
+/// \li getPointCount must return the number of points of the shape
+/// \li getPoint must return the points of the shape
+///
+/// \see sf::RectangleShape, sf::CircleShape, sf::ConvexShape, sf::Transformable
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Graphics/Sprite.hpp b/include/SFML/Graphics/Sprite.hpp index 9d47bb4..954881d 100755..100644 --- a/include/SFML/Graphics/Sprite.hpp +++ b/include/SFML/Graphics/Sprite.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,149 +28,250 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/System/Resource.hpp>
+#include <SFML/Graphics/Export.hpp>
#include <SFML/Graphics/Drawable.hpp>
+#include <SFML/Graphics/Transformable.hpp>
+#include <SFML/Graphics/Vertex.hpp>
#include <SFML/Graphics/Rect.hpp>
namespace sf
{
-class Image;
+class Texture;
////////////////////////////////////////////////////////////
-/// Sprite defines a sprite : texture, transformations,
-/// color, and draw on screen
+/// \brief Drawable representation of a texture, with its
+/// own transformations, color, etc.
+///
////////////////////////////////////////////////////////////
-class SFML_API Sprite : public Drawable
+class SFML_GRAPHICS_API Sprite : public Drawable, public Transformable
{
public :
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
+ ///
+ /// Creates an empty sprite with no source texture.
///
////////////////////////////////////////////////////////////
Sprite();
////////////////////////////////////////////////////////////
- /// Construct the sprite from a source image
+ /// \brief Construct the sprite from a source texture
+ ///
+ /// \param texture Source texture
///
- /// \param Img : Image of the sprite
- /// \param Position : Position of the sprite (0, 0 by default)
- /// \param Scale : Scale factor (1, 1 by default)
- /// \param Rotation : Orientation, in degrees (0 by default)
- /// \param Col : Color of the sprite (white by default)
+ /// \see setTexture
///
////////////////////////////////////////////////////////////
- explicit Sprite(const Image& Img, const Vector2f& Position = Vector2f(0, 0), const Vector2f& Scale = Vector2f(1, 1), float Rotation = 0.f, const Color& Col = Color(255, 255, 255, 255));
+ explicit Sprite(const Texture& texture);
////////////////////////////////////////////////////////////
- /// Change the image of the sprite
+ /// \brief Construct the sprite from a sub-rectangle of a source texture
///
- /// \param Img : New image
+ /// \param texture Source texture
+ /// \param rectangle Sub-rectangle of the texture to assign to the sprite
+ ///
+ /// \see setTexture, setTextureRect
///
////////////////////////////////////////////////////////////
- void SetImage(const Image& Img);
+ Sprite(const Texture& texture, const IntRect& rectangle);
////////////////////////////////////////////////////////////
- /// Set the sub-rectangle of the sprite inside the source image.
- /// By default, the subrect covers the entire source image
+ /// \brief Change the source texture of the sprite
+ ///
+ /// The \a texture argument refers to a texture that must
+ /// exist as long as the sprite uses it. Indeed, the sprite
+ /// doesn't store its own copy of the texture, but rather keeps
+ /// a pointer to the one that you passed to this function.
+ /// If the source texture is destroyed and the sprite tries to
+ /// use it, the behaviour is undefined.
+ /// If \a resetRect is true, the TextureRect property of
+ /// the sprite is automatically adjusted to the size of the new
+ /// texture. If it is false, the texture rect is left unchanged.
///
- /// \param SubRect : New sub-rectangle
+ /// \param texture New texture
+ /// \param resetRect Should the texture rect be reset to the size of the new texture?
+ ///
+ /// \see getTexture, setTextureRect
///
////////////////////////////////////////////////////////////
- void SetSubRect(const IntRect& SubRect);
+ void setTexture(const Texture& texture, bool resetRect = false);
////////////////////////////////////////////////////////////
- /// Resize the sprite (by changing its scale factors) (take 2 values).
- /// The default size is defined by the subrect
+ /// \brief Set the sub-rectangle of the texture that the sprite will display
+ ///
+ /// The texture rect is useful when you don't want to display
+ /// the whole texture, but rather a part of it.
+ /// By default, the texture rect covers the entire texture.
+ ///
+ /// \param rectangle Rectangle defining the region of the texture to display
///
- /// \param Width : New width (must be strictly positive)
- /// \param Height : New height (must be strictly positive)
+ /// \see getTextureRect, setTexture
///
////////////////////////////////////////////////////////////
- void Resize(float Width, float Height);
+ void setTextureRect(const IntRect& rectangle);
////////////////////////////////////////////////////////////
- /// Resize the sprite (by changing its scale factors) (take a 2D vector).
- /// The default size is defined by the subrect
+ /// \brief Set the global color of the sprite
///
- /// \param Size : New size (both coordinates must be strictly positive)
+ /// This color is modulated (multiplied) with the sprite's
+ /// texture. It can be used to colorize the sprite, or change
+ /// its global opacity.
+ /// By default, the sprite's color is opaque white.
+ ///
+ /// \param color New color of the sprite
+ ///
+ /// \see getColor
///
////////////////////////////////////////////////////////////
- void Resize(const Vector2f& Size);
+ void setColor(const Color& color);
////////////////////////////////////////////////////////////
- /// Flip the sprite horizontally
+ /// \brief Get the source texture of the sprite
+ ///
+ /// If the sprite has no source texture, a NULL pointer is returned.
+ /// The returned pointer is const, which means that you can't
+ /// modify the texture when you retrieve it with this function.
+ ///
+ /// \return Pointer to the sprite's texture
///
- /// \param Flipped : True to flip the sprite
+ /// \see setTexture
///
////////////////////////////////////////////////////////////
- void FlipX(bool Flipped);
+ const Texture* getTexture() const;
////////////////////////////////////////////////////////////
- /// Flip the sprite vertically
+ /// \brief Get the sub-rectangle of the texture displayed by the sprite
///
- /// \param Flipped : True to flip the sprite
+ /// \return Texture rectangle of the sprite
+ ///
+ /// \see setTextureRect
///
////////////////////////////////////////////////////////////
- void FlipY(bool Flipped);
+ const IntRect& getTextureRect() const;
////////////////////////////////////////////////////////////
- /// Get the source image of the sprite
+ /// \brief Get the global color of the sprite
+ ///
+ /// \return Global color of the sprite
///
- /// \return Pointer to the image (can be NULL)
+ /// \see setColor
///
////////////////////////////////////////////////////////////
- const Image* GetImage() const;
+ const Color& getColor() const;
////////////////////////////////////////////////////////////
- /// Get the sub-rectangle of the sprite inside the source image
+ /// \brief Get the local bounding rectangle of the entity
+ ///
+ /// The returned rectangle is in local coordinates, which means
+ /// that it ignores the transformations (translation, rotation,
+ /// scale, ...) that are applied to the entity.
+ /// In other words, this function returns the bounds of the
+ /// entity in the entity's coordinate system.
///
- /// \return Sub-rectangle
+ /// \return Local bounding rectangle of the entity
///
////////////////////////////////////////////////////////////
- const IntRect& GetSubRect() const;
+ FloatRect getLocalBounds() const;
////////////////////////////////////////////////////////////
- /// Get the sprite size
+ /// \brief Get the global bounding rectangle of the entity
///
- /// \return Size of the sprite
+ /// The returned rectangle is in global coordinates, which means
+ /// that it takes in account the transformations (translation,
+ /// rotation, scale, ...) that are applied to the entity.
+ /// In other words, this function returns the bounds of the
+ /// sprite in the global 2D world's coordinate system.
+ ///
+ /// \return Global bounding rectangle of the entity
///
////////////////////////////////////////////////////////////
- Vector2f GetSize() const;
+ FloatRect getGlobalBounds() const;
+
+private :
////////////////////////////////////////////////////////////
- /// Get the color of a given pixel in the sprite
- /// (point is in local coordinates)
- ///
- /// \param X : X coordinate of the pixel to get
- /// \param Y : Y coordinate of the pixel to get
+ /// \brief Draw the sprite to a render target
///
- /// \return Color of pixel (X, Y)
+ /// \param target Render target to draw to
+ /// \param states Current render states
///
////////////////////////////////////////////////////////////
- Color GetPixel(unsigned int X, unsigned int Y) const;
-
-protected :
+ virtual void draw(RenderTarget& target, RenderStates states) const;
////////////////////////////////////////////////////////////
- /// /see Drawable::Render
+ /// \brief Update the vertices' positions
///
////////////////////////////////////////////////////////////
- virtual void Render(RenderTarget& Target) const;
+ void updatePositions();
-private :
+ ////////////////////////////////////////////////////////////
+ /// \brief Update the vertices' texture coordinates
+ ///
+ ////////////////////////////////////////////////////////////
+ void updateTexCoords();
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- ResourcePtr<Image> myImage; ///< Image used to draw the sprite
- IntRect mySubRect; ///< Sub-rectangle of source image to assign to the sprite
- bool myIsFlippedX; ///< Is the sprite flipped on the X axis ?
- bool myIsFlippedY; ///< Is the sprite flipped on the Y axis ?
+ Vertex m_vertices[4]; ///< Vertices defining the sprite's geometry
+ const Texture* m_texture; ///< Texture of the sprite
+ IntRect m_textureRect; ///< Rectangle defining the area of the source texture to display
};
} // namespace sf
#endif // SFML_SPRITE_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Sprite
+/// \ingroup graphics
+///
+/// sf::Sprite is a drawable class that allows to easily display
+/// a texture (or a part of it) on a render target.
+///
+/// It inherits all the functions from sf::Transformable:
+/// position, rotation, scale, origin. It also adds sprite-specific
+/// properties such as the texture to use, the part of it to display,
+/// and some convenience functions to change the overall color of the
+/// sprite, or to get its bounding rectangle.
+///
+/// sf::Sprite works in combination with the sf::Texture class, which
+/// loads and provides the pixel data of a given texture.
+///
+/// The separation of sf::Sprite and sf::Texture allows more flexibility
+/// and better performances: indeed a sf::Texture is a heavy resource,
+/// and any operation on it is slow (often too slow for real-time
+/// applications). On the other side, a sf::Sprite is a lightweight
+/// object which can use the pixel data of a sf::Texture and draw
+/// it with its own transformation/color/blending attributes.
+///
+/// It is important to note that the sf::Sprite instance doesn't
+/// copy the texture that it uses, it only keeps a reference to it.
+/// Thus, a sf::Texture must not be destroyed while it is
+/// used by a sf::Sprite (i.e. never write a function that
+/// uses a local sf::Texture instance for creating a sprite).
+///
+/// Usage example:
+/// \code
+/// // Declare and load a texture
+/// sf::Texture texture;
+/// texture.loadFromFile("texture.png");
+///
+/// // Create a sprite
+/// sf::Sprite sprite;
+/// sprite.setTexture(texture);
+/// sprite.setTextureRect(sf::IntRect(10, 10, 50, 30));
+/// sprite.setColor(sf::Color(255, 255, 255, 200));
+/// sprite.setPosition(100, 25);
+///
+/// // Draw it
+/// window.draw(sprite);
+/// \endcode
+///
+/// \see sf::Texture, sf::Transformable
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Graphics/String.hpp b/include/SFML/Graphics/String.hpp deleted file mode 100755 index b0ca81b..0000000 --- a/include/SFML/Graphics/String.hpp +++ /dev/null @@ -1,191 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_STRING_HPP
-#define SFML_STRING_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/System/Resource.hpp>
-#include <SFML/System/Unicode.hpp>
-#include <SFML/Graphics/Drawable.hpp>
-#include <SFML/Graphics/Font.hpp>
-#include <SFML/Graphics/Rect.hpp>
-#include <string>
-
-
-namespace sf
-{
-////////////////////////////////////////////////////////////
-/// String defines a graphical 2D text, that can be drawn on screen
-////////////////////////////////////////////////////////////
-class SFML_API String : public Drawable
-{
-public :
-
- ////////////////////////////////////////////////////////////
- /// Enumerate the string drawing styles
- ////////////////////////////////////////////////////////////
- enum Style
- {
- Regular = 0, ///< Regular characters, no style
- Bold = 1 << 0, ///< Characters are bold
- Italic = 1 << 1, ///< Characters are in italic
- Underlined = 1 << 2 ///< Characters are underlined
- };
-
- ////////////////////////////////////////////////////////////
- /// Default constructor
- ///
- ////////////////////////////////////////////////////////////
- String();
-
- ////////////////////////////////////////////////////////////
- /// Construct the string from any kind of text
- ///
- /// \param Text : Text assigned to the string
- /// \param Font : Font used to draw the string (SFML built-in font by default)
- /// \param Size : Characters size (30 by default)
- ///
- ////////////////////////////////////////////////////////////
- explicit String(const Unicode::Text& Text, const Font& CharFont = Font::GetDefaultFont(), float Size = 30.f);
-
- ////////////////////////////////////////////////////////////
- /// Set the text (from any kind of string)
- ///
- /// \param Text : New text
- ///
- ////////////////////////////////////////////////////////////
- void SetText(const Unicode::Text& Text);
-
- ////////////////////////////////////////////////////////////
- /// Set the font of the string
- ///
- /// \param Font : Font to use
- ///
- ////////////////////////////////////////////////////////////
- void SetFont(const Font& CharFont);
-
- ////////////////////////////////////////////////////////////
- /// Set the size of the string
- /// The default size is 30
- ///
- /// \param Size : New size, in pixels
- ///
- ////////////////////////////////////////////////////////////
- void SetSize(float Size);
-
- ////////////////////////////////////////////////////////////
- /// Set the style of the text
- /// The default style is Regular
- ///
- /// \param TextStyle : New text style, (combination of Style enum values)
- ///
- ////////////////////////////////////////////////////////////
- void SetStyle(unsigned long TextStyle);
-
- ////////////////////////////////////////////////////////////
- /// Get the text (the returned text can be converted implicitely to any kind of string)
- ///
- /// \return String's text
- ///
- ////////////////////////////////////////////////////////////
- const Unicode::Text& GetText() const;
-
- ////////////////////////////////////////////////////////////
- /// Get the font used by the string
- ///
- /// \return Font used
- ///
- ////////////////////////////////////////////////////////////
- const Font& GetFont() const;
-
- ////////////////////////////////////////////////////////////
- /// Get the size of the characters
- ///
- /// \return Size of the characters
- ///
- ////////////////////////////////////////////////////////////
- float GetSize() const;
-
- ////////////////////////////////////////////////////////////
- /// Get the style of the text
- ///
- /// \return Current string style (combination of Style enum values)
- ///
- ////////////////////////////////////////////////////////////
- unsigned long GetStyle() const;
-
- ////////////////////////////////////////////////////////////
- /// Return the visual position of the Index-th character of the string,
- /// in coordinates relative to the string
- /// (note : translation, center, rotation and scale are not applied)
- ///
- /// \param Index : Index of the character
- ///
- /// \return Position of the Index-th character (end of string if Index is out of range)
- ///
- ////////////////////////////////////////////////////////////
- sf::Vector2f GetCharacterPos(std::size_t Index) const;
-
- ////////////////////////////////////////////////////////////
- /// Get the string rectangle on screen
- ///
- /// \return Rectangle contaning the string in screen coordinates
- ///
- ////////////////////////////////////////////////////////////
- FloatRect GetRect() const;
-
-protected :
-
- ////////////////////////////////////////////////////////////
- /// /see Drawable::Render
- ///
- ////////////////////////////////////////////////////////////
- virtual void Render(RenderTarget& Target) const;
-
-private :
-
- ////////////////////////////////////////////////////////////
- /// Recompute the bounding rectangle of the text
- ///
- ////////////////////////////////////////////////////////////
- void RecomputeRect();
-
- ////////////////////////////////////////////////////////////
- // Member data
- ////////////////////////////////////////////////////////////
- Unicode::Text myText; ///< Text to display
- ResourcePtr<Font> myFont; ///< Font used to display the string
- float mySize; ///< Size of the characters
- unsigned long myStyle; ///< Text style (see Style enum)
- FloatRect myBaseRect; ///< Bounding rectangle of the text in object coordinates
- bool myNeedRectUpdate; ///< Does the bounding rect need an update ?
-};
-
-} // namespace sf
-
-
-#endif // SFML_STRING_HPP
diff --git a/include/SFML/Graphics/Text.hpp b/include/SFML/Graphics/Text.hpp new file mode 100644 index 0000000..04abd24 --- /dev/null +++ b/include/SFML/Graphics/Text.hpp @@ -0,0 +1,351 @@ +////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+// you must not claim that you wrote the original software.
+// If you use this software in a product, an acknowledgment
+// in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+// and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_TEXT_HPP
+#define SFML_TEXT_HPP
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Graphics/Export.hpp>
+#include <SFML/Graphics/Drawable.hpp>
+#include <SFML/Graphics/Transformable.hpp>
+#include <SFML/Graphics/Font.hpp>
+#include <SFML/Graphics/Rect.hpp>
+#include <SFML/Graphics/VertexArray.hpp>
+#include <SFML/System/String.hpp>
+#include <string>
+#include <vector>
+
+
+namespace sf
+{
+////////////////////////////////////////////////////////////
+/// \brief Graphical text that can be drawn to a render target
+///
+////////////////////////////////////////////////////////////
+class SFML_GRAPHICS_API Text : public Drawable, public Transformable
+{
+public :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Enumeration of the string drawing styles
+ ///
+ ////////////////////////////////////////////////////////////
+ enum Style
+ {
+ Regular = 0, ///< Regular characters, no style
+ Bold = 1 << 0, ///< Bold characters
+ Italic = 1 << 1, ///< Italic characters
+ Underlined = 1 << 2 ///< Underlined characters
+ };
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Default constructor
+ ///
+ /// Creates an empty text.
+ ///
+ ////////////////////////////////////////////////////////////
+ Text();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Construct the text from a string, font and size
+ ///
+ /// \param string Text assigned to the string
+ /// \param font Font used to draw the string
+ /// \param characterSize Base size of characters, in pixels
+ ///
+ ////////////////////////////////////////////////////////////
+ Text(const String& string, const Font& font, unsigned int characterSize = 30);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Set the text's string
+ ///
+ /// The \a string argument is a sf::String, which can
+ /// automatically be constructed from standard string types.
+ /// So, the following calls are all valid:
+ /// \code
+ /// text.setString("hello");
+ /// text.setString(L"hello");
+ /// text.setString(std::string("hello"));
+ /// text.setString(std::wstring(L"hello"));
+ /// \endcode
+ /// A text's string is empty by default.
+ ///
+ /// \param string New string
+ ///
+ /// \see getString
+ ///
+ ////////////////////////////////////////////////////////////
+ void setString(const String& string);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Set the text's font
+ ///
+ /// The \a font argument refers to a font that must
+ /// exist as long as the text uses it. Indeed, the text
+ /// doesn't store its own copy of the font, but rather keeps
+ /// a pointer to the one that you passed to this function.
+ /// If the font is destroyed and the text tries to
+ /// use it, the behaviour is undefined.
+ ///
+ /// \param font New font
+ ///
+ /// \see getFont
+ ///
+ ////////////////////////////////////////////////////////////
+ void setFont(const Font& font);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Set the character size
+ ///
+ /// The default size is 30.
+ ///
+ /// \param size New character size, in pixels
+ ///
+ /// \see getCharacterSize
+ ///
+ ////////////////////////////////////////////////////////////
+ void setCharacterSize(unsigned int size);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Set the text's style
+ ///
+ /// You can pass a combination of one or more styles, for
+ /// example sf::Text::Bold | sf::Text::Italic.
+ /// The default style is sf::Text::Regular.
+ ///
+ /// \param style New style
+ ///
+ /// \see getStyle
+ ///
+ ////////////////////////////////////////////////////////////
+ void setStyle(Uint32 style);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Set the global color of the text
+ ///
+ /// By default, the text's color is opaque white.
+ ///
+ /// \param color New color of the text
+ ///
+ /// \see getColor
+ ///
+ ////////////////////////////////////////////////////////////
+ void setColor(const Color& color);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the text's string
+ ///
+ /// The returned string is a sf::String, which can automatically
+ /// be converted to standard string types. So, the following
+ /// lines of code are all valid:
+ /// \code
+ /// sf::String s1 = text.getString();
+ /// std::string s2 = text.getString();
+ /// std::wstring s3 = text.getString();
+ /// \endcode
+ ///
+ /// \return Text's string
+ ///
+ /// \see setString
+ ///
+ ////////////////////////////////////////////////////////////
+ const String& getString() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the text's font
+ ///
+ /// If the text has no font attached, a NULL pointer is returned.
+ /// The returned reference is const, which means that you
+ /// cannot modify the font when you get it from this function.
+ ///
+ /// \return Pointer to the text's font
+ ///
+ /// \see setFont
+ ///
+ ////////////////////////////////////////////////////////////
+ const Font* getFont() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the character size
+ ///
+ /// \return Size of the characters, in pixels
+ ///
+ /// \see setCharacterSize
+ ///
+ ////////////////////////////////////////////////////////////
+ unsigned int getCharacterSize() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the text's style
+ ///
+ /// \return Text's style
+ ///
+ /// \see setStyle
+ ///
+ ////////////////////////////////////////////////////////////
+ Uint32 getStyle() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the global color of the text
+ ///
+ /// \return Global color of the text
+ ///
+ /// \see setColor
+ ///
+ ////////////////////////////////////////////////////////////
+ const Color& getColor() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Return the position of the \a index-th character
+ ///
+ /// This function computes the visual position of a character
+ /// from its index in the string. The returned position is
+ /// in global coordinates (translation, rotation, scale and
+ /// origin are applied).
+ /// If \a index is out of range, the position of the end of
+ /// the string is returned.
+ ///
+ /// \param index Index of the character
+ ///
+ /// \return Position of the character
+ ///
+ ////////////////////////////////////////////////////////////
+ Vector2f findCharacterPos(std::size_t index) const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the local bounding rectangle of the entity
+ ///
+ /// The returned rectangle is in local coordinates, which means
+ /// that it ignores the transformations (translation, rotation,
+ /// scale, ...) that are applied to the entity.
+ /// In other words, this function returns the bounds of the
+ /// entity in the entity's coordinate system.
+ ///
+ /// \return Local bounding rectangle of the entity
+ ///
+ ////////////////////////////////////////////////////////////
+ FloatRect getLocalBounds() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the global bounding rectangle of the entity
+ ///
+ /// The returned rectangle is in global coordinates, which means
+ /// that it takes in account the transformations (translation,
+ /// rotation, scale, ...) that are applied to the entity.
+ /// In other words, this function returns the bounds of the
+ /// sprite in the global 2D world's coordinate system.
+ ///
+ /// \return Global bounding rectangle of the entity
+ ///
+ ////////////////////////////////////////////////////////////
+ FloatRect getGlobalBounds() const;
+
+private :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Draw the text to a render target
+ ///
+ /// \param target Render target to draw to
+ /// \param states Current render states
+ ///
+ ////////////////////////////////////////////////////////////
+ virtual void draw(RenderTarget& target, RenderStates states) const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Update the text's geometry
+ ///
+ ////////////////////////////////////////////////////////////
+ void updateGeometry();
+
+ ////////////////////////////////////////////////////////////
+ // Member data
+ ////////////////////////////////////////////////////////////
+ String m_string; ///< String to display
+ const Font* m_font; ///< Font used to display the string
+ unsigned int m_characterSize; ///< Base size of characters, in pixels
+ Uint32 m_style; ///< Text style (see Style enum)
+ Color m_color; ///< Text color
+ VertexArray m_vertices; ///< Vertex array containing the text's geometry
+ FloatRect m_bounds; ///< Bounding rectangle of the text (in local coordinates)
+};
+
+} // namespace sf
+
+
+#endif // SFML_TEXT_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Text
+/// \ingroup graphics
+///
+/// sf::Text is a drawable class that allows to easily display
+/// some text with custom style and color on a render target.
+///
+/// It inherits all the functions from sf::Transformable:
+/// position, rotation, scale, origin. It also adds text-specific
+/// properties such as the font to use, the character size,
+/// the font style (bold, italic, underlined), the global color
+/// and the text to display of course.
+/// It also provides convenience functions to calculate the
+/// graphical size of the text, or to get the global position
+/// of a given character.
+///
+/// sf::Text works in combination with the sf::Font class, which
+/// loads and provides the glyphs (visual characters) of a given font.
+///
+/// The separation of sf::Font and sf::Text allows more flexibility
+/// and better performances: indeed a sf::Font is a heavy resource,
+/// and any operation on it is slow (often too slow for real-time
+/// applications). On the other side, a sf::Text is a lightweight
+/// object which can combine the glyphs data and metrics of a sf::Font
+/// to display any text on a render target.
+///
+/// It is important to note that the sf::Text instance doesn't
+/// copy the font that it uses, it only keeps a reference to it.
+/// Thus, a sf::Font must not be destructed while it is
+/// used by a sf::Text (i.e. never write a function that
+/// uses a local sf::Font instance for creating a text).
+///
+/// Usage example:
+/// \code
+/// // Declare and load a font
+/// sf::Font font;
+/// font.loadFromFile("arial.ttf");
+///
+/// // Create a text
+/// sf::Text text("hello", font);
+/// text.setCharacterSize(30);
+/// text.setStyle(sf::Text::Bold);
+/// text.setColor(sf::Color::Red);
+///
+/// // Draw it
+/// window.draw(text);
+/// \endcode
+///
+/// \see sf::Font, sf::Transformable
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Graphics/Texture.hpp b/include/SFML/Graphics/Texture.hpp new file mode 100644 index 0000000..ba61f54 --- /dev/null +++ b/include/SFML/Graphics/Texture.hpp @@ -0,0 +1,602 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_TEXTURE_HPP +#define SFML_TEXTURE_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.hpp> +#include <SFML/Graphics/Image.hpp> +#include <SFML/Window/GlResource.hpp> + + +namespace sf +{ +class Window; +class RenderTarget; +class RenderTexture; +class InputStream; + +//////////////////////////////////////////////////////////// +/// \brief Image living on the graphics card that can be used for drawing +/// +//////////////////////////////////////////////////////////// +class SFML_GRAPHICS_API Texture : GlResource +{ +public : + + //////////////////////////////////////////////////////////// + /// \brief Types of texture coordinates that can be used for rendering + /// + //////////////////////////////////////////////////////////// + enum CoordinateType + { + Normalized, ///< Texture coordinates in range [0 .. 1] + Pixels ///< Texture coordinates in range [0 .. size] + }; + +public : + + //////////////////////////////////////////////////////////// + /// \brief Default constructor + /// + /// Creates an empty texture. + /// + //////////////////////////////////////////////////////////// + Texture(); + + //////////////////////////////////////////////////////////// + /// \brief Copy constructor + /// + /// \param copy instance to copy + /// + //////////////////////////////////////////////////////////// + Texture(const Texture& copy); + + //////////////////////////////////////////////////////////// + /// \brief Destructor + /// + //////////////////////////////////////////////////////////// + ~Texture(); + + //////////////////////////////////////////////////////////// + /// \brief Create the texture + /// + /// If this function fails, the texture is left unchanged. + /// + /// \param width Width of the texture + /// \param height Height of the texture + /// + /// \return True if creation was successful + /// + //////////////////////////////////////////////////////////// + bool create(unsigned int width, unsigned int height); + + //////////////////////////////////////////////////////////// + /// \brief Load the texture from a file on disk + /// + /// This function is a shortcut for the following code: + /// \code + /// sf::Image image; + /// image.loadFromFile(filename); + /// texture.loadFromImage(image, area); + /// \endcode + /// + /// The \a area argument can be used to load only a sub-rectangle + /// of the whole image. If you want the entire image then leave + /// the default value (which is an empty IntRect). + /// If the \a area rectangle crosses the bounds of the image, it + /// is adjusted to fit the image size. + /// + /// The maximum size for a texture depends on the graphics + /// driver and can be retrieved with the getMaximumSize function. + /// + /// If this function fails, the texture is left unchanged. + /// + /// \param filename Path of the image file to load + /// \param area Area of the image to load + /// + /// \return True if loading was successful + /// + /// \see loadFromMemory, loadFromStream, loadFromImage + /// + //////////////////////////////////////////////////////////// + bool loadFromFile(const std::string& filename, const IntRect& area = IntRect()); + + //////////////////////////////////////////////////////////// + /// \brief Load the texture from a file in memory + /// + /// This function is a shortcut for the following code: + /// \code + /// sf::Image image; + /// image.loadFromMemory(data, size); + /// texture.loadFromImage(image, area); + /// \endcode + /// + /// The \a area argument can be used to load only a sub-rectangle + /// of the whole image. If you want the entire image then leave + /// the default value (which is an empty IntRect). + /// If the \a area rectangle crosses the bounds of the image, it + /// is adjusted to fit the image size. + /// + /// The maximum size for a texture depends on the graphics + /// driver and can be retrieved with the getMaximumSize function. + /// + /// If this function fails, the texture is left unchanged. + /// + /// \param data Pointer to the file data in memory + /// \param size Size of the data to load, in bytes + /// \param area Area of the image to load + /// + /// \return True if loading was successful + /// + /// \see loadFromFile, loadFromStream, loadFromImage + /// + //////////////////////////////////////////////////////////// + bool loadFromMemory(const void* data, std::size_t size, const IntRect& area = IntRect()); + + //////////////////////////////////////////////////////////// + /// \brief Load the texture from a custom stream + /// + /// This function is a shortcut for the following code: + /// \code + /// sf::Image image; + /// image.loadFromStream(stream); + /// texture.loadFromImage(image, area); + /// \endcode + /// + /// The \a area argument can be used to load only a sub-rectangle + /// of the whole image. If you want the entire image then leave + /// the default value (which is an empty IntRect). + /// If the \a area rectangle crosses the bounds of the image, it + /// is adjusted to fit the image size. + /// + /// The maximum size for a texture depends on the graphics + /// driver and can be retrieved with the getMaximumSize function. + /// + /// If this function fails, the texture is left unchanged. + /// + /// \param stream Source stream to read from + /// \param area Area of the image to load + /// + /// \return True if loading was successful + /// + /// \see loadFromFile, loadFromMemory, loadFromImage + /// + //////////////////////////////////////////////////////////// + bool loadFromStream(sf::InputStream& stream, const IntRect& area = IntRect()); + + //////////////////////////////////////////////////////////// + /// \brief Load the texture from an image + /// + /// The \a area argument can be used to load only a sub-rectangle + /// of the whole image. If you want the entire image then leave + /// the default value (which is an empty IntRect). + /// If the \a area rectangle crosses the bounds of the image, it + /// is adjusted to fit the image size. + /// + /// The maximum size for a texture depends on the graphics + /// driver and can be retrieved with the getMaximumSize function. + /// + /// If this function fails, the texture is left unchanged. + /// + /// \param image Image to load into the texture + /// \param area Area of the image to load + /// + /// \return True if loading was successful + /// + /// \see loadFromFile, loadFromMemory + /// + //////////////////////////////////////////////////////////// + bool loadFromImage(const Image& image, const IntRect& area = IntRect()); + + //////////////////////////////////////////////////////////// + /// \brief Return the size of the texture + /// + /// \return Size in pixels + /// + //////////////////////////////////////////////////////////// + Vector2u getSize() const; + + //////////////////////////////////////////////////////////// + /// \brief Copy the texture pixels to an image + /// + /// This function performs a slow operation that downloads + /// the texture's pixels from the graphics card and copies + /// them to a new image, potentially applying transformations + /// to pixels if necessary (texture may be padded or flipped). + /// + /// \return Image containing the texture's pixels + /// + /// \see loadFromImage + /// + //////////////////////////////////////////////////////////// + Image copyToImage() const; + + //////////////////////////////////////////////////////////// + /// \brief Update the whole texture from an array of pixels + /// + /// The \a pixel array is assumed to have the same size as + /// the \a area rectangle, and to contain 32-bits RGBA pixels. + /// + /// No additional check is performed on the size of the pixel + /// array, passing invalid arguments will lead to an undefined + /// behaviour. + /// + /// This function does nothing if \a pixels is null or if the + /// texture was not previously created. + /// + /// \param pixels Array of pixels to copy to the texture + /// + //////////////////////////////////////////////////////////// + void update(const Uint8* pixels); + + //////////////////////////////////////////////////////////// + /// \brief Update a part of the texture from an array of pixels + /// + /// The size of the \a pixel array must match the \a width and + /// \a height arguments, and it must contain 32-bits RGBA pixels. + /// + /// No additional check is performed on the size of the pixel + /// array or the bounds of the area to update, passing invalid + /// arguments will lead to an undefined behaviour. + /// + /// This function does nothing if \a pixels is null or if the + /// texture was not previously created. + /// + /// \param pixels Array of pixels to copy to the texture + /// \param width Width of the pixel region contained in \a pixels + /// \param height Height of the pixel region contained in \a pixels + /// \param x X offset in the texture where to copy the source pixels + /// \param y Y offset in the texture where to copy the source pixels + /// + //////////////////////////////////////////////////////////// + void update(const Uint8* pixels, unsigned int width, unsigned int height, unsigned int x, unsigned int y); + + //////////////////////////////////////////////////////////// + /// \brief Update the texture from an image + /// + /// Although the source image can be smaller than the texture, + /// this function is usually used for updating the whole texture. + /// The other overload, which has (x, y) additional arguments, + /// is more convenient for updating a sub-area of the texture. + /// + /// No additional check is performed on the size of the image, + /// passing an image bigger than the texture will lead to an + /// undefined behaviour. + /// + /// This function does nothing if the texture was not + /// previously created. + /// + /// \param image Image to copy to the texture + /// + //////////////////////////////////////////////////////////// + void update(const Image& image); + + //////////////////////////////////////////////////////////// + /// \brief Update a part of the texture from an image + /// + /// No additional check is performed on the size of the image, + /// passing an invalid combination of image size and offset + /// will lead to an undefined behaviour. + /// + /// This function does nothing if the texture was not + /// previously created. + /// + /// \param image Image to copy to the texture + /// \param x X offset in the texture where to copy the source image + /// \param y Y offset in the texture where to copy the source image + /// + //////////////////////////////////////////////////////////// + void update(const Image& image, unsigned int x, unsigned int y); + + //////////////////////////////////////////////////////////// + /// \brief Update the texture from the contents of a window + /// + /// Although the source window can be smaller than the texture, + /// this function is usually used for updating the whole texture. + /// The other overload, which has (x, y) additional arguments, + /// is more convenient for updating a sub-area of the texture. + /// + /// No additional check is performed on the size of the window, + /// passing a window bigger than the texture will lead to an + /// undefined behaviour. + /// + /// This function does nothing if either the texture or the window + /// was not previously created. + /// + /// \param window Window to copy to the texture + /// + //////////////////////////////////////////////////////////// + void update(const Window& window); + + //////////////////////////////////////////////////////////// + /// \brief Update a part of the texture from the contents of a window + /// + /// No additional check is performed on the size of the window, + /// passing an invalid combination of window size and offset + /// will lead to an undefined behaviour. + /// + /// This function does nothing if either the texture or the window + /// was not previously created. + /// + /// \param window Window to copy to the texture + /// \param x X offset in the texture where to copy the source window + /// \param y Y offset in the texture where to copy the source window + /// + //////////////////////////////////////////////////////////// + void update(const Window& window, unsigned int x, unsigned int y); + + //////////////////////////////////////////////////////////// + /// \brief Enable or disable the smooth filter + /// + /// When the filter is activated, the texture appears smoother + /// so that pixels are less noticeable. However if you want + /// the texture to look exactly the same as its source file, + /// you should leave it disabled. + /// The smooth filter is disabled by default. + /// + /// \param smooth True to enable smoothing, false to disable it + /// + /// \see isSmooth + /// + //////////////////////////////////////////////////////////// + void setSmooth(bool smooth); + + //////////////////////////////////////////////////////////// + /// \brief Tell whether the smooth filter is enabled or not + /// + /// \return True if smoothing is enabled, false if it is disabled + /// + /// \see setSmooth + /// + //////////////////////////////////////////////////////////// + bool isSmooth() const; + + //////////////////////////////////////////////////////////// + /// \brief Enable or disable repeating + /// + /// Repeating is involved when using texture coordinates + /// outside the texture rectangle [0, 0, width, height]. + /// In this case, if repeat mode is enabled, the whole texture + /// will be repeated as many times as needed to reach the + /// coordinate (for example, if the X texture coordinate is + /// 3 * width, the texture will be repeated 3 times). + /// If repeat mode is disabled, the "extra space" will instead + /// be filled with border pixels. + /// Warning: on very old graphics cards, white pixels may appear + /// when the texture is repeated. With such cards, repeat mode + /// can be used reliably only if the texture has power-of-two + /// dimensions (such as 256x128). + /// Repeating is disabled by default. + /// + /// \param repeated True to repeat the texture, false to disable repeating + /// + /// \see isRepeated + /// + //////////////////////////////////////////////////////////// + void setRepeated(bool repeated); + + //////////////////////////////////////////////////////////// + /// \brief Tell whether the texture is repeated or not + /// + /// \return True if repeat mode is enabled, false if it is disabled + /// + /// \see setRepeated + /// + //////////////////////////////////////////////////////////// + bool isRepeated() const; + + //////////////////////////////////////////////////////////// + /// \brief Overload of assignment operator + /// + /// \param right Instance to assign + /// + /// \return Reference to self + /// + //////////////////////////////////////////////////////////// + Texture& operator =(const Texture& right); + + //////////////////////////////////////////////////////////// + /// \brief Bind a texture for rendering + /// + /// This function is not part of the graphics API, it mustn't be + /// used when drawing SFML entities. It must be used only if you + /// mix sf::Texture with OpenGL code. + /// + /// \code + /// sf::Texture t1, t2; + /// ... + /// sf::Texture::bind(&t1); + /// // draw OpenGL stuff that use t1... + /// sf::Texture::bind(&t2); + /// // draw OpenGL stuff that use t2... + /// sf::Texture::bind(NULL); + /// // draw OpenGL stuff that use no texture... + /// \endcode + /// + /// The \a coordinateType argument controls how texture + /// coordinates will be interpreted. If Normalized (the default), they + /// must be in range [0 .. 1], which is the default way of handling + /// texture coordinates with OpenGL. If Pixels, they must be given + /// in pixels (range [0 .. size]). This mode is used internally by + /// the graphics classes of SFML, it makes the definition of texture + /// coordinates more intuitive for the high-level API, users don't need + /// to compute normalized values. + /// + /// \param texture Pointer to the texture to bind, can be null to use no texture + /// \param coordinateType Type of texture coordinates to use + /// + //////////////////////////////////////////////////////////// + static void bind(const Texture* texture, CoordinateType coordinateType = Normalized); + + //////////////////////////////////////////////////////////// + /// \brief Get the maximum texture size allowed + /// + /// This maximum size is defined by the graphics driver. + /// You can expect a value of 512 pixels for low-end graphics + /// card, and up to 8192 pixels or more for newer hardware. + /// + /// \return Maximum size allowed for textures, in pixels + /// + //////////////////////////////////////////////////////////// + static unsigned int getMaximumSize(); + +private : + + friend class RenderTexture; + friend class RenderTarget; + + //////////////////////////////////////////////////////////// + /// \brief Get a valid image size according to hardware support + /// + /// This function checks whether the graphics driver supports + /// non power of two sizes or not, and adjusts the size + /// accordingly. + /// The returned size is greater than or equal to the original size. + /// + /// \param Size size to convert + /// + /// \return Valid nearest size (greater than or equal to specified size) + /// + //////////////////////////////////////////////////////////// + static unsigned int getValidSize(unsigned int size); + + //////////////////////////////////////////////////////////// + // Member data + //////////////////////////////////////////////////////////// + Vector2u m_size; ///< Public texture size + Vector2u m_actualSize; ///< Actual texture size (can be greater than public size because of padding) + unsigned int m_texture; ///< Internal texture identifier + bool m_isSmooth; ///< Status of the smooth filter + bool m_isRepeated; ///< Is the texture in repeat mode? + mutable bool m_pixelsFlipped; ///< To work around the inconsistency in Y orientation + Uint64 m_cacheId; ///< Unique number that identifies the texture to the render target's cache +}; + +} // namespace sf + + +#endif // SFML_TEXTURE_HPP + +//////////////////////////////////////////////////////////// +/// \class sf::Texture +/// \ingroup graphics +/// +/// sf::Texture stores pixels that can be drawn, with a sprite +/// for example. A texture lives in the graphics card memory, +/// therefore it is very fast to draw a texture to a render target, +/// or copy a render target to a texture (the graphics card can +/// access both directly). +/// +/// Being stored in the graphics card memory has some drawbacks. +/// A texture cannot be manipulated as freely as a sf::Image, +/// you need to prepare the pixels first and then upload them +/// to the texture in a single operation (see Texture::update). +/// +/// sf::Texture makes it easy to convert from/to sf::Image, but +/// keep in mind that these calls require transfers between +/// the graphics card and the central memory, therefore they are +/// slow operations. +/// +/// A texture can be loaded from an image, but also directly +/// from a file/memory/stream. The necessary shortcuts are defined +/// so that you don't need an image first for the most common cases. +/// However, if you want to perform some modifications on the pixels +/// before creating the final texture, you can load your file to a +/// sf::Image, do whatever you need with the pixels, and then call +/// Texture::loadFromImage. +/// +/// Since they live in the graphics card memory, the pixels of a texture +/// cannot be accessed without a slow copy first. And they cannot be +/// accessed individually. Therefore, if you need to read the texture's +/// pixels (like for pixel-perfect collisions), it is recommended to +/// store the collision information separately, for example in an array +/// of booleans. +/// +/// Like sf::Image, sf::Texture can handle a unique internal +/// representation of pixels, which is RGBA 32 bits. This means +/// that a pixel must be composed of 8 bits red, green, blue and +/// alpha channels -- just like a sf::Color. +/// +/// Usage example: +/// \code +/// // This example shows the most common use of sf::Texture: +/// // drawing a sprite +/// +/// // Load a texture from a file +/// sf::Texture texture; +/// if (!texture.loadFromFile("texture.png")) +/// return -1; +/// +/// // Assign it to a sprite +/// sf::Sprite sprite; +/// sprite.setTexture(texture); +/// +/// // Draw the textured sprite +/// window.draw(sprite); +/// \endcode +/// +/// \code +/// // This example shows another common use of sf::Texture: +/// // streaming real-time data, like video frames +/// +/// // Create an empty texture +/// sf::Texture texture; +/// if (!texture.create(640, 480)) +/// return -1; +/// +/// // Create a sprite that will display the texture +/// sf::Sprite sprite(texture); +/// +/// while (...) // the main loop +/// { +/// ... +/// +/// // update the texture +/// sf::Uint8* pixels = ...; // get a fresh chunk of pixels (the next frame of a movie, for example) +/// texture.update(pixels); +/// +/// // draw it +/// window.draw(sprite); +/// +/// ... +/// } +/// +/// \endcode +/// +/// Like sf::Shader that can be used as a raw OpenGL shader, +/// sf::Texture can also be used directly as a raw texture for +/// custom OpenGL geometry. +/// \code +/// sf::Texture::bind(&texture); +/// ... render OpenGL geometry ... +/// sf::Texture::bind(NULL); +/// \endcode +/// +/// \see sf::Sprite, sf::Image, sf::RenderTexture +/// +//////////////////////////////////////////////////////////// diff --git a/include/SFML/Graphics/Transform.hpp b/include/SFML/Graphics/Transform.hpp new file mode 100644 index 0000000..3b91a8a --- /dev/null +++ b/include/SFML/Graphics/Transform.hpp @@ -0,0 +1,450 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_TRANSFORM_HPP +#define SFML_TRANSFORM_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.hpp> +#include <SFML/Graphics/Rect.hpp> +#include <SFML/System/Vector2.hpp> + + +namespace sf +{ +//////////////////////////////////////////////////////////// +/// \brief Define a 3x3 transform matrix +/// +//////////////////////////////////////////////////////////// +class SFML_GRAPHICS_API Transform +{ +public : + + //////////////////////////////////////////////////////////// + /// \brief Default constructor + /// + /// Creates an identity transform (a transform that does nothing). + /// + //////////////////////////////////////////////////////////// + Transform(); + + //////////////////////////////////////////////////////////// + /// \brief Construct a transform from a 3x3 matrix + /// + /// \param a00 Element (0, 0) of the matrix + /// \param a01 Element (0, 1) of the matrix + /// \param a02 Element (0, 2) of the matrix + /// \param a10 Element (1, 0) of the matrix + /// \param a11 Element (1, 1) of the matrix + /// \param a12 Element (1, 2) of the matrix + /// \param a20 Element (2, 0) of the matrix + /// \param a21 Element (2, 1) of the matrix + /// \param a22 Element (2, 2) of the matrix + /// + //////////////////////////////////////////////////////////// + Transform(float a00, float a01, float a02, + float a10, float a11, float a12, + float a20, float a21, float a22); + + //////////////////////////////////////////////////////////// + /// \brief Return the transform as a 4x4 matrix + /// + /// This function returns a pointer to an array of 16 floats + /// containing the transform elements as a 4x4 matrix, which + /// is directly compatible with OpenGL functions. + /// + /// \code + /// sf::Transform transform = ...; + /// glLoadMatrixf(transform.getMatrix()); + /// \endcode + /// + /// \return Pointer to a 4x4 matrix + /// + //////////////////////////////////////////////////////////// + const float* getMatrix() const; + + //////////////////////////////////////////////////////////// + /// \brief Return the inverse of the transform + /// + /// If the inverse cannot be computed, an identity transform + /// is returned. + /// + /// \return A new transform which is the inverse of self + /// + //////////////////////////////////////////////////////////// + Transform getInverse() const; + + //////////////////////////////////////////////////////////// + /// \brief Transform a 2D point + /// + /// \param x X coordinate of the point to transform + /// \param y Y coordinate of the point to transform + /// + /// \return Transformed point + /// + //////////////////////////////////////////////////////////// + Vector2f transformPoint(float x, float y) const; + + //////////////////////////////////////////////////////////// + /// \brief Transform a 2D point + /// + /// \param point Point to transform + /// + /// \return Transformed point + /// + //////////////////////////////////////////////////////////// + Vector2f transformPoint(const Vector2f& point) const; + + //////////////////////////////////////////////////////////// + /// \brief Transform a rectangle + /// + /// Since SFML doesn't provide support for oriented rectangles, + /// the result of this function is always an axis-aligned + /// rectangle. Which means that if the transform contains a + /// rotation, the bounding rectangle of the transformed rectangle + /// is returned. + /// + /// \param rectangle Rectangle to transform + /// + /// \return Transformed rectangle + /// + //////////////////////////////////////////////////////////// + FloatRect transformRect(const FloatRect& rectangle) const; + + //////////////////////////////////////////////////////////// + /// \brief Combine the current transform with another one + /// + /// The result is a transform that is equivalent to applying + /// *this followed by \a transform. Mathematically, it is + /// equivalent to a matrix multiplication. + /// + /// \param transform Transform to combine with this transform + /// + /// \return Reference to *this + /// + //////////////////////////////////////////////////////////// + Transform& combine(const Transform& transform); + + //////////////////////////////////////////////////////////// + /// \brief Combine the current transform with a translation + /// + /// This function returns a reference to *this, so that calls + /// can be chained. + /// \code + /// sf::Transform transform; + /// transform.translate(100, 200).rotate(45); + /// \endcode + /// + /// \param x Offset to apply on X axis + /// \param y Offset to apply on Y axis + /// + /// \return Reference to *this + /// + /// \see rotate, scale + /// + //////////////////////////////////////////////////////////// + Transform& translate(float x, float y); + + //////////////////////////////////////////////////////////// + /// \brief Combine the current transform with a translation + /// + /// This function returns a reference to *this, so that calls + /// can be chained. + /// \code + /// sf::Transform transform; + /// transform.translate(sf::Vector2f(100, 200)).rotate(45); + /// \endcode + /// + /// \param offset Translation offset to apply + /// + /// \return Reference to *this + /// + /// \see rotate, scale + /// + //////////////////////////////////////////////////////////// + Transform& translate(const Vector2f& offset); + + //////////////////////////////////////////////////////////// + /// \brief Combine the current transform with a rotation + /// + /// This function returns a reference to *this, so that calls + /// can be chained. + /// \code + /// sf::Transform transform; + /// transform.rotate(90).translate(50, 20); + /// \endcode + /// + /// \param angle Rotation angle, in degrees + /// + /// \return Reference to *this + /// + /// \see translate, scale + /// + //////////////////////////////////////////////////////////// + Transform& rotate(float angle); + + //////////////////////////////////////////////////////////// + /// \brief Combine the current transform with a rotation + /// + /// The center of rotation is provided for convenience as a second + /// argument, so that you can build rotations around arbitrary points + /// more easily (and efficiently) than the usual + /// translate(-center).rotate(angle).translate(center). + /// + /// This function returns a reference to *this, so that calls + /// can be chained. + /// \code + /// sf::Transform transform; + /// transform.rotate(90, 8, 3).translate(50, 20); + /// \endcode + /// + /// \param angle Rotation angle, in degrees + /// \param centerX X coordinate of the center of rotation + /// \param centerY Y coordinate of the center of rotation + /// + /// \return Reference to *this + /// + /// \see translate, scale + /// + //////////////////////////////////////////////////////////// + Transform& rotate(float angle, float centerX, float centerY); + + //////////////////////////////////////////////////////////// + /// \brief Combine the current transform with a rotation + /// + /// The center of rotation is provided for convenience as a second + /// argument, so that you can build rotations around arbitrary points + /// more easily (and efficiently) than the usual + /// translate(-center).rotate(angle).translate(center). + /// + /// This function returns a reference to *this, so that calls + /// can be chained. + /// \code + /// sf::Transform transform; + /// transform.rotate(90, sf::Vector2f(8, 3)).translate(sf::Vector2f(50, 20)); + /// \endcode + /// + /// \param angle Rotation angle, in degrees + /// \param center Center of rotation + /// + /// \return Reference to *this + /// + /// \see translate, scale + /// + //////////////////////////////////////////////////////////// + Transform& rotate(float angle, const Vector2f& center); + + //////////////////////////////////////////////////////////// + /// \brief Combine the current transform with a scaling + /// + /// This function returns a reference to *this, so that calls + /// can be chained. + /// \code + /// sf::Transform transform; + /// transform.scale(2, 1).rotate(45); + /// \endcode + /// + /// \param scaleX Scaling factor on the X axis + /// \param scaleY Scaling factor on the Y axis + /// + /// \return Reference to *this + /// + /// \see translate, rotate + /// + //////////////////////////////////////////////////////////// + Transform& scale(float scaleX, float scaleY); + + //////////////////////////////////////////////////////////// + /// \brief Combine the current transform with a scaling + /// + /// The center of scaling is provided for convenience as a second + /// argument, so that you can build scaling around arbitrary points + /// more easily (and efficiently) than the usual + /// translate(-center).scale(factors).translate(center). + /// + /// This function returns a reference to *this, so that calls + /// can be chained. + /// \code + /// sf::Transform transform; + /// transform.scale(2, 1, 8, 3).rotate(45); + /// \endcode + /// + /// \param scaleX Scaling factor on X axis + /// \param scaleY Scaling factor on Y axis + /// \param centerX X coordinate of the center of scaling + /// \param centerY Y coordinate of the center of scaling + /// + /// \return Reference to *this + /// + /// \see translate, rotate + /// + //////////////////////////////////////////////////////////// + Transform& scale(float scaleX, float scaleY, float centerX, float centerY); + + //////////////////////////////////////////////////////////// + /// \brief Combine the current transform with a scaling + /// + /// This function returns a reference to *this, so that calls + /// can be chained. + /// \code + /// sf::Transform transform; + /// transform.scale(sf::Vector2f(2, 1)).rotate(45); + /// \endcode + /// + /// \param factors Scaling factors + /// + /// \return Reference to *this + /// + /// \see translate, rotate + /// + //////////////////////////////////////////////////////////// + Transform& scale(const Vector2f& factors); + + //////////////////////////////////////////////////////////// + /// \brief Combine the current transform with a scaling + /// + /// The center of scaling is provided for convenience as a second + /// argument, so that you can build scaling around arbitrary points + /// more easily (and efficiently) than the usual + /// translate(-center).scale(factors).translate(center). + /// + /// This function returns a reference to *this, so that calls + /// can be chained. + /// \code + /// sf::Transform transform; + /// transform.scale(sf::Vector2f(2, 1), sf::Vector2f(8, 3)).rotate(45); + /// \endcode + /// + /// \param factors Scaling factors + /// \param center Center of scaling + /// + /// \return Reference to *this + /// + /// \see translate, rotate + /// + //////////////////////////////////////////////////////////// + Transform& scale(const Vector2f& factors, const Vector2f& center); + + //////////////////////////////////////////////////////////// + // Static member data + //////////////////////////////////////////////////////////// + static const Transform Identity; ///< The identity transform (does nothing) + +private: + + //////////////////////////////////////////////////////////// + // Member data + //////////////////////////////////////////////////////////// + float m_matrix[16]; ///< 4x4 matrix defining the transformation +}; + +//////////////////////////////////////////////////////////// +/// \relates sf::Transform +/// \brief Overload of binary operator * to combine two transforms +/// +/// This call is equivalent to calling Transform(left).combine(right). +/// +/// \param left Left operand (the first transform) +/// \param right Right operand (the second transform) +/// +/// \return New combined transform +/// +//////////////////////////////////////////////////////////// +SFML_GRAPHICS_API Transform operator *(const Transform& left, const Transform& right); + +//////////////////////////////////////////////////////////// +/// \relates sf::Transform +/// \brief Overload of binary operator *= to combine two transforms +/// +/// This call is equivalent to calling left.combine(right). +/// +/// \param left Left operand (the first transform) +/// \param right Right operand (the second transform) +/// +/// \return The combined transform +/// +//////////////////////////////////////////////////////////// +SFML_GRAPHICS_API Transform& operator *=(Transform& left, const Transform& right); + +//////////////////////////////////////////////////////////// +/// \relates sf::Transform +/// \brief Overload of binary operator * to transform a point +/// +/// This call is equivalent to calling left.transformPoint(right). +/// +/// \param left Left operand (the transform) +/// \param right Right operand (the point to transform) +/// +/// \return New transformed point +/// +//////////////////////////////////////////////////////////// +SFML_GRAPHICS_API Vector2f operator *(const Transform& left, const Vector2f& right); + +} // namespace sf + + +#endif // SFML_TRANSFORM_HPP + + +//////////////////////////////////////////////////////////// +/// \class sf::Transform +/// \ingroup graphics +/// +/// A sf::Transform specifies how to translate, rotate, scale, +/// shear, project, whatever things. In mathematical terms, it defines +/// how to transform a coordinate system into another. +/// +/// For example, if you apply a rotation transform to a sprite, the +/// result will be a rotated sprite. And anything that is transformed +/// by this rotation transform will be rotated the same way, according +/// to its initial position. +/// +/// Transforms are typically used for drawing. But they can also be +/// used for any computation that requires to transform points between +/// the local and global coordinate systems of an entity (like collision +/// detection). +/// +/// Example: +/// \code +/// // define a translation transform +/// sf::Transform translation; +/// translation.translate(20, 50); +/// +/// // define a rotation transform +/// sf::Transform rotation; +/// rotation.rotate(45); +/// +/// // combine them +/// sf::Transform transform = translation * rotation; +/// +/// // use the result to transform stuff... +/// sf::Vector2f point = transform.transformPoint(10, 20); +/// sf::FloatRect rect = transform.transformRect(sf::FloatRect(0, 0, 10, 100)); +/// \endcode +/// +/// \see sf::Transformable, sf::RenderStates +/// +//////////////////////////////////////////////////////////// diff --git a/include/SFML/Graphics/Transformable.hpp b/include/SFML/Graphics/Transformable.hpp new file mode 100644 index 0000000..28fb386 --- /dev/null +++ b/include/SFML/Graphics/Transformable.hpp @@ -0,0 +1,417 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_TRANSFORMABLE_HPP +#define SFML_TRANSFORMABLE_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.hpp> +#include <SFML/Graphics/Transform.hpp> + + +namespace sf +{ +//////////////////////////////////////////////////////////// +/// \brief Decomposed transform defined by a position, a rotation and a scale +/// +//////////////////////////////////////////////////////////// +class SFML_GRAPHICS_API Transformable +{ +public : + + //////////////////////////////////////////////////////////// + /// \brief Default constructor + /// + //////////////////////////////////////////////////////////// + Transformable(); + + //////////////////////////////////////////////////////////// + /// \brief Virtual destructor + /// + //////////////////////////////////////////////////////////// + virtual ~Transformable(); + + //////////////////////////////////////////////////////////// + /// \brief set the position of the object + /// + /// This function completely overwrites the previous position. + /// See the move function to apply an offset based on the previous position instead. + /// The default position of a transformable object is (0, 0). + /// + /// \param x X coordinate of the new position + /// \param y Y coordinate of the new position + /// + /// \see move, getPosition + /// + //////////////////////////////////////////////////////////// + void setPosition(float x, float y); + + //////////////////////////////////////////////////////////// + /// \brief set the position of the object + /// + /// This function completely overwrites the previous position. + /// See the move function to apply an offset based on the previous position instead. + /// The default position of a transformable object is (0, 0). + /// + /// \param position New position + /// + /// \see move, getPosition + /// + //////////////////////////////////////////////////////////// + void setPosition(const Vector2f& position); + + //////////////////////////////////////////////////////////// + /// \brief set the orientation of the object + /// + /// This function completely overwrites the previous rotation. + /// See the rotate function to add an angle based on the previous rotation instead. + /// The default rotation of a transformable object is 0. + /// + /// \param angle New rotation, in degrees + /// + /// \see rotate, getRotation + /// + //////////////////////////////////////////////////////////// + void setRotation(float angle); + + //////////////////////////////////////////////////////////// + /// \brief set the scale factors of the object + /// + /// This function completely overwrites the previous scale. + /// See the scale function to add a factor based on the previous scale instead. + /// The default scale of a transformable object is (1, 1). + /// + /// \param factorX New horizontal scale factor + /// \param factorY New vertical scale factor + /// + /// \see scale, getScale + /// + //////////////////////////////////////////////////////////// + void setScale(float factorX, float factorY); + + //////////////////////////////////////////////////////////// + /// \brief set the scale factors of the object + /// + /// This function completely overwrites the previous scale. + /// See the scale function to add a factor based on the previous scale instead. + /// The default scale of a transformable object is (1, 1). + /// + /// \param factors New scale factors + /// + /// \see scale, getScale + /// + //////////////////////////////////////////////////////////// + void setScale(const Vector2f& factors); + + //////////////////////////////////////////////////////////// + /// \brief set the local origin of the object + /// + /// The origin of an object defines the center point for + /// all transformations (position, scale, rotation). + /// The coordinates of this point must be relative to the + /// top-left corner of the object, and ignore all + /// transformations (position, scale, rotation). + /// The default origin of a transformable object is (0, 0). + /// + /// \param x X coordinate of the new origin + /// \param y Y coordinate of the new origin + /// + /// \see getOrigin + /// + //////////////////////////////////////////////////////////// + void setOrigin(float x, float y); + + //////////////////////////////////////////////////////////// + /// \brief set the local origin of the object + /// + /// The origin of an object defines the center point for + /// all transformations (position, scale, rotation). + /// The coordinates of this point must be relative to the + /// top-left corner of the object, and ignore all + /// transformations (position, scale, rotation). + /// The default origin of a transformable object is (0, 0). + /// + /// \param origin New origin + /// + /// \see getOrigin + /// + //////////////////////////////////////////////////////////// + void setOrigin(const Vector2f& origin); + + //////////////////////////////////////////////////////////// + /// \brief get the position of the object + /// + /// \return Current position + /// + /// \see setPosition + /// + //////////////////////////////////////////////////////////// + const Vector2f& getPosition() const; + + //////////////////////////////////////////////////////////// + /// \brief get the orientation of the object + /// + /// The rotation is always in the range [0, 360]. + /// + /// \return Current rotation, in degrees + /// + /// \see setRotation + /// + //////////////////////////////////////////////////////////// + float getRotation() const; + + //////////////////////////////////////////////////////////// + /// \brief get the current scale of the object + /// + /// \return Current scale factors + /// + /// \see setScale + /// + //////////////////////////////////////////////////////////// + const Vector2f& getScale() const; + + //////////////////////////////////////////////////////////// + /// \brief get the local origin of the object + /// + /// \return Current origin + /// + /// \see setOrigin + /// + //////////////////////////////////////////////////////////// + const Vector2f& getOrigin() const; + + //////////////////////////////////////////////////////////// + /// \brief Move the object by a given offset + /// + /// This function adds to the current position of the object, + /// unlike setPosition which overwrites it. + /// Thus, it is equivalent to the following code: + /// \code + /// sf::Vector2f pos = object.getPosition(); + /// object.setPosition(pos.x + offsetX, pos.y + offsetY); + /// \endcode + /// + /// \param offsetX X offset + /// \param offsetY Y offset + /// + /// \see setPosition + /// + //////////////////////////////////////////////////////////// + void move(float offsetX, float offsetY); + + //////////////////////////////////////////////////////////// + /// \brief Move the object by a given offset + /// + /// This function adds to the current position of the object, + /// unlike setPosition which overwrites it. + /// Thus, it is equivalent to the following code: + /// \code + /// object.setPosition(object.getPosition() + offset); + /// \endcode + /// + /// \param offset Offset + /// + /// \see setPosition + /// + //////////////////////////////////////////////////////////// + void move(const Vector2f& offset); + + //////////////////////////////////////////////////////////// + /// \brief Rotate the object + /// + /// This function adds to the current rotation of the object, + /// unlike setRotation which overwrites it. + /// Thus, it is equivalent to the following code: + /// \code + /// object.setRotation(object.getRotation() + angle); + /// \endcode + /// + /// \param angle Angle of rotation, in degrees + /// + //////////////////////////////////////////////////////////// + void rotate(float angle); + + //////////////////////////////////////////////////////////// + /// \brief Scale the object + /// + /// This function multiplies the current scale of the object, + /// unlike setScale which overwrites it. + /// Thus, it is equivalent to the following code: + /// \code + /// sf::Vector2f scale = object.getScale(); + /// object.setScale(scale.x * factorX, scale.y * factorY); + /// \endcode + /// + /// \param factorX Horizontal scale factor + /// \param factorY Vertical scale factor + /// + /// \see setScale + /// + //////////////////////////////////////////////////////////// + void scale(float factorX, float factorY); + + //////////////////////////////////////////////////////////// + /// \brief Scale the object + /// + /// This function multiplies the current scale of the object, + /// unlike setScale which overwrites it. + /// Thus, it is equivalent to the following code: + /// \code + /// sf::Vector2f scale = object.getScale(); + /// object.setScale(scale.x * factor.x, scale.y * factor.y); + /// \endcode + /// + /// \param factor Scale factors + /// + /// \see setScale + /// + //////////////////////////////////////////////////////////// + void scale(const Vector2f& factor); + + //////////////////////////////////////////////////////////// + /// \brief get the combined transform of the object + /// + /// \return Transform combining the position/rotation/scale/origin of the object + /// + /// \see getInverseTransform + /// + //////////////////////////////////////////////////////////// + const Transform& getTransform() const; + + //////////////////////////////////////////////////////////// + /// \brief get the inverse of the combined transform of the object + /// + /// \return Inverse of the combined transformations applied to the object + /// + /// \see getTransform + /// + //////////////////////////////////////////////////////////// + const Transform& getInverseTransform() const; + +private : + + //////////////////////////////////////////////////////////// + // Member data + //////////////////////////////////////////////////////////// + Vector2f m_origin; ///< Origin of translation/rotation/scaling of the object + Vector2f m_position; ///< Position of the object in the 2D world + float m_rotation; ///< Orientation of the object, in degrees + Vector2f m_scale; ///< Scale of the object + mutable Transform m_transform; ///< Combined transformation of the object + mutable bool m_transformNeedUpdate; ///< Does the transform need to be recomputed? + mutable Transform m_inverseTransform; ///< Combined transformation of the object + mutable bool m_inverseTransformNeedUpdate; ///< Does the transform need to be recomputed? +}; + +} // namespace sf + + +#endif // SFML_TRANSFORMABLE_HPP + + +//////////////////////////////////////////////////////////// +/// \class sf::Transformable +/// \ingroup graphics +/// +/// This class is provided for convenience, on top of sf::Transform. +/// +/// sf::Transform, as a low-level class, offers a great level of +/// flexibility but it is not always convenient to manage. Indeed, +/// one can easily combine any kind of operation, such as a translation +/// followed by a rotation followed by a scaling, but once the result +/// transform is built, there's no way to go backward and, let's say, +/// change only the rotation without modifying the translation and scaling. +/// The entire transform must be recomputed, which means that you +/// need to retrieve the initial translation and scale factors as +/// well, and combine them the same way you did before updating the +/// rotation. This is a tedious operation, and it requires to store +/// all the individual components of the final transform. +/// +/// That's exactly what sf::Transformable was written for: it hides +/// these variables and the composed transform behind an easy to use +/// interface. You can set or get any of the individual components +/// without worrying about the others. It also provides the composed +/// transform (as a sf::Transform), and keeps it up-to-date. +/// +/// In addition to the position, rotation and scale, sf::Transformable +/// provides an "origin" component, which represents the local origin +/// of the three other components. Let's take an example with a 10x10 +/// pixels sprite. By default, the sprite is positioned/rotated/scaled +/// relatively to its top-left corner, because it is the local point +/// (0, 0). But if we change the origin to be (5, 5), the sprite will +/// be positioned/rotated/scaled around its center instead. And if +/// we set the origin to (10, 10), it will be transformed around its +/// bottom-right corner. +/// +/// To keep the sf::Transformable class simple, there's only one +/// origin for all the components. You cannot position the sprite +/// relatively to its top-left corner while rotating it around its +/// center, for example. To do such things, use sf::Transform directly. +/// +/// sf::Transformable can be used as a base class. It is often +/// combined with sf::Drawable -- that's what SFML's sprites, +/// texts and shapes do. +/// \code +/// class MyEntity : public sf::Transformable, public sf::Drawable +/// { +/// virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const +/// { +/// states.transform *= getTransform(); +/// target.draw(..., states); +/// } +/// }; +/// +/// MyEntity entity; +/// entity.setPosition(10, 20); +/// entity.setRotation(45); +/// window.draw(entity); +/// \endcode +/// +/// It can also be used as a member, if you don't want to use +/// its API directly (because you don't need all its functions, +/// or you have different naming conventions for example). +/// \code +/// class MyEntity +/// { +/// public : +/// void SetPosition(const MyVector& v) +/// { +/// myTransform.setPosition(v.x(), v.y()); +/// } +/// +/// void Draw(sf::RenderTarget& target) const +/// { +/// target.draw(..., myTransform.getTransform()); +/// } +/// +/// private : +/// sf::Transformable myTransform; +/// }; +/// \endcode +/// +/// \see sf::Transform +/// +//////////////////////////////////////////////////////////// diff --git a/include/SFML/Graphics/Vertex.hpp b/include/SFML/Graphics/Vertex.hpp new file mode 100644 index 0000000..b983ef2 --- /dev/null +++ b/include/SFML/Graphics/Vertex.hpp @@ -0,0 +1,148 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_VERTEX_HPP +#define SFML_VERTEX_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.hpp> +#include <SFML/Graphics/Color.hpp> +#include <SFML/System/Vector2.hpp> + + +namespace sf +{ +//////////////////////////////////////////////////////////// +/// \brief Define a point with color and texture coordinates +/// +//////////////////////////////////////////////////////////// +class SFML_GRAPHICS_API Vertex +{ +public : + + //////////////////////////////////////////////////////////// + /// \brief Default constructor + /// + //////////////////////////////////////////////////////////// + Vertex(); + + //////////////////////////////////////////////////////////// + /// \brief Construct the vertex from its position + /// + /// The vertex color is white and texture coordinates are (0, 0). + /// + /// \param thePosition Vertex position + /// + //////////////////////////////////////////////////////////// + Vertex(const Vector2f& thePosition); + + //////////////////////////////////////////////////////////// + /// \brief Construct the vertex from its position and color + /// + /// The texture coordinates are (0, 0). + /// + /// \param thePosition Vertex position + /// \param theColor Vertex color + /// + //////////////////////////////////////////////////////////// + Vertex(const Vector2f& thePosition, const Color& theColor); + + //////////////////////////////////////////////////////////// + /// \brief Construct the vertex from its position and texture coordinates + /// + /// The vertex color is white. + /// + /// \param thePosition Vertex position + /// \param theTexCoords Vertex texture coordinates + /// + //////////////////////////////////////////////////////////// + Vertex(const Vector2f& thePosition, const Vector2f& theTexCoords); + + //////////////////////////////////////////////////////////// + /// \brief Construct the vertex from its position, color and texture coordinates + /// + /// \param thePosition Vertex position + /// \param theColor Vertex color + /// \param theTexCoords Vertex texture coordinates + /// + //////////////////////////////////////////////////////////// + Vertex(const Vector2f& thePosition, const Color& theColor, const Vector2f& theTexCoords); + + //////////////////////////////////////////////////////////// + // Member data + //////////////////////////////////////////////////////////// + Vector2f position; ///< 2D position of the vertex + Color color; ///< Color of the vertex + Vector2f texCoords; ///< Coordinates of the texture's pixel to map to the vertex +}; + +} // namespace sf + + +#endif // SFML_VERTEX_HPP + + +//////////////////////////////////////////////////////////// +/// \class sf::Vertex +/// \ingroup graphics +/// +/// A vertex is an improved point. It has a position and other +/// extra attributes that will be used for drawing: in SFML, +/// vertices also have a color and a pair of texture coordinates. +/// +/// The vertex is the building block of drawing. Everything which +/// is visible on screen is made of vertices. They are grouped +/// as 2D primitives (triangles, quads, ...), and these primitives +/// are grouped to create even more complex 2D entities such as +/// sprites, texts, etc. +/// +/// If you use the graphical entities of SFML (sprite, text, shape) +/// you won't have to deal with vertices directly. But if you want +/// to define your own 2D entities, such as tiled maps or particle +/// systems, using vertices will allow you to get maximum performances. +/// +/// Example: +/// \code +/// // define a 100x100 square, red, with a 10x10 texture mapped on it +/// sf::Vertex vertices[] = +/// { +/// sf::Vertex(sf::Vector2f( 0, 0), sf::Color::Red, sf::Vector2f( 0, 0)), +/// sf::Vertex(sf::Vector2f( 0, 100), sf::Color::Red, sf::Vector2f( 0, 10)), +/// sf::Vertex(sf::Vector2f(100, 100), sf::Color::Red, sf::Vector2f(10, 10)), +/// sf::Vertex(sf::Vector2f(100, 0), sf::Color::Red, sf::Vector2f(10, 0)) +/// }; +/// +/// // draw it +/// window.draw(vertices, 4, sf::Quads); +/// \endcode +/// +/// Note: although texture coordinates are supposed to be an integer +/// amount of pixels, their type is float because of some buggy graphics +/// drivers that are not able to process integer coordinates correctly. +/// +/// \see sf::VertexArray +/// +//////////////////////////////////////////////////////////// diff --git a/include/SFML/Graphics/VertexArray.hpp b/include/SFML/Graphics/VertexArray.hpp new file mode 100644 index 0000000..fc67845 --- /dev/null +++ b/include/SFML/Graphics/VertexArray.hpp @@ -0,0 +1,223 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_VERTEXARRAY_HPP +#define SFML_VERTEXARRAY_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.hpp> +#include <SFML/Graphics/Vertex.hpp> +#include <SFML/Graphics/PrimitiveType.hpp> +#include <SFML/Graphics/Rect.hpp> +#include <SFML/Graphics/Drawable.hpp> +#include <vector> + + +namespace sf +{ +//////////////////////////////////////////////////////////// +/// \brief Define a set of one or more 2D primitives +/// +//////////////////////////////////////////////////////////// +class SFML_GRAPHICS_API VertexArray : public Drawable +{ +public : + + //////////////////////////////////////////////////////////// + /// \brief Default constructor + /// + /// Creates an empty vertex array. + /// + //////////////////////////////////////////////////////////// + VertexArray(); + + //////////////////////////////////////////////////////////// + /// \brief Construct the vertex array with a type and an initial number of vertices + /// + /// \param type Type of primitives + /// \param vertexCount Initial number of vertices in the array + /// + //////////////////////////////////////////////////////////// + explicit VertexArray(PrimitiveType type, unsigned int vertexCount = 0); + + //////////////////////////////////////////////////////////// + /// \brief Return the vertex count + /// + /// \return Number of vertices in the array + /// + //////////////////////////////////////////////////////////// + unsigned int getVertexCount() const; + + //////////////////////////////////////////////////////////// + /// \brief Get a read-write access to a vertex by its index + /// + /// This function doesn't check \a index, it must be in range + /// [0, getVertexCount() - 1]. The behaviour is undefined + /// otherwise. + /// + /// \param index Index of the vertex to get + /// + /// \return Reference to the index-th vertex + /// + /// \see getVertexCount + /// + //////////////////////////////////////////////////////////// + Vertex& operator [](unsigned int index); + + //////////////////////////////////////////////////////////// + /// \brief Get a read-only access to a vertex by its index + /// + /// This function doesn't check \a index, it must be in range + /// [0, getVertexCount() - 1]. The behaviour is undefined + /// otherwise. + /// + /// \param index Index of the vertex to get + /// + /// \return Const reference to the index-th vertex + /// + /// \see getVertexCount + /// + //////////////////////////////////////////////////////////// + const Vertex& operator [](unsigned int index) const; + + //////////////////////////////////////////////////////////// + /// \brief Clear the vertex array + /// + /// This function removes all the vertices from the array. + /// It doesn't deallocate the corresponding memory, so that + /// adding new vertices after clearing doesn't involve + /// reallocating all the memory. + /// + //////////////////////////////////////////////////////////// + void clear(); + + //////////////////////////////////////////////////////////// + /// \brief Resize the vertex array + /// + /// If \a vertexCount is greater than the current size, the previous + /// vertices are kept and new (default-constructed) vertices are + /// added. + /// If \a vertexCount is less than the current size, existing vertices + /// are removed from the array. + /// + /// \param vertexCount New size of the array (number of vertices) + /// + //////////////////////////////////////////////////////////// + void resize(unsigned int vertexCount); + + //////////////////////////////////////////////////////////// + /// \brief Add a vertex to the array + /// + /// \param vertex Vertex to add + /// + //////////////////////////////////////////////////////////// + void append(const Vertex& vertex); + + //////////////////////////////////////////////////////////// + /// \brief Set the type of primitives to draw + /// + /// This function defines how the vertices must be interpreted + /// when it's time to draw them: + /// \li As points + /// \li As lines + /// \li As triangles + /// \li As quads + /// The default primitive type is sf::Points. + /// + /// \param type Type of primitive + /// + //////////////////////////////////////////////////////////// + void setPrimitiveType(PrimitiveType type); + + //////////////////////////////////////////////////////////// + /// \brief Get the type of primitives drawn by the vertex array + /// + /// \return Primitive type + /// + //////////////////////////////////////////////////////////// + PrimitiveType getPrimitiveType() const; + + //////////////////////////////////////////////////////////// + /// \brief Compute the bounding rectangle of the vertex array + /// + /// This function returns the axis-aligned rectangle that + /// contains all the vertices of the array. + /// + /// \return Bounding rectangle of the vertex array + /// + //////////////////////////////////////////////////////////// + FloatRect getBounds() const; + +private : + + //////////////////////////////////////////////////////////// + /// \brief Draw the vertex array to a render target + /// + /// \param target Render target to draw to + /// \param states Current render states + /// + //////////////////////////////////////////////////////////// + virtual void draw(RenderTarget& target, RenderStates states) const; + +private: + + //////////////////////////////////////////////////////////// + // Member data + //////////////////////////////////////////////////////////// + std::vector<Vertex> m_vertices; ///< Vertices contained in the array + PrimitiveType m_primitiveType; ///< Type of primitives to draw +}; + +} // namespace sf + + +#endif // SFML_VERTEXARRAY_HPP + + +//////////////////////////////////////////////////////////// +/// \class sf::VertexArray +/// \ingroup graphics +/// +/// sf::VertexArray is a very simple wrapper around a dynamic +/// array of vertices and a primitives type. +/// +/// It inherits sf::Drawable, but unlike other drawables it +/// is not transformable. +/// +/// Example: +/// \code +/// sf::VertexArray lines(sf::LinesStrip, 4); +/// lines[0].position = sf::Vector2f(10, 0); +/// lines[1].position = sf::Vector2f(20, 0); +/// lines[2].position = sf::Vector2f(30, 5); +/// lines[3].position = sf::Vector2f(40, 2); +/// +/// window.draw(lines); +/// \endcode +/// +/// \see sf::Vertex +/// +//////////////////////////////////////////////////////////// diff --git a/include/SFML/Graphics/View.hpp b/include/SFML/Graphics/View.hpp index d5e401a..7713aef 100755..100644 --- a/include/SFML/Graphics/View.hpp +++ b/include/SFML/Graphics/View.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,161 +28,314 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
+#include <SFML/Graphics/Export.hpp>
#include <SFML/Graphics/Rect.hpp>
-#include <SFML/Graphics/Matrix3.hpp>
+#include <SFML/Graphics/Transform.hpp>
#include <SFML/System/Vector2.hpp>
namespace sf
{
-class RenderTarget;
-
////////////////////////////////////////////////////////////
-/// This class defines a view (position, size, etc.) ;
-/// you can consider it as a 2D camera
+/// \brief 2D camera that defines what region is shown on screen
+///
////////////////////////////////////////////////////////////
-class SFML_API View
+class SFML_GRAPHICS_API View
{
public :
////////////////////////////////////////////////////////////
- /// Construct the view from a rectangle
+ /// \brief Default constructor
+ ///
+ /// This constructor creates a default view of (0, 0, 1000, 1000)
+ ///
+ ////////////////////////////////////////////////////////////
+ View();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Construct the view from a rectangle
+ ///
+ /// \param rectangle Rectangle defining the zone to display
+ ///
+ ////////////////////////////////////////////////////////////
+ explicit View(const FloatRect& rectangle);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Construct the view from its center and size
+ ///
+ /// \param center Center of the zone to display
+ /// \param size Size of zone to display
+ ///
+ ////////////////////////////////////////////////////////////
+ View(const Vector2f& center, const Vector2f& size);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Set the center of the view
///
- /// \param ViewRect : Rectangle defining the position and size of the view (1000x1000 by default)
+ /// \param x X coordinate of the new center
+ /// \param y Y coordinate of the new center
+ ///
+ /// \see setSize, getCenter
///
////////////////////////////////////////////////////////////
- explicit View(const FloatRect& ViewRect = FloatRect(0, 0, 1000, 1000));
+ void setCenter(float x, float y);
////////////////////////////////////////////////////////////
- /// Construct the view from its center and half-size
+ /// \brief Set the center of the view
+ ///
+ /// \param center New center
///
- /// \param Center : Center of the view
- /// \param HalfSize : Half-size of the view (from center to corner)
+ /// \see setSize, getCenter
///
////////////////////////////////////////////////////////////
- View(const sf::Vector2f& Center, const sf::Vector2f& HalfSize);
+ void setCenter(const Vector2f& center);
////////////////////////////////////////////////////////////
- /// Change the center of the view (take 2 values)
+ /// \brief Set the size of the view
///
- /// \param X : X coordinate of the new center
- /// \param Y : Y coordinate of the new center
+ /// \param width New width of the view
+ /// \param height New height of the view
+ ///
+ /// \see setCenter, getCenter
///
////////////////////////////////////////////////////////////
- void SetCenter(float X, float Y);
+ void setSize(float width, float height);
////////////////////////////////////////////////////////////
- /// Change the center of the view (take a vector)
+ /// \brief Set the size of the view
+ ///
+ /// \param size New size
///
- /// \param Center : New center
+ /// \see setCenter, getCenter
///
////////////////////////////////////////////////////////////
- void SetCenter(const sf::Vector2f& Center);
+ void setSize(const Vector2f& size);
////////////////////////////////////////////////////////////
- /// Change the half-size of the view (take 2 values)
+ /// \brief Set the orientation of the view
+ ///
+ /// The default rotation of a view is 0 degree.
///
- /// \param HalfWidth : New half-width
- /// \param HalfHeight : New half-height
+ /// \param angle New angle, in degrees
+ ///
+ /// \see getRotation
///
////////////////////////////////////////////////////////////
- void SetHalfSize(float HalfWidth, float HalfHeight);
+ void setRotation(float angle);
////////////////////////////////////////////////////////////
- /// Change the half-size of the view (take a vector)
+ /// \brief Set the target viewport
+ ///
+ /// The viewport is the rectangle into which the contents of the
+ /// view are displayed, expressed as a factor (between 0 and 1)
+ /// of the size of the RenderTarget to which the view is applied.
+ /// For example, a view which takes the left side of the target would
+ /// be defined with View.setViewport(sf::FloatRect(0, 0, 0.5, 1)).
+ /// By default, a view has a viewport which covers the entire target.
///
- /// \param HalfSize : New half-size
+ /// \param viewport New viewport rectangle
+ ///
+ /// \see getViewport
///
////////////////////////////////////////////////////////////
- void SetHalfSize(const sf::Vector2f& HalfSize);
+ void setViewport(const FloatRect& viewport);
////////////////////////////////////////////////////////////
- /// Rebuild the view from a rectangle
+ /// \brief Reset the view to the given rectangle
+ ///
+ /// Note that this function resets the rotation angle to 0.
///
- /// \param ViewRect : Rectangle defining the position and size of the view
+ /// \param rectangle Rectangle defining the zone to display
+ ///
+ /// \see setCenter, setSize, setRotation
///
////////////////////////////////////////////////////////////
- void SetFromRect(const FloatRect& ViewRect);
+ void reset(const FloatRect& rectangle);
////////////////////////////////////////////////////////////
- /// Get the center of the view
+ /// \brief Get the center of the view
///
/// \return Center of the view
///
+ /// \see getSize, setCenter
+ ///
////////////////////////////////////////////////////////////
- const sf::Vector2f& GetCenter() const;
+ const Vector2f& getCenter() const;
////////////////////////////////////////////////////////////
- /// Get the half-size of the view
+ /// \brief Get the size of the view
+ ///
+ /// \return Size of the view
///
- /// \return Half-size of the view
+ /// \see getCenter, setSize
///
////////////////////////////////////////////////////////////
- const sf::Vector2f& GetHalfSize() const;
+ const Vector2f& getSize() const;
////////////////////////////////////////////////////////////
- /// Get the bounding rectangle of the view
+ /// \brief Get the current orientation of the view
///
- /// \return Bounding rectangle of the view
+ /// \return Rotation angle of the view, in degrees
+ ///
+ /// \see setRotation
///
////////////////////////////////////////////////////////////
- const sf::FloatRect& GetRect() const;
+ float getRotation() const;
////////////////////////////////////////////////////////////
- /// Move the view (take 2 values)
+ /// \brief Get the target viewport rectangle of the view
+ ///
+ /// \return Viewport rectangle, expressed as a factor of the target size
///
- /// \param OffsetX : Offset to move the view, on X axis
- /// \param OffsetY : Offset to move the view, on Y axis
+ /// \see setViewport
///
////////////////////////////////////////////////////////////
- void Move(float OffsetX, float OffsetY);
+ const FloatRect& getViewport() const;
////////////////////////////////////////////////////////////
- /// Move the view (take a vector)
+ /// \brief Move the view relatively to its current position
///
- /// \param Offset : Offset to move the view
+ /// \param offsetX X coordinate of the move offset
+ /// \param offsetY Y coordinate of the move offset
+ ///
+ /// \see setCenter, rotate, zoom
///
////////////////////////////////////////////////////////////
- void Move(const sf::Vector2f& Offset);
+ void move(float offsetX, float offsetY);
////////////////////////////////////////////////////////////
- /// Resize the view rectangle to simulate a zoom / unzoom effect
+ /// \brief Move the view relatively to its current position
+ ///
+ /// \param offset Move offset
///
- /// \param Factor : Zoom factor to apply, relative to the current zoom
+ /// \see setCenter, rotate, zoom
///
////////////////////////////////////////////////////////////
- void Zoom(float Factor);
+ void move(const Vector2f& offset);
-private :
+ ////////////////////////////////////////////////////////////
+ /// \brief Rotate the view relatively to its current orientation
+ ///
+ /// \param angle Angle to rotate, in degrees
+ ///
+ /// \see setRotation, move, zoom
+ ///
+ ////////////////////////////////////////////////////////////
+ void rotate(float angle);
- friend class RenderTarget;
+ ////////////////////////////////////////////////////////////
+ /// \brief Resize the view rectangle relatively to its current size
+ ///
+ /// Resizing the view simulates a zoom, as the zone displayed on
+ /// screen grows or shrinks.
+ /// \a factor is a multiplier:
+ /// \li 1 keeps the size unchanged
+ /// \li > 1 makes the view bigger (objects appear smaller)
+ /// \li < 1 makes the view smaller (objects appear bigger)
+ ///
+ /// \param factor Zoom factor to apply
+ ///
+ /// \see setSize, move, rotate
+ ///
+ ////////////////////////////////////////////////////////////
+ void zoom(float factor);
////////////////////////////////////////////////////////////
- /// Get the projection matrix of the view
+ /// \brief Get the projection transform of the view
+ ///
+ /// This function is meant for internal use only.
+ ///
+ /// \return Projection transform defining the view
///
- /// \return Projection matrix containing the view settings
+ /// \see getInverseTransform
///
////////////////////////////////////////////////////////////
- const Matrix3& GetMatrix() const;
+ const Transform& getTransform() const;
////////////////////////////////////////////////////////////
- /// Recompute the view rectangle and the projection matrix
+ /// \brief Get the inverse projection transform of the view
+ ///
+ /// This function is meant for internal use only.
+ ///
+ /// \return Inverse of the projection transform defining the view
+ ///
+ /// \see getTransform
///
////////////////////////////////////////////////////////////
- void RecomputeMatrix();
+ const Transform& getInverseTransform() const;
+
+private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- sf::Vector2f myCenter; ///< Center of the view
- sf::Vector2f myHalfSize; ///< Half-size of the view
- FloatRect myRect; ///< Rectangle defining the bounds of the view
- Matrix3 myMatrix; ///< Precomputed projection matrix corresponding to the view
- bool myNeedUpdate; ///< Internal state telling if the matrix needs to be updated
+ Vector2f m_center; ///< Center of the view, in scene coordinates
+ Vector2f m_size; ///< Size of the view, in scene coordinates
+ float m_rotation; ///< Angle of rotation of the view rectangle, in degrees
+ FloatRect m_viewport; ///< Viewport rectangle, expressed as a factor of the render-target's size
+ mutable Transform m_transform; ///< Precomputed projection transform corresponding to the view
+ mutable Transform m_inverseTransform; ///< Precomputed inverse projection transform corresponding to the view
+ mutable bool m_transformUpdated; ///< Internal state telling if the transform needs to be updated
+ mutable bool m_invTransformUpdated; ///< Internal state telling if the inverse transform needs to be updated
};
} // namespace sf
#endif // SFML_VIEW_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::View
+/// \ingroup graphics
+///
+/// sf::View defines a camera in the 2D scene. This is a
+/// very powerful concept: you can scroll, rotate or zoom
+/// the entire scene without altering the way that your
+/// drawable objects are drawn.
+///
+/// A view is composed of a source rectangle, which defines
+/// what part of the 2D scene is shown, and a target viewport,
+/// which defines where the contents of the source rectangle
+/// will be displayed on the render target (window or texture).
+///
+/// The viewport allows to map the scene to a custom part
+/// of the render target, and can be used for split-screen
+/// or for displaying a minimap, for example. If the source
+/// rectangle has not the same size as the viewport, its
+/// contents will be stretched to fit in.
+///
+/// To apply a view, you have to assign it to the render target.
+/// Then, every objects drawn in this render target will be
+/// affected by the view until you use another view.
+///
+/// Usage example:
+/// \code
+/// sf::RenderWindow window;
+/// sf::View view;
+///
+/// // Initialize the view to a rectangle located at (100, 100) and with a size of 400x200
+/// view.reset(sf::FloatRect(100, 100, 400, 200));
+///
+/// // Rotate it by 45 degrees
+/// view.rotate(45);
+///
+/// // Set its target viewport to be half of the window
+/// view.setViewport(sf::FloatRect(0.f, 0.f, 0.5f, 1.f));
+///
+/// // Apply it
+/// window.setView(view);
+///
+/// // Render stuff
+/// window.draw(someSprite);
+///
+/// // Set the default view back
+/// window.setView(window.getDefaultView());
+///
+/// // Render stuff not affected by the view
+/// window.draw(someText);
+/// \endcode
+///
+/// \see sf::RenderWindow, sf::RenderTexture
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Network.hpp b/include/SFML/Network.hpp index 6ec13d3..66b3b85 100755..100644 --- a/include/SFML/Network.hpp +++ b/include/SFML/Network.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -32,11 +32,20 @@ #include <SFML/System.hpp>
#include <SFML/Network/Ftp.hpp>
#include <SFML/Network/Http.hpp>
-#include <SFML/Network/IPAddress.hpp>
+#include <SFML/Network/IpAddress.hpp>
#include <SFML/Network/Packet.hpp>
-#include <SFML/Network/Selector.hpp>
-#include <SFML/Network/SocketTCP.hpp>
-#include <SFML/Network/SocketUDP.hpp>
+#include <SFML/Network/SocketSelector.hpp>
+#include <SFML/Network/TcpListener.hpp>
+#include <SFML/Network/TcpSocket.hpp>
+#include <SFML/Network/UdpSocket.hpp>
#endif // SFML_NETWORK_HPP
+
+////////////////////////////////////////////////////////////
+/// \defgroup network Network module
+///
+/// Socket-based communication, utilities and higher-level
+/// network protocols (HTTP, FTP).
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Network/Export.hpp b/include/SFML/Network/Export.hpp new file mode 100644 index 0000000..7dcd1d0 --- /dev/null +++ b/include/SFML/Network/Export.hpp @@ -0,0 +1,48 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_NETWORK_EXPORT_HPP +#define SFML_NETWORK_EXPORT_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Config.hpp> + + +//////////////////////////////////////////////////////////// +// Define portable import / export macros +//////////////////////////////////////////////////////////// +#if defined(SFML_NETWORK_EXPORTS) + + #define SFML_NETWORK_API SFML_API_EXPORT + +#else + + #define SFML_NETWORK_API SFML_API_IMPORT + +#endif + + +#endif // SFML_NETWORK_EXPORT_HPP diff --git a/include/SFML/Network/Ftp.hpp b/include/SFML/Network/Ftp.hpp index f2f1bd3..9b8ed9b 100755..100644 --- a/include/SFML/Network/Ftp.hpp +++ b/include/SFML/Network/Ftp.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,28 +28,29 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
+#include <SFML/Network/Export.hpp>
+#include <SFML/Network/TcpSocket.hpp>
#include <SFML/System/NonCopyable.hpp>
-#include <SFML/Network/SocketTCP.hpp>
+#include <SFML/System/Time.hpp>
#include <string>
#include <vector>
namespace sf
{
-class IPAddress;
+class IpAddress;
////////////////////////////////////////////////////////////
-/// This class provides methods for manipulating the FTP
-/// protocol (described in RFC 959).
-/// It provides easy access and transfers to remote
-/// directories and files on a FTP server
+/// \brief A FTP client
+///
////////////////////////////////////////////////////////////
-class SFML_API Ftp : NonCopyable
+class SFML_NETWORK_API Ftp : NonCopyable
{
public :
////////////////////////////////////////////////////////////
- /// Enumeration of transfer modes
+ /// \brief Enumeration of transfer modes
+ ///
////////////////////////////////////////////////////////////
enum TransferMode
{
@@ -59,17 +60,16 @@ public : };
////////////////////////////////////////////////////////////
- /// This class wraps a FTP response, which is basically :
- /// - a status code
- /// - a message
+ /// \brief Define a FTP response
+ ///
////////////////////////////////////////////////////////////
- class SFML_API Response
+ class SFML_NETWORK_API Response
{
public :
////////////////////////////////////////////////////////////
- /// Enumerate all the valid status codes returned in
- /// a FTP response
+ /// \brief Status codes possibly returned by a FTP response
+ ///
////////////////////////////////////////////////////////////
enum Status
{
@@ -134,303 +134,383 @@ public : };
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
///
- /// \param Code : Response status code (InvalidResponse by default)
- /// \param Message : Response message (empty by default)
+ /// This constructor is used by the FTP client to build
+ /// the response.
+ ///
+ /// \param code Response status code
+ /// \param message Response message
///
////////////////////////////////////////////////////////////
- Response(Status Code = InvalidResponse, const std::string& Message = "");
+ explicit Response(Status code = InvalidResponse, const std::string& message = "");
////////////////////////////////////////////////////////////
- /// Convenience function to check if the response status code
- /// means a success
+ /// \brief Check if the status code means a success
+ ///
+ /// This function is defined for convenience, it is
+ /// equivalent to testing if the status code is < 400.
///
- /// \return True if status is success (code < 400)
+ /// \return True if the status is a success, false if it is a failure
///
////////////////////////////////////////////////////////////
- bool IsOk() const;
+ bool isOk() const;
////////////////////////////////////////////////////////////
- /// Get the response status code
+ /// \brief Get the status code of the response
///
/// \return Status code
///
////////////////////////////////////////////////////////////
- Status GetStatus() const;
+ Status getStatus() const;
////////////////////////////////////////////////////////////
- /// Get the full message contained in the response
+ /// \brief Get the full message contained in the response
///
/// \return The response message
///
////////////////////////////////////////////////////////////
- const std::string& GetMessage() const;
+ const std::string& getMessage() const;
private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- Status myStatus; ///< Status code returned from the server
- std::string myMessage; ///< Last message received from the server
+ Status m_status; ///< Status code returned from the server
+ std::string m_message; ///< Last message received from the server
};
////////////////////////////////////////////////////////////
- /// Specialization of FTP response returning a directory
+ /// \brief Specialization of FTP response returning a directory
+ ///
////////////////////////////////////////////////////////////
- class SFML_API DirectoryResponse : public Response
+ class SFML_NETWORK_API DirectoryResponse : public Response
{
public :
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
///
- /// \param Resp : Source response
+ /// \param response Source response
///
////////////////////////////////////////////////////////////
- DirectoryResponse(Response Resp);
+ DirectoryResponse(const Response& response);
////////////////////////////////////////////////////////////
- /// Get the directory returned in the response
+ /// \brief Get the directory returned in the response
///
/// \return Directory name
///
////////////////////////////////////////////////////////////
- const std::string& GetDirectory() const;
+ const std::string& getDirectory() const;
private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- std::string myDirectory; ///< Directory extracted from the response message
+ std::string m_directory; ///< Directory extracted from the response message
};
////////////////////////////////////////////////////////////
- /// Specialization of FTP response returning a filename lisiting
+ /// \brief Specialization of FTP response returning a
+ /// filename lisiting
////////////////////////////////////////////////////////////
- class SFML_API ListingResponse : public Response
+ class SFML_NETWORK_API ListingResponse : public Response
{
public :
////////////////////////////////////////////////////////////
- /// Default constructor
- ///
- /// \param Resp : Source response
- /// \param Data : Data containing the raw listing
- ///
- ////////////////////////////////////////////////////////////
- ListingResponse(Response Resp, const std::vector<char>& Data);
-
- ////////////////////////////////////////////////////////////
- /// Get the number of filenames in the listing
+ /// \brief Default constructor
///
- /// \return Total number of filenames
+ /// \param response Source response
+ /// \param data Data containing the raw listing
///
////////////////////////////////////////////////////////////
- std::size_t GetCount() const;
+ ListingResponse(const Response& response, const std::vector<char>& data);
////////////////////////////////////////////////////////////
- /// Get the Index-th filename in the directory
+ /// \brief Return the array of directory/file names
///
- /// \param Index : Index of the filename to get
- ///
- /// \return Index-th filename
+ /// \return Array containing the requested listing
///
////////////////////////////////////////////////////////////
- const std::string& GetFilename(std::size_t Index) const;
+ const std::vector<std::string>& getListing() const;
private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- std::vector<std::string> myFilenames; ///< Filenames extracted from the data
+ std::vector<std::string> m_listing; ///< Directory/file names extracted from the data
};
////////////////////////////////////////////////////////////
- /// Destructor -- close the connection with the server
+ /// \brief Destructor
+ ///
+ /// Automatically closes the connection with the server if
+ /// it is still opened.
///
////////////////////////////////////////////////////////////
~Ftp();
////////////////////////////////////////////////////////////
- /// Connect to the specified FTP server
+ /// \brief Connect to the specified FTP server
+ ///
+ /// The port has a default value of 21, which is the standard
+ /// port used by the FTP protocol. You shouldn't use a different
+ /// value, unless you really know what you do.
+ /// This function tries to connect to the server so it may take
+ /// a while to complete, especially if the server is not
+ /// reachable. To avoid blocking your application for too long,
+ /// you can use a timeout. The default value, Time::Zero, means that the
+ /// system timeout will be used (which is usually pretty long).
///
- /// \param Server : FTP server to connect to
- /// \param Port : Port used for connection (21 by default, standard FTP port)
- /// \param Timeout : Maximum time to wait, in seconds (0 by default, means no timeout)
+ /// \param server Name or address of the FTP server to connect to
+ /// \param port Port used for the connection
+ /// \param timeout Maximum time to wait
///
/// \return Server response to the request
///
+ /// \see disconnect
+ ///
////////////////////////////////////////////////////////////
- Response Connect(const IPAddress& Server, unsigned short Port = 21, float Timeout = 0.f);
+ Response connect(const IpAddress& server, unsigned short port = 21, Time timeout = Time::Zero);
////////////////////////////////////////////////////////////
- /// Log in using anonymous account
+ /// \brief Close the connection with the server
///
/// \return Server response to the request
///
+ /// \see connect
+ ///
////////////////////////////////////////////////////////////
- Response Login();
+ Response disconnect();
////////////////////////////////////////////////////////////
- /// Log in using a username and a password
+ /// \brief Log in using an anonymous account
///
- /// \param UserName : User name
- /// \param Password : Password
+ /// Logging in is mandatory after connecting to the server.
+ /// Users that are not logged in cannot perform any operation.
///
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
- Response Login(const std::string& UserName, const std::string& Password);
+ Response login();
////////////////////////////////////////////////////////////
- /// Close the connection with FTP server
+ /// \brief Log in using a username and a password
+ ///
+ /// Logging in is mandatory after connecting to the server.
+ /// Users that are not logged in cannot perform any operation.
+ ///
+ /// \param name User name
+ /// \param password Password
///
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
- Response Disconnect();
+ Response login(const std::string& name, const std::string& password);
////////////////////////////////////////////////////////////
- /// Send a null command just to prevent from being disconnected
+ /// \brief Send a null command to keep the connection alive
+ ///
+ /// This command is useful because the server may close the
+ /// connection automatically if no command is sent.
///
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
- Response KeepAlive();
+ Response keepAlive();
////////////////////////////////////////////////////////////
- /// Get the current working directory
+ /// \brief Get the current working directory
+ ///
+ /// The working directory is the root path for subsequent
+ /// operations involving directories and/or filenames.
///
/// \return Server response to the request
///
+ /// \see getDirectoryListing, changeDirectory, parentDirectory
+ ///
////////////////////////////////////////////////////////////
- DirectoryResponse GetWorkingDirectory();
+ DirectoryResponse getWorkingDirectory();
////////////////////////////////////////////////////////////
- /// Get the contents of the given directory
- /// (subdirectories and files)
+ /// \brief Get the contents of the given directory
+ ///
+ /// This function retrieves the sub-directories and files
+ /// contained in the given directory. It is not recursive.
+ /// The \a directory parameter is relative to the current
+ /// working directory.
///
- /// \param Directory : Directory to list ("" by default, the current one)
+ /// \param directory Directory to list
///
/// \return Server response to the request
///
+ /// \see getWorkingDirectory, changeDirectory, parentDirectory
+ ///
////////////////////////////////////////////////////////////
- ListingResponse GetDirectoryListing(const std::string& Directory = "");
+ ListingResponse getDirectoryListing(const std::string& directory = "");
////////////////////////////////////////////////////////////
- /// Change the current working directory
+ /// \brief Change the current working directory
+ ///
+ /// The new directory must be relative to the current one.
///
- /// \param Directory : New directory, relative to the current one
+ /// \param directory New working directory
///
/// \return Server response to the request
///
+ /// \see getWorkingDirectory, getDirectoryListing, parentDirectory
+ ///
////////////////////////////////////////////////////////////
- Response ChangeDirectory(const std::string& Directory);
+ Response changeDirectory(const std::string& directory);
////////////////////////////////////////////////////////////
- /// Go to the parent directory of the current one
+ /// \brief Go to the parent directory of the current one
///
/// \return Server response to the request
///
+ /// \see getWorkingDirectory, getDirectoryListing, changeDirectory
+ ///
////////////////////////////////////////////////////////////
- Response ParentDirectory();
+ Response parentDirectory();
////////////////////////////////////////////////////////////
- /// Create a new directory
+ /// \brief Create a new directory
+ ///
+ /// The new directory is created as a child of the current
+ /// working directory.
///
- /// \param Name : Name of the directory to create
+ /// \param name Name of the directory to create
///
/// \return Server response to the request
///
+ /// \see deleteDirectory
+ ///
////////////////////////////////////////////////////////////
- Response MakeDirectory(const std::string& Name);
+ Response createDirectory(const std::string& name);
////////////////////////////////////////////////////////////
- /// Remove an existing directory
+ /// \brief Remove an existing directory
///
- /// \param Name : Name of the directory to remove
+ /// The directory to remove must be relative to the
+ /// current working directory.
+ /// Use this function with caution, the directory will
+ /// be removed permanently!
+ ///
+ /// \param name Name of the directory to remove
///
/// \return Server response to the request
///
+ /// \see createDirectory
+ ///
////////////////////////////////////////////////////////////
- Response DeleteDirectory(const std::string& Name);
+ Response deleteDirectory(const std::string& name);
////////////////////////////////////////////////////////////
- /// Rename a file
+ /// \brief Rename an existing file
+ ///
+ /// The filenames must be relative to the current working
+ /// directory.
///
- /// \param File : File to rename
- /// \param NewName : New name
+ /// \param file File to rename
+ /// \param newName New name of the file
///
/// \return Server response to the request
///
+ /// \see deleteFile
+ ///
////////////////////////////////////////////////////////////
- Response RenameFile(const std::string& File, const std::string& NewName);
+ Response renameFile(const std::string& file, const std::string& newName);
////////////////////////////////////////////////////////////
- /// Remove an existing file
+ /// \brief Remove an existing file
+ ///
+ /// The file name must be relative to the current working
+ /// directory.
+ /// Use this function with caution, the file will be
+ /// removed permanently!
///
- /// \param Name : File to remove
+ /// \param name File to remove
///
/// \return Server response to the request
///
+ /// \see renameFile
+ ///
////////////////////////////////////////////////////////////
- Response DeleteFile(const std::string& Name);
+ Response deleteFile(const std::string& name);
////////////////////////////////////////////////////////////
- /// Download a file from the server
+ /// \brief Download a file from the server
+ ///
+ /// The filename of the distant file is relative to the
+ /// current working directory of the server, and the local
+ /// destination path is relative to the current directory
+ /// of your application.
///
- /// \param DistantFile : Path of the distant file to download
- /// \param DestPath : Where to put to file on the local computer
- /// \param Mode : Transfer mode (binary by default)
+ /// \param remoteFile Filename of the distant file to download
+ /// \param localPath Where to put to file on the local computer
+ /// \param mode Transfer mode
///
/// \return Server response to the request
///
+ /// \see upload
+ ///
////////////////////////////////////////////////////////////
- Response Download(const std::string& DistantFile, const std::string& DestPath, TransferMode Mode = Binary);
+ Response download(const std::string& remoteFile, const std::string& localPath, TransferMode mode = Binary);
////////////////////////////////////////////////////////////
- /// Upload a file to the server
+ /// \brief Upload a file to the server
///
- /// \param LocalFile : Path of the local file to upload
- /// \param DestPath : Where to put to file on the server
- /// \param Mode : Transfer mode (binary by default)
+ /// The name of the local file is relative to the current
+ /// working directory of your application, and the
+ /// remote path is relative to the current directory of the
+ /// FTP server.
+ ///
+ /// \param localFile Path of the local file to upload
+ /// \param remotePath Where to put to file on the server
+ /// \param mode Transfer mode
///
/// \return Server response to the request
///
+ /// \see download
+ ///
////////////////////////////////////////////////////////////
- Response Upload(const std::string& LocalFile, const std::string& DestPath, TransferMode Mode = Binary);
+ Response upload(const std::string& localFile, const std::string& remotePath, TransferMode mode = Binary);
private :
////////////////////////////////////////////////////////////
- /// Send a command to the FTP server
+ /// \brief Send a command to the FTP server
///
- /// \param Command : Command to send
- /// \param Parameter : Command parameter ("" by default)
+ /// \param command Command to send
+ /// \param parameter Command parameter
///
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
- Response SendCommand(const std::string& Command, const std::string& Parameter = "");
+ Response sendCommand(const std::string& command, const std::string& parameter = "");
////////////////////////////////////////////////////////////
- /// Receive a response from the server
- /// (usually after a command has been sent)
+ /// \brief Receive a response from the server
+ ///
+ /// This function must be called after each call to
+ /// SendCommand that expects a response.
///
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
- Response GetResponse();
+ Response getResponse();
////////////////////////////////////////////////////////////
- /// Utility class for exchanging datas with the server
- /// on the data channel
+ /// \brief Utility class for exchanging datas with the server
+ /// on the data channel
+ ///
////////////////////////////////////////////////////////////
class DataChannel;
@@ -439,10 +519,73 @@ private : ////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- SocketTCP myCommandSocket; ///< Socket holding the control connection with the server
+ TcpSocket m_commandSocket; ///< Socket holding the control connection with the server
};
} // namespace sf
#endif // SFML_FTP_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Ftp
+/// \ingroup network
+///
+/// sf::Ftp is a very simple FTP client that allows you
+/// to communicate with a FTP server. The FTP protocol allows
+/// you to manipulate a remote file system (list files,
+/// upload, download, create, remove, ...).
+///
+/// Using the FTP client consists of 4 parts:
+/// \li Connecting to the FTP server
+/// \li Logging in (either as a registered user or anonymously)
+/// \li Sending commands to the server
+/// \li Disconnecting (this part can be done implicitely by the destructor)
+///
+/// Every command returns a FTP response, which contains the
+/// status code as well as a message from the server. Some
+/// commands such as getWorkingDirectory and getDirectoryListing
+/// return additional data, and use a class derived from
+/// sf::Ftp::Response to provide this data.
+///
+/// All commands, especially upload and download, may take some
+/// time to complete. This is important to know if you don't want
+/// to block your application while the server is completing
+/// the task.
+///
+/// Usage example:
+/// \code
+/// // Create a new FTP client
+/// sf::Ftp ftp;
+///
+/// // Connect to the server
+/// sf::Ftp::Response response = ftp.connect("ftp://ftp.myserver.com");
+/// if (response.isOk())
+/// std::cout << "Connected" << std::endl;
+///
+/// // Log in
+/// response = ftp.login("laurent", "dF6Zm89D");
+/// if (response.isOk())
+/// std::cout << "Logged in" << std::endl;
+///
+/// // Print the working directory
+/// sf::Ftp::DirectoryResponse directory = ftp.getWorkingDirectory();
+/// if (directory.isOk())
+/// std::cout << "Working directory: " << directory.getDirectory() << std::endl;
+///
+/// // Create a new directory
+/// response = ftp.createDirectory("files");
+/// if (response.isOk())
+/// std::cout << "Created new directory" << std::endl;
+///
+/// // Upload a file to this new directory
+/// response = ftp.upload("local-path/file.txt", "files", sf::Ftp::Ascii);
+/// if (response.isOk())
+/// std::cout << "File uploaded" << std::endl;
+///
+/// // Disconnect from the server (optional)
+/// ftp.disconnect();
+/// \endcode
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Network/Http.hpp b/include/SFML/Network/Http.hpp index 54e5c1f..7338f5a 100755..100644 --- a/include/SFML/Network/Http.hpp +++ b/include/SFML/Network/Http.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,9 +28,11 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
+#include <SFML/Network/Export.hpp>
+#include <SFML/Network/IpAddress.hpp>
+#include <SFML/Network/TcpSocket.hpp>
#include <SFML/System/NonCopyable.hpp>
-#include <SFML/Network/IPAddress.hpp>
-#include <SFML/Network/SocketTCP.hpp>
+#include <SFML/System/Time.hpp>
#include <map>
#include <string>
@@ -38,25 +40,24 @@ namespace sf
{
////////////////////////////////////////////////////////////
-/// This class provides methods for manipulating the HTTP
-/// protocol (described in RFC 1945).
-/// It can connect to a website, get its files, send requests, etc.
+/// \brief A HTTP client
+///
////////////////////////////////////////////////////////////
-class SFML_API Http : NonCopyable
+class SFML_NETWORK_API Http : NonCopyable
{
public :
////////////////////////////////////////////////////////////
- /// This class wraps an HTTP request, which is basically :
- /// - a header with a method, a target URI, and a set of field/value pairs
- /// - an optional body (for POST requests)
+ /// \brief Define a HTTP request
+ ///
////////////////////////////////////////////////////////////
- class SFML_API Request
+ class SFML_NETWORK_API Request
{
public :
////////////////////////////////////////////////////////////
- /// Enumerate the available HTTP methods for a request
+ /// \brief Enumerate the available HTTP methods for a request
+ ///
////////////////////////////////////////////////////////////
enum Method
{
@@ -66,83 +67,106 @@ public : };
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
///
- /// \param RequestMethod : Method to use for the request (Get by default)
- /// \param URI : Target URI ("/" by default -- index page)
- /// \param Body : Content of the request's body (empty by default)
+ /// This constructor creates a GET request, with the root
+ /// URI ("/") and an empty body.
+ ///
+ /// \param uri Target URI
+ /// \param method Method to use for the request
+ /// \param body Content of the request's body
///
////////////////////////////////////////////////////////////
- Request(Method RequestMethod = Get, const std::string& URI = "/", const std::string& Body = "");
+ Request(const std::string& uri = "/", Method method = Get, const std::string& body = "");
////////////////////////////////////////////////////////////
- /// Set the value of a field; the field is added if it doesn't exist
+ /// \brief Set the value of a field
+ ///
+ /// The field is created if it doesn't exist. The name of
+ /// the field is case insensitive.
+ /// By default, a request doesn't contain any field (but the
+ /// mandatory fields are added later by the HTTP client when
+ /// sending the request).
///
- /// \param Field : Name of the field to set (case-insensitive)
- /// \param Value : Value of the field
+ /// \param field Name of the field to set
+ /// \param value Value of the field
///
////////////////////////////////////////////////////////////
- void SetField(const std::string& Field, const std::string& Value);
+ void setField(const std::string& field, const std::string& value);
////////////////////////////////////////////////////////////
- /// Set the request method.
- /// This parameter is Http::Request::Get by default
+ /// \brief Set the request method
///
- /// \param RequestMethod : Method to use for the request
+ /// See the Method enumeration for a complete list of all
+ /// the availale methods.
+ /// The method is Http::Request::Get by default.
+ ///
+ /// \param method Method to use for the request
///
////////////////////////////////////////////////////////////
- void SetMethod(Method RequestMethod);
+ void setMethod(Method method);
////////////////////////////////////////////////////////////
- /// Set the target URI of the request.
- /// This parameter is "/" by default
+ /// \brief Set the requested URI
+ ///
+ /// The URI is the resource (usually a web page or a file)
+ /// that you want to get or post.
+ /// The URI is "/" (the root page) by default.
///
- /// \param URI : URI to request, local to the host
+ /// \param uri URI to request, relative to the host
///
////////////////////////////////////////////////////////////
- void SetURI(const std::string& URI);
+ void setUri(const std::string& uri);
////////////////////////////////////////////////////////////
- /// Set the HTTP version of the request.
- /// This parameter is 1.0 by default
+ /// \brief Set the HTTP version for the request
+ ///
+ /// The HTTP version is 1.0 by default.
///
- /// \param Major : Major version number
- /// \param Minor : Minor version number
+ /// \param major Major HTTP version number
+ /// \param minor Minor HTTP version number
///
////////////////////////////////////////////////////////////
- void SetHttpVersion(unsigned int Major, unsigned int Minor);
+ void setHttpVersion(unsigned int major, unsigned int minor);
////////////////////////////////////////////////////////////
- /// Set the body of the request. This parameter is optional and
- /// makes sense only for POST requests.
- /// This parameter is empty by default
+ /// \brief Set the body of the request
///
- /// \param Body : Content of the request body
+ /// The body of a request is optional and only makes sense
+ /// for POST requests. It is ignored for all other methods.
+ /// The body is empty by default.
+ ///
+ /// \param body Content of the body
///
////////////////////////////////////////////////////////////
- void SetBody(const std::string& Body);
+ void setBody(const std::string& body);
private :
friend class Http;
////////////////////////////////////////////////////////////
- /// Get the string representation of the request header
+ /// \brief Prepare the final request to send to the server
+ ///
+ /// This is used internally by Http before sending the
+ /// request to the web server.
///
- /// \return String containing the request
+ /// \return String containing the request, ready to be sent
///
////////////////////////////////////////////////////////////
- std::string ToString() const;
+ std::string prepare() const;
////////////////////////////////////////////////////////////
- /// Check if the given field has been defined
+ /// \brief Check if the request defines a field
+ ///
+ /// This function uses case-insensitive comparisons.
///
- /// \param Field : Name of the field to check (case-insensitive)
+ /// \param field Name of the field to test
///
- /// \return True if the field exists
+ /// \return True if the field exists, false otherwise
///
////////////////////////////////////////////////////////////
- bool HasField(const std::string& Field) const;
+ bool hasField(const std::string& field) const;
////////////////////////////////////////////////////////////
// Types
@@ -152,34 +176,35 @@ public : ////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- FieldTable myFields; ///< Fields of the header
- Method myMethod; ///< Method to use for the request
- std::string myURI; ///< Target URI of the request
- unsigned int myMajorVersion; ///< Major HTTP version
- unsigned int myMinorVersion; ///< Minor HTTP version
- std::string myBody; ///< Body of the request
+ FieldTable m_fields; ///< Fields of the header associated to their value
+ Method m_method; ///< Method to use for the request
+ std::string m_uri; ///< Target URI of the request
+ unsigned int m_majorVersion; ///< Major HTTP version
+ unsigned int m_minorVersion; ///< Minor HTTP version
+ std::string m_body; ///< Body of the request
};
////////////////////////////////////////////////////////////
- /// This class wraps an HTTP response, which is basically :
- /// - a header with a status code and a set of field/value pairs
- /// - a body (the content of the requested resource)
+ /// \brief Define a HTTP response
+ ///
////////////////////////////////////////////////////////////
- class SFML_API Response
+ class SFML_NETWORK_API Response
{
public :
////////////////////////////////////////////////////////////
- /// Enumerate all the valid status codes returned in
- /// a HTTP response
+ /// \brief Enumerate all the valid status codes for a response
+ ///
////////////////////////////////////////////////////////////
enum Status
{
// 2xx: success
- Ok = 200, ///< Most common code returned when operation was successful
- Created = 201, ///< The resource has successfully been created
- Accepted = 202, ///< The request has been accepted, but will be processed later by the server
- NoContent = 204, ///< Sent when the server didn't send any data in return
+ Ok = 200, ///< Most common code returned when operation was successful
+ Created = 201, ///< The resource has successfully been created
+ Accepted = 202, ///< The request has been accepted, but will be processed later by the server
+ NoContent = 204, ///< The server didn't send any data in return
+ ResetContent = 205, ///< The server informs the client that it should clear the view (form) that caused the request to be sent
+ PartialContent = 206, ///< The server has sent a part of the resource, as a response to a partial GET request
// 3xx: redirection
MultipleChoices = 300, ///< The requested page can be accessed from several locations
@@ -188,16 +213,19 @@ public : NotModified = 304, ///< For conditionnal requests, means the requested page hasn't changed and doesn't need to be refreshed
// 4xx: client error
- BadRequest = 400, ///< The server couldn't understand the request (syntax error)
- Unauthorized = 401, ///< The requested page needs an authentification to be accessed
- Forbidden = 403, ///< The requested page cannot be accessed at all, even with authentification
- NotFound = 404, ///< The requested page doesn't exist
+ BadRequest = 400, ///< The server couldn't understand the request (syntax error)
+ Unauthorized = 401, ///< The requested page needs an authentification to be accessed
+ Forbidden = 403, ///< The requested page cannot be accessed at all, even with authentification
+ NotFound = 404, ///< The requested page doesn't exist
+ RangeNotSatisfiable = 407, ///< The server can't satisfy the partial GET request (with a "Range" header field)
// 5xx: server error
InternalServerError = 500, ///< The server encountered an unexpected error
NotImplemented = 501, ///< The server doesn't implement a requested feature
BadGateway = 502, ///< The gateway server has received an error from the source server
ServiceNotAvailable = 503, ///< The server is temporarily unavailable (overloaded, in maintenance, ...)
+ GatewayTimeout = 504, ///< The gateway server couldn't receive a response from the source server
+ VersionNotSupported = 505, ///< The server doesn't support the requested HTTP version
// 10xx: SFML custom codes
InvalidResponse = 1000, ///< Response is not a valid HTTP one
@@ -205,68 +233,88 @@ public : };
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
+ ///
+ /// Constructs an empty response.
///
////////////////////////////////////////////////////////////
Response();
////////////////////////////////////////////////////////////
- /// Get the value of a field
+ /// \brief Get the value of a field
///
- /// \param Field : Name of the field to get (case-insensitive)
+ /// If the field \a field is not found in the response header,
+ /// the empty string is returned. This function uses
+ /// case-insensitive comparisons.
+ ///
+ /// \param field Name of the field to get
///
/// \return Value of the field, or empty string if not found
///
////////////////////////////////////////////////////////////
- const std::string& GetField(const std::string& Field) const;
+ const std::string& getField(const std::string& field) const;
////////////////////////////////////////////////////////////
- /// Get the header's status code
+ /// \brief Get the response status code
+ ///
+ /// The status code should be the first thing to be checked
+ /// after receiving a response, it defines whether it is a
+ /// success, a failure or anything else (see the Status
+ /// enumeration).
///
- /// \return Header's status code
+ /// \return Status code of the response
///
////////////////////////////////////////////////////////////
- Status GetStatus() const;
+ Status getStatus() const;
////////////////////////////////////////////////////////////
- /// Get the major HTTP version number of the response
+ /// \brief Get the major HTTP version number of the response
///
- /// \return Major version number
+ /// \return Major HTTP version number
+ ///
+ /// \see getMinorHttpVersion
///
////////////////////////////////////////////////////////////
- unsigned int GetMajorHttpVersion() const;
+ unsigned int getMajorHttpVersion() const;
////////////////////////////////////////////////////////////
- /// Get the major HTTP version number of the response
+ /// \brief Get the minor HTTP version number of the response
+ ///
+ /// \return Minor HTTP version number
///
- /// \return Major version number
+ /// \see getMajorHttpVersion
///
////////////////////////////////////////////////////////////
- unsigned int GetMinorHttpVersion() const;
+ unsigned int getMinorHttpVersion() const;
////////////////////////////////////////////////////////////
- /// Get the body of the response. The body can contain :
- /// - the requested page (for GET requests)
- /// - a response from the server (for POST requests)
- /// - nothing (for HEAD requests)
- /// - an error message (in case of an error)
+ /// \brief Get the body of the response
+ ///
+ /// The body of a response may contain:
+ /// \li the requested page (for GET requests)
+ /// \li a response from the server (for POST requests)
+ /// \li nothing (for HEAD requests)
+ /// \li an error message (in case of an error)
///
/// \return The response body
///
////////////////////////////////////////////////////////////
- const std::string& GetBody() const;
+ const std::string& getBody() const;
private :
friend class Http;
////////////////////////////////////////////////////////////
- /// Construct the header from a response string
+ /// \brief Construct the header from a response string
+ ///
+ /// This function is used by Http to build the response
+ /// of a request.
///
- /// \param Data : Content of the response's header to parse
+ /// \param data Content of the response to parse
///
////////////////////////////////////////////////////////////
- void FromString(const std::string& Data);
+ void parse(const std::string& data);
////////////////////////////////////////////////////////////
// Types
@@ -276,65 +324,144 @@ public : ////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- FieldTable myFields; ///< Fields of the header
- Status myStatus; ///< Status code
- unsigned int myMajorVersion; ///< Major HTTP version
- unsigned int myMinorVersion; ///< Minor HTTP version
- std::string myBody; ///< Body of the response
+ FieldTable m_fields; ///< Fields of the header
+ Status m_status; ///< Status code
+ unsigned int m_majorVersion; ///< Major HTTP version
+ unsigned int m_minorVersion; ///< Minor HTTP version
+ std::string m_body; ///< Body of the response
};
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
///
////////////////////////////////////////////////////////////
Http();
////////////////////////////////////////////////////////////
- /// Construct the Http instance with the target host
+ /// \brief Construct the HTTP client with the target host
+ ///
+ /// This is equivalent to calling setHost(host, port).
+ /// The port has a default value of 0, which means that the
+ /// HTTP client will use the right port according to the
+ /// protocol used (80 for HTTP, 443 for HTTPS). You should
+ /// leave it like this unless you really need a port other
+ /// than the standard one, or use an unknown protocol.
///
- /// \param Host : Web server to connect to
- /// \param Port : Port to use for connection (0 by default -- use the standard port of the protocol used)
+ /// \param host Web server to connect to
+ /// \param port Port to use for connection
///
////////////////////////////////////////////////////////////
- Http(const std::string& Host, unsigned short Port = 0);
+ Http(const std::string& host, unsigned short port = 0);
////////////////////////////////////////////////////////////
- /// Set the target host
+ /// \brief Set the target host
///
- /// \param Host : Web server to connect to
- /// \param Port : Port to use for connection (0 by default -- use the standard port of the protocol used)
+ /// This function just stores the host address and port, it
+ /// doesn't actually connect to it until you send a request.
+ /// The port has a default value of 0, which means that the
+ /// HTTP client will use the right port according to the
+ /// protocol used (80 for HTTP, 443 for HTTPS). You should
+ /// leave it like this unless you really need a port other
+ /// than the standard one, or use an unknown protocol.
+ ///
+ /// \param host Web server to connect to
+ /// \param port Port to use for connection
///
////////////////////////////////////////////////////////////
- void SetHost(const std::string& Host, unsigned short Port = 0);
+ void setHost(const std::string& host, unsigned short port = 0);
////////////////////////////////////////////////////////////
- /// Send a HTTP request and return the server's response.
- /// You must be connected to a host before sending requests.
- /// Any missing mandatory header field will be added with an appropriate value.
- /// Warning : this function waits for the server's response and may
+ /// \brief Send a HTTP request and return the server's response.
+ ///
+ /// You must have a valid host before sending a request (see setHost).
+ /// Any missing mandatory header field in the request will be added
+ /// with an appropriate value.
+ /// Warning: this function waits for the server's response and may
/// not return instantly; use a thread if you don't want to block your
- /// application.
+ /// application, or use a timeout to limit the time to wait. A value
+ /// of Time::Zero means that the client will use the system defaut timeout
+ /// (which is usually pretty long).
///
- /// \param Req : Request to send
- /// \param Timeout : Maximum time to wait, in seconds (0 by default, means no timeout)
+ /// \param request Request to send
+ /// \param timeout Maximum time to wait
///
/// \return Server's response
///
////////////////////////////////////////////////////////////
- Response SendRequest(const Request& Req, float Timeout = 0.f);
+ Response sendRequest(const Request& request, Time timeout = Time::Zero);
private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- SocketTCP myConnection; ///< Connection to the host
- IPAddress myHost; ///< Web host address
- std::string myHostName; ///< Web host name
- unsigned short myPort; ///< Port used for connection with host
+ TcpSocket m_connection; ///< Connection to the host
+ IpAddress m_host; ///< Web host address
+ std::string m_hostName; ///< Web host name
+ unsigned short m_port; ///< Port used for connection with host
};
} // namespace sf
#endif // SFML_HTTP_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Http
+/// \ingroup network
+///
+/// sf::Http is a very simple HTTP client that allows you
+/// to communicate with a web server. You can retrieve
+/// web pages, send data to an interactive resource,
+/// download a remote file, etc.
+///
+/// The HTTP client is split into 3 classes:
+/// \li sf::Http::Request
+/// \li sf::Http::Response
+/// \li sf::Http
+///
+/// sf::Http::Request builds the request that will be
+/// sent to the server. A request is made of:
+/// \li a method (what you want to do)
+/// \li a target URI (usually the name of the web page or file)
+/// \li one or more header fields (options that you can pass to the server)
+/// \li an optional body (for POST requests)
+///
+/// sf::Http::Response parse the response from the web server
+/// and provides getters to read them. The response contains:
+/// \li a status code
+/// \li header fields (that may be answers to the ones that you requested)
+/// \li a body, which contains the contents of the requested resource
+///
+/// sf::Http provides a simple function, SendRequest, to send a
+/// sf::Http::Request and return the corresponding sf::Http::Response
+/// from the server.
+///
+/// Usage example:
+/// \code
+/// // Create a new HTTP client
+/// sf::Http http;
+///
+/// // We'll work on http://www.sfml-dev.org
+/// http.setHost("http://www.sfml-dev.org");
+///
+/// // Prepare a request to get the 'features.php' page
+/// sf::Http::Request request("features.php");
+///
+/// // Send the request
+/// sf::Http::Response response = http.sendRequest(request);
+///
+/// // Check the status code and display the result
+/// sf::Http::Response::Status status = response.getStatus();
+/// if (status == sf::Http::Response::Ok)
+/// {
+/// std::cout << response.getBody() << std::endl;
+/// }
+/// else
+/// {
+/// std::cout << "Error " << status << std::endl;
+/// }
+/// \endcode
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Network/IPAddress.hpp b/include/SFML/Network/IPAddress.hpp deleted file mode 100755 index 638dc47..0000000 --- a/include/SFML/Network/IPAddress.hpp +++ /dev/null @@ -1,231 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_IPADDRESS_HPP
-#define SFML_IPADDRESS_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
-#include <istream>
-#include <ostream>
-#include <string>
-
-
-namespace sf
-{
-////////////////////////////////////////////////////////////
-/// IPAddress provides easy manipulation of IP v4 addresses
-////////////////////////////////////////////////////////////
-class SFML_API IPAddress
-{
-public :
-
- ////////////////////////////////////////////////////////////
- /// Default constructor -- constructs an invalid address
- ///
- ////////////////////////////////////////////////////////////
- IPAddress();
-
- ////////////////////////////////////////////////////////////
- /// Construct the address from a string
- ///
- /// \param Address : IP address ("xxx.xxx.xxx.xxx") or network name
- ///
- ////////////////////////////////////////////////////////////
- IPAddress(const std::string& Address);
-
- ////////////////////////////////////////////////////////////
- /// Construct the address from a C-style string ;
- /// Needed for implicit conversions from literal strings to IPAddress to work
- ///
- /// \param Address : IP address ("xxx.xxx.xxx.xxx") or network name
- ///
- ////////////////////////////////////////////////////////////
- IPAddress(const char* Address);
-
- ////////////////////////////////////////////////////////////
- /// Construct the address from 4 bytes
- ///
- /// \param Byte0 : First byte of the address
- /// \param Byte1 : Second byte of the address
- /// \param Byte2 : Third byte of the address
- /// \param Byte3 : Fourth byte of the address
- ///
- ////////////////////////////////////////////////////////////
- IPAddress(Uint8 Byte0, Uint8 Byte1, Uint8 Byte2, Uint8 Byte3);
-
- ////////////////////////////////////////////////////////////
- /// Construct the address from a 32-bits integer
- ///
- /// \param Address : 4 bytes of the address packed into a 32-bits integer
- ///
- ////////////////////////////////////////////////////////////
- IPAddress(Uint32 Address);
-
- ////////////////////////////////////////////////////////////
- /// Tell if the address is a valid one
- ///
- /// \return True if address has a valid syntax
- ///
- ////////////////////////////////////////////////////////////
- bool IsValid() const;
-
- ////////////////////////////////////////////////////////////
- /// Get a string representation of the address
- ///
- /// \return String representation of the IP address ("xxx.xxx.xxx.xxx")
- ///
- ////////////////////////////////////////////////////////////
- std::string ToString() const;
-
- ////////////////////////////////////////////////////////////
- /// Get an integer representation of the address
- ///
- /// \return 32-bits integer containing the 4 bytes of the address, in system endianness
- ///
- ////////////////////////////////////////////////////////////
- Uint32 ToInteger() const;
-
- ////////////////////////////////////////////////////////////
- /// Get the computer's local IP address (from the LAN point of view)
- ///
- /// \return Local IP address
- ///
- ////////////////////////////////////////////////////////////
- static IPAddress GetLocalAddress();
-
- ////////////////////////////////////////////////////////////
- /// Get the computer's public IP address (from the web point of view).
- /// The only way to get a public address is to ask it to a
- /// distant website ; as a consequence, this function may be
- /// very slow -- use it as few as possible !
- ///
- /// \param Timeout : Maximum time to wait, in seconds (0 by default : no timeout)
- ///
- /// \return Public IP address
- ///
- ////////////////////////////////////////////////////////////
- static IPAddress GetPublicAddress(float Timeout = 0.f);
-
- ////////////////////////////////////////////////////////////
- /// Comparison operator ==
- ///
- /// \param Other : Address to compare
- ///
- /// \return True if *this == Other
- ///
- ////////////////////////////////////////////////////////////
- bool operator ==(const IPAddress& Other) const;
-
- ////////////////////////////////////////////////////////////
- /// Comparison operator !=
- ///
- /// \param Other : Address to compare
- ///
- /// \return True if *this != Other
- ///
- ////////////////////////////////////////////////////////////
- bool operator !=(const IPAddress& Other) const;
-
- ////////////////////////////////////////////////////////////
- /// Comparison operator <
- ///
- /// \param Other : Address to compare
- ///
- /// \return True if *this < Other
- ///
- ////////////////////////////////////////////////////////////
- bool operator <(const IPAddress& Other) const;
-
- ////////////////////////////////////////////////////////////
- /// Comparison operator >
- ///
- /// \param Other : Address to compare
- ///
- /// \return True if *this > Other
- ///
- ////////////////////////////////////////////////////////////
- bool operator >(const IPAddress& Other) const;
-
- ////////////////////////////////////////////////////////////
- /// Comparison operator <=
- ///
- /// \param Other : Address to compare
- ///
- /// \return True if *this <= Other
- ///
- ////////////////////////////////////////////////////////////
- bool operator <=(const IPAddress& Other) const;
-
- ////////////////////////////////////////////////////////////
- /// Comparison operator >=
- ///
- /// \param Other : Address to compare
- ///
- /// \return True if *this >= Other
- ///
- ////////////////////////////////////////////////////////////
- bool operator >=(const IPAddress& Other) const;
-
- ////////////////////////////////////////////////////////////
- // Static member data
- ////////////////////////////////////////////////////////////
- static const IPAddress LocalHost; ///< Local host address (to connect to the same computer)
-
-private :
-
- ////////////////////////////////////////////////////////////
- // Member data
- ////////////////////////////////////////////////////////////
- Uint32 myAddress; ///< Address stored as an unsigned 32 bits integer
-};
-
-////////////////////////////////////////////////////////////
-/// Operator >> overload to extract an address from an input stream
-///
-/// \param Stream : Input stream
-/// \param Address : Address to extract
-///
-/// \return Reference to the input stream
-///
-////////////////////////////////////////////////////////////
-SFML_API std::istream& operator >>(std::istream& Stream, IPAddress& Address);
-
-////////////////////////////////////////////////////////////
-/// Operator << overload to print an address to an output stream
-///
-/// \param Stream : Output stream
-/// \param Address : Address to print
-///
-/// \return Reference to the output stream
-///
-////////////////////////////////////////////////////////////
-SFML_API std::ostream& operator <<(std::ostream& Stream, const IPAddress& Address);
-
-} // namespace sf
-
-
-#endif // SFML_IPADDRESS_HPP
diff --git a/include/SFML/Network/IpAddress.hpp b/include/SFML/Network/IpAddress.hpp new file mode 100644 index 0000000..15c4ac3 --- /dev/null +++ b/include/SFML/Network/IpAddress.hpp @@ -0,0 +1,316 @@ +////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+// you must not claim that you wrote the original software.
+// If you use this software in a product, an acknowledgment
+// in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+// and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_IPADDRESS_HPP
+#define SFML_IPADDRESS_HPP
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Network/Export.hpp>
+#include <SFML/System/Time.hpp>
+#include <istream>
+#include <ostream>
+#include <string>
+
+
+namespace sf
+{
+////////////////////////////////////////////////////////////
+/// \brief Encapsulate an IPv4 network address
+///
+////////////////////////////////////////////////////////////
+class SFML_NETWORK_API IpAddress
+{
+public :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Default constructor
+ ///
+ /// This constructor creates an empty (invalid) address
+ ///
+ ////////////////////////////////////////////////////////////
+ IpAddress();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Construct the address from a string
+ ///
+ /// Here \a address can be either a decimal address
+ /// (ex: "192.168.1.56") or a network name (ex: "localhost").
+ ///
+ /// \param address IP address or network name
+ ///
+ ////////////////////////////////////////////////////////////
+ IpAddress(const std::string& address);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Construct the address from a string
+ ///
+ /// Here \a address can be either a decimal address
+ /// (ex: "192.168.1.56") or a network name (ex: "localhost").
+ /// This is equivalent to the constructor taking a std::string
+ /// parameter, it is defined for convenience so that the
+ /// implicit conversions from literal strings to IpAddress work.
+ ///
+ /// \param address IP address or network name
+ ///
+ ////////////////////////////////////////////////////////////
+ IpAddress(const char* address);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Construct the address from 4 bytes
+ ///
+ /// Calling IpAddress(a, b, c, d) is equivalent to calling
+ /// IpAddress("a.b.c.d"), but safer as it doesn't have to
+ /// parse a string to get the address components.
+ ///
+ /// \param byte0 First byte of the address
+ /// \param byte1 Second byte of the address
+ /// \param byte2 Third byte of the address
+ /// \param byte3 Fourth byte of the address
+ ///
+ ////////////////////////////////////////////////////////////
+ IpAddress(Uint8 byte0, Uint8 byte1, Uint8 byte2, Uint8 byte3);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Construct the address from a 32-bits integer
+ ///
+ /// This constructor uses the internal representation of
+ /// the address directly. It should be used for optimization
+ /// purposes, and only if you got that representation from
+ /// IpAddress::ToInteger().
+ ///
+ /// \param address 4 bytes of the address packed into a 32-bits integer
+ ///
+ /// \see toInteger
+ ///
+ ////////////////////////////////////////////////////////////
+ explicit IpAddress(Uint32 address);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get a string representation of the address
+ ///
+ /// The returned string is the decimal representation of the
+ /// IP address (like "192.168.1.56"), even if it was constructed
+ /// from a host name.
+ ///
+ /// \return String representation of the address
+ ///
+ /// \see toInteger
+ ///
+ ////////////////////////////////////////////////////////////
+ std::string toString() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get an integer representation of the address
+ ///
+ /// The returned number is the internal representation of the
+ /// address, and should be used for optimization purposes only
+ /// (like sending the address through a socket).
+ /// The integer produced by this function can then be converted
+ /// back to a sf::IpAddress with the proper constructor.
+ ///
+ /// \return 32-bits unsigned integer representation of the address
+ ///
+ /// \see toString
+ ///
+ ////////////////////////////////////////////////////////////
+ Uint32 toInteger() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the computer's local address
+ ///
+ /// The local address is the address of the computer from the
+ /// LAN point of view, i.e. something like 192.168.1.56. It is
+ /// meaningful only for communications over the local network.
+ /// Unlike getPublicAddress, this function is fast and may be
+ /// used safely anywhere.
+ ///
+ /// \return Local IP address of the computer
+ ///
+ /// \see getPublicAddress
+ ///
+ ////////////////////////////////////////////////////////////
+ static IpAddress getLocalAddress();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the computer's public address
+ ///
+ /// The public address is the address of the computer from the
+ /// internet point of view, i.e. something like 89.54.1.169.
+ /// It is necessary for communications over the world wide web.
+ /// The only way to get a public address is to ask it to a
+ /// distant website; as a consequence, this function depends on
+ /// both your network connection and the server, and may be
+ /// very slow. You should use it as few as possible. Because
+ /// this function depends on the network connection and on a distant
+ /// server, you may use a time limit if you don't want your program
+ /// to be possibly stuck waiting in case there is a problem; this
+ /// limit is deactivated by default.
+ ///
+ /// \param timeout Maximum time to wait
+ ///
+ /// \return Public IP address of the computer
+ ///
+ /// \see getLocalAddress
+ ///
+ ////////////////////////////////////////////////////////////
+ static IpAddress getPublicAddress(Time timeout = Time::Zero);
+
+ ////////////////////////////////////////////////////////////
+ // Static member data
+ ////////////////////////////////////////////////////////////
+ static const IpAddress None; ///< Value representing an empty/invalid address
+ static const IpAddress LocalHost; ///< The "localhost" address (for connecting a computer to itself locally)
+ static const IpAddress Broadcast; ///< The "broadcast" address (for sending UDP messages to everyone on a local network)
+
+private :
+
+ ////////////////////////////////////////////////////////////
+ // Member data
+ ////////////////////////////////////////////////////////////
+ Uint32 m_address; ///< Address stored as an unsigned 32 bits integer
+};
+
+////////////////////////////////////////////////////////////
+/// \brief Overload of == operator to compare two IP addresses
+///
+/// \param left Left operand (a IP address)
+/// \param right Right operand (a IP address)
+///
+/// \return True if both addresses are equal
+///
+////////////////////////////////////////////////////////////
+SFML_NETWORK_API bool operator ==(const IpAddress& left, const IpAddress& right);
+
+////////////////////////////////////////////////////////////
+/// \brief Overload of != operator to compare two IP addresses
+///
+/// \param left Left operand (a IP address)
+/// \param right Right operand (a IP address)
+///
+/// \return True if both addresses are different
+///
+////////////////////////////////////////////////////////////
+SFML_NETWORK_API bool operator !=(const IpAddress& left, const IpAddress& right);
+
+////////////////////////////////////////////////////////////
+/// \brief Overload of < operator to compare two IP addresses
+///
+/// \param left Left operand (a IP address)
+/// \param right Right operand (a IP address)
+///
+/// \return True if \a left is lesser than \a right
+///
+////////////////////////////////////////////////////////////
+SFML_NETWORK_API bool operator <(const IpAddress& left, const IpAddress& right);
+
+////////////////////////////////////////////////////////////
+/// \brief Overload of > operator to compare two IP addresses
+///
+/// \param left Left operand (a IP address)
+/// \param right Right operand (a IP address)
+///
+/// \return True if \a left is greater than \a right
+///
+////////////////////////////////////////////////////////////
+SFML_NETWORK_API bool operator >(const IpAddress& left, const IpAddress& right);
+
+////////////////////////////////////////////////////////////
+/// \brief Overload of <= operator to compare two IP addresses
+///
+/// \param left Left operand (a IP address)
+/// \param right Right operand (a IP address)
+///
+/// \return True if \a left is lesser or equal than \a right
+///
+////////////////////////////////////////////////////////////
+SFML_NETWORK_API bool operator <=(const IpAddress& left, const IpAddress& right);
+
+////////////////////////////////////////////////////////////
+/// \brief Overload of >= operator to compare two IP addresses
+///
+/// \param left Left operand (a IP address)
+/// \param right Right operand (a IP address)
+///
+/// \return True if \a left is greater or equal than \a right
+///
+////////////////////////////////////////////////////////////
+SFML_NETWORK_API bool operator >=(const IpAddress& left, const IpAddress& right);
+
+////////////////////////////////////////////////////////////
+/// \brief Overload of >> operator to extract an IP address from an input stream
+///
+/// \param stream Input stream
+/// \param address IP address to extract
+///
+/// \return Reference to the input stream
+///
+////////////////////////////////////////////////////////////
+SFML_NETWORK_API std::istream& operator >>(std::istream& stream, IpAddress& address);
+
+////////////////////////////////////////////////////////////
+/// \brief Overload of << operator to print an IP address to an output stream
+///
+/// \param stream Output stream
+/// \param address IP address to print
+///
+/// \return Reference to the output stream
+///
+////////////////////////////////////////////////////////////
+SFML_NETWORK_API std::ostream& operator <<(std::ostream& stream, const IpAddress& address);
+
+} // namespace sf
+
+
+#endif // SFML_IPADDRESS_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::IpAddress
+/// \ingroup network
+///
+/// sf::IpAddress is a utility class for manipulating network
+/// addresses. It provides a set a implicit constructors and
+/// conversion functions to easily build or transform an IP
+/// address from/to various representations.
+///
+/// Usage example:
+/// \code
+/// sf::IpAddress a0; // an invalid address
+/// sf::IpAddress a1 = sf::IpAddress::None; // an invalid address (same as a0)
+/// sf::IpAddress a2("127.0.0.1"); // the local host address
+/// sf::IpAddress a3 = sf::IpAddress::Broadcast; // the broadcast address
+/// sf::IpAddress a4(192, 168, 1, 56); // a local address
+/// sf::IpAddress a5("my_computer"); // a local address created from a network name
+/// sf::IpAddress a6("89.54.1.169"); // a distant address
+/// sf::IpAddress a7("www.google.com"); // a distant address created from a network name
+/// sf::IpAddress a8 = sf::IpAddress::getLocalAddress(); // my address on the local network
+/// sf::IpAddress a9 = sf::IpAddress::getPublicAddress(); // my address on the internet
+/// \endcode
+///
+/// Note that sf::IpAddress currently doesn't support IPv6
+/// nor other types of network addresses.
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Network/Packet.hpp b/include/SFML/Network/Packet.hpp index 9c5463f..2d3e201 100755..100644 --- a/include/SFML/Network/Packet.hpp +++ b/include/SFML/Network/Packet.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,160 +28,380 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
+#include <SFML/Network/Export.hpp>
#include <string>
#include <vector>
namespace sf
{
+class String;
+class TcpSocket;
+class UdpSocket;
+
////////////////////////////////////////////////////////////
-/// Packet wraps data to send / to receive through the network
+/// \brief Utility class to build blocks of data to transfer
+/// over the network
+///
////////////////////////////////////////////////////////////
-class SFML_API Packet
+class SFML_NETWORK_API Packet
{
+ // A bool-like type that cannot be converted to integer or pointer types
+ typedef bool (Packet::*BoolType)(std::size_t);
+
public :
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
+ ///
+ /// Creates an empty packet.
///
////////////////////////////////////////////////////////////
Packet();
////////////////////////////////////////////////////////////
- /// Virtual destructor
+ /// \brief Virtual destructor
///
////////////////////////////////////////////////////////////
virtual ~Packet();
////////////////////////////////////////////////////////////
- /// Append data to the end of the packet
+ /// \brief Append data to the end of the packet
///
- /// \param Data : Pointer to the bytes to append
- /// \param SizeInBytes : Number of bytes to append
+ /// \param data Pointer to the sequence of bytes to append
+ /// \param sizeInBytes Number of bytes to append
+ ///
+ /// \see clear
///
////////////////////////////////////////////////////////////
- void Append(const void* Data, std::size_t SizeInBytes);
+ void append(const void* data, std::size_t sizeInBytes);
////////////////////////////////////////////////////////////
- /// Clear the packet data
+ /// \brief Clear the packet
+ ///
+ /// After calling Clear, the packet is empty.
+ ///
+ /// \see append
///
////////////////////////////////////////////////////////////
- void Clear();
+ void clear();
////////////////////////////////////////////////////////////
- /// Get a pointer to the data contained in the packet
- /// Warning : the returned pointer may be invalid after you
- /// append data to the packet
+ /// \brief Get a pointer to the data contained in the packet
+ ///
+ /// Warning: the returned pointer may become invalid after
+ /// you append data to the packet, therefore it should never
+ /// be stored.
+ /// The return pointer is NULL if the packet is empty.
///
/// \return Pointer to the data
///
+ /// \see getDataSize
+ ///
////////////////////////////////////////////////////////////
- const char* GetData() const;
+ const void* getData() const;
////////////////////////////////////////////////////////////
- /// Get the size of the data contained in the packet
+ /// \brief Get the size of the data contained in the packet
+ ///
+ /// This function returns the number of bytes pointed to by
+ /// what getData returns.
///
/// \return Data size, in bytes
///
+ /// \see getData
+ ///
////////////////////////////////////////////////////////////
- std::size_t GetDataSize() const;
+ std::size_t getDataSize() const;
////////////////////////////////////////////////////////////
- /// Tell if the reading position has reached the end of the packet
+ /// \brief Tell if the reading position has reached the
+ /// end of the packet
///
- /// \return True if all data have been read into the packet
+ /// This function is useful to know if there is some data
+ /// left to be read, without actually reading it.
+ ///
+ /// \return True if all data was read, false otherwise
+ ///
+ /// \see operator bool
///
////////////////////////////////////////////////////////////
- bool EndOfPacket() const;
+ bool endOfPacket() const;
+
+public:
////////////////////////////////////////////////////////////
- /// Return the validity of packet
+ /// \brief Test the validity of the packet, for reading
+ ///
+ /// This operator allows to test the packet as a boolean
+ /// variable, to check if a reading operation was successful.
+ ///
+ /// A packet will be in an invalid state if it has no more
+ /// data to read.
+ ///
+ /// This behaviour is the same as standard C++ streams.
+ ///
+ /// Usage example:
+ /// \code
+ /// float x;
+ /// packet >> x;
+ /// if (packet)
+ /// {
+ /// // ok, x was extracted successfully
+ /// }
+ ///
+ /// // -- or --
+ ///
+ /// float x;
+ /// if (packet >> x)
+ /// {
+ /// // ok, x was extracted successfully
+ /// }
+ /// \endcode
+ ///
+ /// Don't focus on the return type, it's equivalent to bool but
+ /// it disallows unwanted implicit conversions to integer or
+ /// pointer types.
///
/// \return True if last data extraction from packet was successful
///
+ /// \see endOfPacket
+ ///
////////////////////////////////////////////////////////////
- operator bool() const;
+ operator BoolType() const;
////////////////////////////////////////////////////////////
- /// Operator >> overloads to extract data from the packet
+ /// Overloads of operator >> to read data from the packet
///
////////////////////////////////////////////////////////////
- Packet& operator >>(bool& Data);
- Packet& operator >>(Int8& Data);
- Packet& operator >>(Uint8& Data);
- Packet& operator >>(Int16& Data);
- Packet& operator >>(Uint16& Data);
- Packet& operator >>(Int32& Data);
- Packet& operator >>(Uint32& Data);
- Packet& operator >>(float& Data);
- Packet& operator >>(double& Data);
- Packet& operator >>(char* Data);
- Packet& operator >>(std::string& Data);
- Packet& operator >>(wchar_t* Data);
- Packet& operator >>(std::wstring& Data);
+ Packet& operator >>(bool& data);
+ Packet& operator >>(Int8& data);
+ Packet& operator >>(Uint8& data);
+ Packet& operator >>(Int16& data);
+ Packet& operator >>(Uint16& data);
+ Packet& operator >>(Int32& data);
+ Packet& operator >>(Uint32& data);
+ Packet& operator >>(float& data);
+ Packet& operator >>(double& data);
+ Packet& operator >>(char* data);
+ Packet& operator >>(std::string& data);
+ Packet& operator >>(wchar_t* data);
+ Packet& operator >>(std::wstring& data);
+ Packet& operator >>(String& data);
////////////////////////////////////////////////////////////
- /// Operator << overloads to put data into the packet
+ /// Overloads of operator << to write data into the packet
///
////////////////////////////////////////////////////////////
- Packet& operator <<(bool Data);
- Packet& operator <<(Int8 Data);
- Packet& operator <<(Uint8 Data);
- Packet& operator <<(Int16 Data);
- Packet& operator <<(Uint16 Data);
- Packet& operator <<(Int32 Data);
- Packet& operator <<(Uint32 Data);
- Packet& operator <<(float Data);
- Packet& operator <<(double Data);
- Packet& operator <<(const char* Data);
- Packet& operator <<(const std::string& Data);
- Packet& operator <<(const wchar_t* Data);
- Packet& operator <<(const std::wstring& Data);
+ Packet& operator <<(bool data);
+ Packet& operator <<(Int8 data);
+ Packet& operator <<(Uint8 data);
+ Packet& operator <<(Int16 data);
+ Packet& operator <<(Uint16 data);
+ Packet& operator <<(Int32 data);
+ Packet& operator <<(Uint32 data);
+ Packet& operator <<(float data);
+ Packet& operator <<(double data);
+ Packet& operator <<(const char* data);
+ Packet& operator <<(const std::string& data);
+ Packet& operator <<(const wchar_t* data);
+ Packet& operator <<(const std::wstring& data);
+ Packet& operator <<(const String& data);
-private :
+protected:
- friend class SocketTCP;
- friend class SocketUDP;
+ friend class TcpSocket;
+ friend class UdpSocket;
////////////////////////////////////////////////////////////
- /// Check if the packet can extract a given size of bytes
+ /// \brief Called before the packet is sent over the network
+ ///
+ /// This function can be defined by derived classes to
+ /// transform the data before it is sent; this can be
+ /// used for compression, encryption, etc.
+ /// The function must return a pointer to the modified data,
+ /// as well as the number of bytes pointed.
+ /// The default implementation provides the packet's data
+ /// without transforming it.
///
- /// \param Size : Size to check
+ /// \param size Variable to fill with the size of data to send
+ ///
+ /// \return Pointer to the array of bytes to send
///
- /// \return True if Size bytes can be read from the packet's data
+ /// \see onReceive
///
////////////////////////////////////////////////////////////
- bool CheckSize(std::size_t Size);
+ virtual const void* onSend(std::size_t& size);
////////////////////////////////////////////////////////////
- /// Called before the packet is sent to the network
+ /// \brief Called after the packet is received over the network
///
- /// \param DataSize : Variable to fill with the size of data to send
+ /// This function can be defined by derived classes to
+ /// transform the data after it is received; this can be
+ /// used for uncompression, decryption, etc.
+ /// The function receives a pointer to the received data,
+ /// and must fill the packet with the transformed bytes.
+ /// The default implementation fills the packet directly
+ /// without transforming the data.
///
- /// \return Pointer to the array of bytes to send
+ /// \param data Pointer to the received bytes
+ /// \param size Number of bytes
+ ///
+ /// \see onSend
///
////////////////////////////////////////////////////////////
- virtual const char* OnSend(std::size_t& DataSize);
+ virtual void onReceive(const void* data, std::size_t size);
+
+private :
////////////////////////////////////////////////////////////
- /// Called after the packet has been received from the network
+ /// Disallow comparisons between packets
///
- /// \param Data : Pointer to the array of received bytes
- /// \param DataSize : Size of the array of bytes
+ ////////////////////////////////////////////////////////////
+ bool operator ==(const Packet& right) const;
+ bool operator !=(const Packet& right) const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Check if the packet can extract a given number of bytes
+ ///
+ /// This function updates accordingly the state of the packet.
+ ///
+ /// \param size Size to check
+ ///
+ /// \return True if \a size bytes can be read from the packet
///
////////////////////////////////////////////////////////////
- virtual void OnReceive(const char* Data, std::size_t DataSize);
+ bool checkSize(std::size_t size);
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- std::vector<char> myData; ///< Data stored in the packet
- std::size_t myReadPos; ///< Current reading position in the packet
- bool myIsValid; ///< Reading state of the packet
+ std::vector<char> m_data; ///< Data stored in the packet
+ std::size_t m_readPos; ///< Current reading position in the packet
+ bool m_isValid; ///< Reading state of the packet
};
} // namespace sf
#endif // SFML_PACKET_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Packet
+/// \ingroup network
+///
+/// Packets provide a safe and easy way to serialize data,
+/// in order to send it over the network using sockets
+/// (sf::TcpSocket, sf::UdpSocket).
+///
+/// Packets solve 2 fundamental problems that arise when
+/// transfering data over the network:
+/// \li data is interpreted correctly according to the endianness
+/// \li the bounds of the packet are preserved (one send == one receive)
+///
+/// The sf::Packet class provides both input and output modes.
+/// It is designed to follow the behaviour of standard C++ streams,
+/// using operators >> and << to extract and insert data.
+///
+/// It is recommended to use only fixed-size types (like sf::Int32, etc.),
+/// to avoid possible differences between the sender and the receiver.
+/// Indeed, the native C++ types may have different sizes on two platforms
+/// and your data may be corrupted if that happens.
+///
+/// Usage example:
+/// \code
+/// sf::Uint32 x = 24;
+/// std::string s = "hello";
+/// double d = 5.89;
+///
+/// // Group the variables to send into a packet
+/// sf::Packet packet;
+/// packet << x << s << d;
+///
+/// // Send it over the network (socket is a valid sf::TcpSocket)
+/// socket.send(packet);
+///
+/// -----------------------------------------------------------------
+///
+/// // Receive the packet at the other end
+/// sf::Packet packet;
+/// socket.receive(packet);
+///
+/// // Extract the variables contained in the packet
+/// sf::Uint32 x;
+/// std::string s;
+/// double d;
+/// if (packet >> x >> s >> d)
+/// {
+/// // Data extracted successfully...
+/// }
+/// \endcode
+///
+/// Packets have built-in operator >> and << overloads for
+/// standard types:
+/// \li bool
+/// \li fixed-size integer types (sf::Int8/16/32, sf::Uint8/16/32)
+/// \li floating point numbers (float, double)
+/// \li string types (char*, wchar_t*, std::string, std::wstring, sf::String)
+///
+/// Like standard streams, it is also possible to define your own
+/// overloads of operators >> and << in order to handle your
+/// custom types.
+///
+/// \code
+/// struct MyStruct
+/// {
+/// float number;
+/// sf::Int8 integer;
+/// std::string str;
+/// };
+///
+/// sf::Packet& operator <<(sf::Packet& packet, const MyStruct& m)
+/// {
+/// return packet << m.number << m.integer << m.str;
+/// }
+///
+/// sf::Packet& operator >>(sf::Packet& packet, MyStruct& m)
+/// {
+/// return packet >> m.number >> m.integer >> m.str;
+/// }
+/// \endcode
+///
+/// Packets also provide an extra feature that allows to apply
+/// custom transformations to the data before it is sent,
+/// and after it is received. This is typically used to
+/// handle automatic compression or encryption of the data.
+/// This is achieved by inheriting from sf::Packet, and overriding
+/// the onSend and onReceive functions.
+///
+/// Here is an example:
+/// \code
+/// class ZipPacket : public sf::Packet
+/// {
+/// virtual const void* onSend(std::size_t& size)
+/// {
+/// const void* srcData = getData();
+/// std::size_t srcSize = getDataSize();
+///
+/// return MySuperZipFunction(srcData, srcSize, &size);
+/// }
+///
+/// virtual void onReceive(const void* data, std::size_t size)
+/// {
+/// std::size_t dstSize;
+/// const void* dstData = MySuperUnzipFunction(data, size, &dstSize);
+///
+/// append(dstData, dstSize);
+/// }
+/// };
+///
+/// // Use like regular packets:
+/// ZipPacket packet;
+/// packet << x << s << d;
+/// ...
+/// \endcode
+///
+/// \see sf::TcpSocket, sf::UdpSocket
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Network/Selector.hpp b/include/SFML/Network/Selector.hpp deleted file mode 100755 index 588a72c..0000000 --- a/include/SFML/Network/Selector.hpp +++ /dev/null @@ -1,116 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_SELECTOR_HPP
-#define SFML_SELECTOR_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/Network/SocketUDP.hpp>
-#include <SFML/Network/SocketTCP.hpp>
-#include <SFML/Network/SelectorBase.hpp>
-#include <map>
-
-
-namespace sf
-{
-////////////////////////////////////////////////////////////
-/// Selector allow reading from multiple sockets
-/// without blocking. It's a kind of multiplexer
-////////////////////////////////////////////////////////////
-template <typename Type>
-class Selector : private SelectorBase
-{
-public :
-
- ////////////////////////////////////////////////////////////
- /// Add a socket to watch
- ///
- /// \param Socket : Socket to add
- ///
- ////////////////////////////////////////////////////////////
- void Add(Type Socket);
-
- ////////////////////////////////////////////////////////////
- /// Remove a socket
- ///
- /// \param Socket : Socket to remove
- ///
- ////////////////////////////////////////////////////////////
- void Remove(Type Socket);
-
- ////////////////////////////////////////////////////////////
- /// Remove all sockets
- ///
- ////////////////////////////////////////////////////////////
- void Clear();
-
- ////////////////////////////////////////////////////////////
- /// Wait and collect sockets which are ready for reading.
- /// This functions will return either when at least one socket
- /// is ready, or when the given time is out
- ///
- /// \param Timeout : Timeout, in seconds (0 by default : no timeout)
- ///
- /// \return Number of sockets ready to be read
- ///
- ////////////////////////////////////////////////////////////
- unsigned int Wait(float Timeout = 0.f);
-
- ////////////////////////////////////////////////////////////
- /// After a call to Wait(), get the Index-th socket which is
- /// ready for reading. The total number of sockets ready
- /// is the integer returned by the previous call to Wait()
- ///
- /// \param Index : Index of the socket to get
- ///
- /// \return The Index-th socket
- ///
- ////////////////////////////////////////////////////////////
- Type GetSocketReady(unsigned int Index);
-
-private :
-
- ////////////////////////////////////////////////////////////
- // Types
- ////////////////////////////////////////////////////////////
- typedef std::map<SocketHelper::SocketType, Type> SocketTable;
-
- ////////////////////////////////////////////////////////////
- // Member data
- ////////////////////////////////////////////////////////////
- SocketTable mySockets; ///< Table matching the SFML socket instances with their low-level handles
-};
-
-#include <SFML/Network/Selector.inl>
-
-// Let's define the two only valid types of Selector
-typedef Selector<SocketUDP> SelectorUDP;
-typedef Selector<SocketTCP> SelectorTCP;
-
-} // namespace sf
-
-
-#endif // SFML_SELECTOR_HPP
diff --git a/include/SFML/Network/Selector.inl b/include/SFML/Network/Selector.inl deleted file mode 100755 index 40ac948..0000000 --- a/include/SFML/Network/Selector.inl +++ /dev/null @@ -1,97 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-
-////////////////////////////////////////////////////////////
-/// Add a socket to watch
-////////////////////////////////////////////////////////////
-template <typename Type>
-void Selector<Type>::Add(Type Socket)
-{
- if (Socket.IsValid())
- {
- SelectorBase::Add(Socket.mySocket);
- mySockets[Socket.mySocket] = Socket;
- }
-}
-
-
-////////////////////////////////////////////////////////////
-/// Remove a socket
-////////////////////////////////////////////////////////////
-template <typename Type>
-void Selector<Type>::Remove(Type Socket)
-{
- typename SocketTable::iterator It = mySockets.find(Socket.mySocket);
- if (It != mySockets.end())
- {
- SelectorBase::Remove(Socket.mySocket);
- mySockets.erase(It);
- }
-}
-
-
-////////////////////////////////////////////////////////////
-/// Remove all sockets
-////////////////////////////////////////////////////////////
-template <typename Type>
-void Selector<Type>::Clear()
-{
- SelectorBase::Clear();
- mySockets.clear();
-}
-
-
-////////////////////////////////////////////////////////////
-/// Wait and collect sockets which are ready for reading.
-/// This functions will return either when at least one socket
-/// is ready, or when the given time is out
-////////////////////////////////////////////////////////////
-template <typename Type>
-unsigned int Selector<Type>::Wait(float Timeout)
-{
- // No socket in the selector : return 0
- if (mySockets.empty())
- return 0;
-
- return SelectorBase::Wait(Timeout);
-}
-
-
-////////////////////////////////////////////////////////////
-/// After a call to Wait(), get the Index-th socket which is
-/// ready for reading. The total number of sockets ready
-/// is the integer returned by the previous call to Wait()
-////////////////////////////////////////////////////////////
-template <typename Type>
-Type Selector<Type>::GetSocketReady(unsigned int Index)
-{
- SocketHelper::SocketType Socket = SelectorBase::GetSocketReady(Index);
-
- typename SocketTable::const_iterator It = mySockets.find(Socket);
- if (It != mySockets.end())
- return It->second;
- else
- return Type(Socket);
-}
diff --git a/include/SFML/Network/Socket.hpp b/include/SFML/Network/Socket.hpp new file mode 100644 index 0000000..4b30307 --- /dev/null +++ b/include/SFML/Network/Socket.hpp @@ -0,0 +1,218 @@ +////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+// you must not claim that you wrote the original software.
+// If you use this software in a product, an acknowledgment
+// in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+// and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_SOCKET_HPP
+#define SFML_SOCKET_HPP
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Network/Export.hpp>
+#include <SFML/Network/SocketHandle.hpp>
+#include <SFML/System/NonCopyable.hpp>
+#include <vector>
+
+
+namespace sf
+{
+class SocketSelector;
+
+////////////////////////////////////////////////////////////
+/// \brief Base class for all the socket types
+///
+////////////////////////////////////////////////////////////
+class SFML_NETWORK_API Socket : NonCopyable
+{
+public :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Status codes that may be returned by socket functions
+ ///
+ ////////////////////////////////////////////////////////////
+ enum Status
+ {
+ Done, ///< The socket has sent / received the data
+ NotReady, ///< The socket is not ready to send / receive data yet
+ Disconnected, ///< The TCP socket has been disconnected
+ Error ///< An unexpected error happened
+ };
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Some special values used by sockets
+ ///
+ ////////////////////////////////////////////////////////////
+ enum
+ {
+ AnyPort = 0 ///< Special value that tells the system to pick any available port
+ };
+
+public :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Destructor
+ ///
+ ////////////////////////////////////////////////////////////
+ virtual ~Socket();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Set the blocking state of the socket
+ ///
+ /// In blocking mode, calls will not return until they have
+ /// completed their task. For example, a call to Receive in
+ /// blocking mode won't return until some data was actually
+ /// received.
+ /// In non-blocking mode, calls will always return immediately,
+ /// using the return code to signal whether there was data
+ /// available or not.
+ /// By default, all sockets are blocking.
+ ///
+ /// \param blocking True to set the socket as blocking, false for non-blocking
+ ///
+ /// \see isBlocking
+ ///
+ ////////////////////////////////////////////////////////////
+ void setBlocking(bool blocking);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Tell whether the socket is in blocking or non-blocking mode
+ ///
+ /// \return True if the socket is blocking, false otherwise
+ ///
+ /// \see setBlocking
+ ///
+ ////////////////////////////////////////////////////////////
+ bool isBlocking() const;
+
+protected :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Types of protocols that the socket can use
+ ///
+ ////////////////////////////////////////////////////////////
+ enum Type
+ {
+ Tcp, ///< TCP protocol
+ Udp ///< UDP protocol
+ };
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Default constructor
+ ///
+ /// This constructor can only be accessed by derived classes.
+ ///
+ /// \param type Type of the socket (TCP or UDP)
+ ///
+ ////////////////////////////////////////////////////////////
+ Socket(Type type);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Return the internal handle of the socket
+ ///
+ /// The returned handle may be invalid if the socket
+ /// was not created yet (or already destroyed).
+ /// This function can only be accessed by derived classes.
+ ///
+ /// \return The internal (OS-specific) handle of the socket
+ ///
+ ////////////////////////////////////////////////////////////
+ SocketHandle getHandle() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Create the internal representation of the socket
+ ///
+ /// This function can only be accessed by derived classes.
+ ///
+ ////////////////////////////////////////////////////////////
+ void create();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Create the internal representation of the socket
+ /// from a socket handle
+ ///
+ /// This function can only be accessed by derived classes.
+ ///
+ /// \param handle OS-specific handle of the socket to wrap
+ ///
+ ////////////////////////////////////////////////////////////
+ void create(SocketHandle handle);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Close the socket gracefully
+ ///
+ /// This function can only be accessed by derived classes.
+ ///
+ ////////////////////////////////////////////////////////////
+ void close();
+
+private :
+
+ friend class SocketSelector;
+
+ ////////////////////////////////////////////////////////////
+ // Member data
+ ////////////////////////////////////////////////////////////
+ Type m_type; ///< Type of the socket (TCP or UDP)
+ SocketHandle m_socket; ///< Socket descriptor
+ bool m_isBlocking; ///< Current blocking mode of the socket
+};
+
+} // namespace sf
+
+
+#endif // SFML_SOCKET_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Socket
+/// \ingroup network
+///
+/// This class mainly defines internal stuff to be used by
+/// derived classes.
+///
+/// The only public features that it defines, and which
+/// is therefore common to all the socket classes, is the
+/// blocking state. All sockets can be set as blocking or
+/// non-blocking.
+///
+/// In blocking mode, socket functions will hang until
+/// the operation completes, which means that the entire
+/// program (well, in fact the current thread if you use
+/// multiple ones) will be stuck waiting for your socket
+/// operation to complete.
+///
+/// In non-blocking mode, all the socket functions will
+/// return immediately. If the socket is not ready to complete
+/// the requested operation, the function simply returns
+/// the proper status code (Socket::NotReady).
+///
+/// The default mode, which is blocking, is the one that is
+/// generally used, in combination with threads or selectors.
+/// The non-blocking mode is rather used in real-time
+/// applications that run an endless loop that can poll
+/// the socket often enough, and cannot afford blocking
+/// this loop.
+///
+/// \see sf::TcpListener, sf::TcpSocket, sf::UdpSocket
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Window/WindowListener.hpp b/include/SFML/Network/SocketHandle.hpp index e085880..8edd46a 100755..100644 --- a/include/SFML/Window/WindowListener.hpp +++ b/include/SFML/Network/SocketHandle.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,45 +22,36 @@ //
////////////////////////////////////////////////////////////
-#ifndef SFML_WINDOWLISTENER_HPP
-#define SFML_WINDOWLISTENER_HPP
+#ifndef SFML_SOCKETHANDLE_HPP
+#define SFML_SOCKETHANDLE_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Config.hpp>
+#if defined(SFML_SYSTEM_WINDOWS)
+ #include <basetsd.h>
+#endif
+
namespace sf
{
-class Event;
-
////////////////////////////////////////////////////////////
-/// Base class for classes that want to receive events
-/// from a window (for internal use only)
+// Define the low-level socket handle type, specific to
+// each platform
////////////////////////////////////////////////////////////
-class SFML_API WindowListener
-{
-public :
+#if defined(SFML_SYSTEM_WINDOWS)
+
+ typedef UINT_PTR SocketHandle;
- ////////////////////////////////////////////////////////////
- /// Called each time an event is received from attached window
- ///
- /// \param EventReceived : Event received
- ///
- ////////////////////////////////////////////////////////////
- virtual void OnEvent(const Event& EventReceived) = 0;
+#else
-protected :
+ typedef int SocketHandle;
- ////////////////////////////////////////////////////////////
- /// Destructor
- ///
- ////////////////////////////////////////////////////////////
- virtual ~WindowListener() {}
-};
+#endif
} // namespace sf
-#endif // SFML_WINDOWLISTENER_HPP
+#endif // SFML_SOCKETHANDLE_HPP
diff --git a/include/SFML/Network/SocketSelector.hpp b/include/SFML/Network/SocketSelector.hpp new file mode 100644 index 0000000..414a941 --- /dev/null +++ b/include/SFML/Network/SocketSelector.hpp @@ -0,0 +1,263 @@ +////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+// you must not claim that you wrote the original software.
+// If you use this software in a product, an acknowledgment
+// in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+// and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_SOCKETSELECTOR_HPP
+#define SFML_SOCKETSELECTOR_HPP
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Network/Export.hpp>
+#include <SFML/System/Time.hpp>
+
+
+namespace sf
+{
+class Socket;
+
+////////////////////////////////////////////////////////////
+/// \brief Multiplexer that allows to read from multiple sockets
+///
+////////////////////////////////////////////////////////////
+class SFML_NETWORK_API SocketSelector
+{
+public :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Default constructor
+ ///
+ ////////////////////////////////////////////////////////////
+ SocketSelector();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Copy constructor
+ ///
+ /// \param copy Instance to copy
+ ///
+ ////////////////////////////////////////////////////////////
+ SocketSelector(const SocketSelector& copy);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Destructor
+ ///
+ ////////////////////////////////////////////////////////////
+ ~SocketSelector();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Add a new socket to the selector
+ ///
+ /// This function keeps a weak reference to the socket,
+ /// so you have to make sure that the socket is not destroyed
+ /// while it is stored in the selector.
+ /// This function does nothing if the socket is not valid.
+ ///
+ /// \param socket Reference to the socket to add
+ ///
+ /// \see remove, clear
+ ///
+ ////////////////////////////////////////////////////////////
+ void add(Socket& socket);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Remove a socket from the selector
+ ///
+ /// This function doesn't destroy the socket, it simply
+ /// removes the reference that the selector has to it.
+ ///
+ /// \param socket Reference to the socket to remove
+ ///
+ /// \see add, clear
+ ///
+ ////////////////////////////////////////////////////////////
+ void remove(Socket& socket);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Remove all the sockets stored in the selector
+ ///
+ /// This function doesn't destroy any instance, it simply
+ /// removes all the references that the selector has to
+ /// external sockets.
+ ///
+ /// \see add, remove
+ ///
+ ////////////////////////////////////////////////////////////
+ void clear();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Wait until one or more sockets are ready to receive
+ ///
+ /// This function returns as soon as at least one socket has
+ /// some data available to be received. To know which sockets are
+ /// ready, use the isReady function.
+ /// If you use a timeout and no socket is ready before the timeout
+ /// is over, the function returns false.
+ ///
+ /// \param timeout Maximum time to wait, (use Time::Zero for infinity)
+ ///
+ /// \return True if there are sockets ready, false otherwise
+ ///
+ /// \see isReady
+ ///
+ ////////////////////////////////////////////////////////////
+ bool wait(Time timeout = Time::Zero);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Test a socket to know if it is ready to receive data
+ ///
+ /// This function must be used after a call to Wait, to know
+ /// which sockets are ready to receive data. If a socket is
+ /// ready, a call to receive will never block because we know
+ /// that there is data available to read.
+ /// Note that if this function returns true for a TcpListener,
+ /// this means that it is ready to accept a new connection.
+ ///
+ /// \param socket Socket to test
+ ///
+ /// \return True if the socket is ready to read, false otherwise
+ ///
+ /// \see isReady
+ ///
+ ////////////////////////////////////////////////////////////
+ bool isReady(Socket& socket) const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Overload of assignment operator
+ ///
+ /// \param right Instance to assign
+ ///
+ /// \return Reference to self
+ ///
+ ////////////////////////////////////////////////////////////
+ SocketSelector& operator =(const SocketSelector& right);
+
+private :
+
+ struct SocketSelectorImpl;
+
+ ////////////////////////////////////////////////////////////
+ // Member data
+ ////////////////////////////////////////////////////////////
+ SocketSelectorImpl* m_impl; ///< Opaque pointer to the implementation (which requires OS-specific types)
+};
+
+} // namespace sf
+
+
+#endif // SFML_SOCKETSELECTOR_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::SocketSelector
+/// \ingroup network
+///
+/// Socket selectors provide a way to wait until some data is
+/// available on a set of sockets, instead of just one. This
+/// is convenient when you have multiple sockets that may
+/// possibly receive data, but you don't know which one will
+/// be ready first. In particular, it avoids to use a thread
+/// for each socket; with selectors, a single thread can handle
+/// all the sockets.
+///
+/// All types of sockets can be used in a selector:
+/// \li sf::TcpListener
+/// \li sf::TcpSocket
+/// \li sf::UdpSocket
+///
+/// A selector doesn't store its own copies of the sockets
+/// (socket classes are not copyable anyway), it simply keeps
+/// a reference to the original sockets that you pass to the
+/// "add" function. Therefore, you can't use the selector as a
+/// socket container, you must store them oustide and make sure
+/// that they are alive as long as they are used in the selector.
+///
+/// Using a selector is simple:
+/// \li populate the selector with all the sockets that you want to observe
+/// \li make it wait until there is data available on any of the sockets
+/// \li test each socket to find out which ones are ready
+///
+/// Usage example:
+/// \code
+/// // Create a socket to listen to new connections
+/// sf::TcpListener listener;
+/// listener.listen(55001);
+///
+/// // Create a list to store the future clients
+/// std::list<sf::TcpSocket*> clients;
+///
+/// // Create a selector
+/// sf::SocketSelector selector;
+///
+/// // Add the listener to the selector
+/// selector.add(listener);
+///
+/// // Endless loop that waits for new connections
+/// while (running)
+/// {
+/// // Make the selector wait for data on any socket
+/// if (selector.wait())
+/// {
+/// // Test the listener
+/// if (selector.isReady(listener))
+/// {
+/// // The listener is ready: there is a pending connection
+/// sf::TcpSocket* client = new sf::TcpSocket;
+/// if (listener.accept(*client) == sf::Socket::Done)
+/// {
+/// // Add the new client to the clients list
+/// clients.push_back(client);
+///
+/// // Add the new client to the selector so that we will
+/// // be notified when he sends something
+/// selector.add(*client);
+/// }
+/// else
+/// {
+/// // Error, we won't get a new connection, delete the socket
+/// delete client;
+/// }
+/// }
+/// else
+/// {
+/// // The listener socket is not ready, test all other sockets (the clients)
+/// for (std::list<sf::TcpSocket*>::iterator it = clients.begin(); it != clients.end(); ++it)
+/// {
+/// sf::TcpSocket& client = **it;
+/// if (selector.isReady(client))
+/// {
+/// // The client has sent some data, we can receive it
+/// sf::Packet packet;
+/// if (client.receive(packet) == sf::Socket::Done)
+/// {
+/// ...
+/// }
+/// }
+/// }
+/// }
+/// }
+/// }
+/// \endcode
+///
+/// \see sf::Socket
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Network/SocketTCP.hpp b/include/SFML/Network/SocketTCP.hpp deleted file mode 100755 index 8929dc9..0000000 --- a/include/SFML/Network/SocketTCP.hpp +++ /dev/null @@ -1,227 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_SOCKETTCP_HPP
-#define SFML_SOCKETTCP_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/Network/SocketHelper.hpp>
-#include <vector>
-
-
-namespace sf
-{
-class Packet;
-class IPAddress;
-template <typename> class Selector;
-
-////////////////////////////////////////////////////////////
-/// SocketTCP wraps a socket using TCP protocol to
-/// send data safely (but a bit slower)
-////////////////////////////////////////////////////////////
-class SFML_API SocketTCP
-{
-public :
-
- ////////////////////////////////////////////////////////////
- /// Default constructor
- ///
- ////////////////////////////////////////////////////////////
- SocketTCP();
-
- ////////////////////////////////////////////////////////////
- /// Change the blocking state of the socket.
- /// The default behaviour of a socket is blocking
- ///
- /// \param Blocking : Pass true to set the socket as blocking, or false for non-blocking
- ///
- ////////////////////////////////////////////////////////////
- void SetBlocking(bool Blocking);
-
- ////////////////////////////////////////////////////////////
- /// Connect to another computer on a specified port
- ///
- /// \param Port : Port to use for transfers (warning : ports < 1024 are reserved)
- /// \param HostAddress : IP Address of the host to connect to
- /// \param Timeout : Maximum time to wait, in seconds (0 by default : no timeout) (this parameter is ignored for non-blocking sockets)
- ///
- /// \return True if operation has been successful
- ///
- ////////////////////////////////////////////////////////////
- Socket::Status Connect(unsigned short Port, const IPAddress& HostAddress, float Timeout = 0.f);
-
- ////////////////////////////////////////////////////////////
- /// Listen to a specified port for incoming data or connections
- ///
- /// \param Port : Port to listen to
- ///
- /// \return True if operation has been successful
- ///
- ////////////////////////////////////////////////////////////
- bool Listen(unsigned short Port);
-
- ////////////////////////////////////////////////////////////
- /// Wait for a connection (must be listening to a port).
- /// This function will block if the socket is blocking
- ///
- /// \param Connected : Socket containing the connection with the connected client
- /// \param Address : Pointer to an address to fill with client infos (NULL by default)
- ///
- /// \return Status code
- ///
- ////////////////////////////////////////////////////////////
- Socket::Status Accept(SocketTCP& Connected, IPAddress* Address = NULL);
-
- ////////////////////////////////////////////////////////////
- /// Send an array of bytes to the host (must be connected first)
- ///
- /// \param Data : Pointer to the bytes to send
- /// \param Size : Number of bytes to send
- ///
- /// \return Status code
- ///
- ////////////////////////////////////////////////////////////
- Socket::Status Send(const char* Data, std::size_t Size);
-
- ////////////////////////////////////////////////////////////
- /// Receive an array of bytes from the host (must be connected first).
- /// This function will block if the socket is blocking
- ///
- /// \param Data : Pointer to a byte array to fill (make sure it is big enough)
- /// \param MaxSize : Maximum number of bytes to read
- /// \param SizeReceived : Number of bytes received
- ///
- /// \return Status code
- ///
- ////////////////////////////////////////////////////////////
- Socket::Status Receive(char* Data, std::size_t MaxSize, std::size_t& SizeReceived);
-
- ////////////////////////////////////////////////////////////
- /// Send a packet of data to the host (must be connected first)
- ///
- /// \param PacketToSend : Packet to send
- ///
- /// \return Status code
- ///
- ////////////////////////////////////////////////////////////
- Socket::Status Send(Packet& PacketToSend);
-
- ////////////////////////////////////////////////////////////
- /// Receive a packet from the host (must be connected first).
- /// This function will block if the socket is blocking
- ///
- /// \param PacketToReceive : Packet to fill with received data
- ///
- /// \return Status code
- ///
- ////////////////////////////////////////////////////////////
- Socket::Status Receive(Packet& PacketToReceive);
-
- ////////////////////////////////////////////////////////////
- /// Close the socket
- ///
- /// \return True if operation has been successful
- ///
- ////////////////////////////////////////////////////////////
- bool Close();
-
- ////////////////////////////////////////////////////////////
- /// Check if the socket is in a valid state ; this function
- /// can be called any time to check if the socket is OK
- ///
- /// \return True if the socket is valid
- ///
- ////////////////////////////////////////////////////////////
- bool IsValid() const;
-
- ////////////////////////////////////////////////////////////
- /// Comparison operator ==
- ///
- /// \param Other : Socket to compare
- ///
- /// \return True if *this == Other
- ///
- ////////////////////////////////////////////////////////////
- bool operator ==(const SocketTCP& Other) const;
-
- ////////////////////////////////////////////////////////////
- /// Comparison operator !=
- ///
- /// \param Other : Socket to compare
- ///
- /// \return True if *this != Other
- ///
- ////////////////////////////////////////////////////////////
- bool operator !=(const SocketTCP& Other) const;
-
- ////////////////////////////////////////////////////////////
- /// Comparison operator <.
- /// Provided for compatibility with standard containers, as
- /// comparing two sockets doesn't make much sense...
- ///
- /// \param Other : Socket to compare
- ///
- /// \return True if *this < Other
- ///
- ////////////////////////////////////////////////////////////
- bool operator <(const SocketTCP& Other) const;
-
-private :
-
- friend class Selector<SocketTCP>;
-
- ////////////////////////////////////////////////////////////
- /// Construct the socket from a socket descriptor
- /// (for internal use only)
- ///
- /// \param Descriptor : Socket descriptor
- ///
- ////////////////////////////////////////////////////////////
- SocketTCP(SocketHelper::SocketType Descriptor);
-
- ////////////////////////////////////////////////////////////
- /// Create the socket
- ///
- /// \param Descriptor : System socket descriptor to use (0 by default -- create a new socket)
- ///
- ////////////////////////////////////////////////////////////
- void Create(SocketHelper::SocketType Descriptor = 0);
-
- ////////////////////////////////////////////////////////////
- // Member data
- ////////////////////////////////////////////////////////////
- SocketHelper::SocketType mySocket; ///< Socket descriptor
- Uint32 myPendingHeader; ///< Data of the current pending packet header, if any
- Uint32 myPendingHeaderSize; ///< Size of the current pending packet header, if any
- std::vector<char> myPendingPacket; ///< Data of the current pending packet, if any
- Int32 myPendingPacketSize; ///< Size of the current pending packet, if any
- bool myIsBlocking; ///< Is the socket blocking or non-blocking ?
-};
-
-} // namespace sf
-
-
-#endif // SFML_SOCKETTCP_HPP
diff --git a/include/SFML/Network/SocketUDP.hpp b/include/SFML/Network/SocketUDP.hpp deleted file mode 100755 index 7cb6b19..0000000 --- a/include/SFML/Network/SocketUDP.hpp +++ /dev/null @@ -1,228 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_SOCKETUDP_HPP
-#define SFML_SOCKETUDP_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/Network/SocketHelper.hpp>
-#include <vector>
-
-
-namespace sf
-{
-class Packet;
-class IPAddress;
-template <typename> class Selector;
-
-////////////////////////////////////////////////////////////
-/// SocketUDP wraps a socket using UDP protocol to
-/// send data fastly (but with less safety)
-////////////////////////////////////////////////////////////
-class SFML_API SocketUDP
-{
-public :
-
- ////////////////////////////////////////////////////////////
- /// Default constructor
- ///
- ////////////////////////////////////////////////////////////
- SocketUDP();
-
- ////////////////////////////////////////////////////////////
- /// Change the blocking state of the socket.
- /// The default behaviour of a socket is blocking
- ///
- /// \param Blocking : Pass true to set the socket as blocking, or false for non-blocking
- ///
- ////////////////////////////////////////////////////////////
- void SetBlocking(bool Blocking);
-
- ////////////////////////////////////////////////////////////
- /// Bind the socket to a specific port
- ///
- /// \param Port : Port to bind the socket to
- ///
- /// \return True if operation has been successful
- ///
- ////////////////////////////////////////////////////////////
- bool Bind(unsigned short Port);
-
- ////////////////////////////////////////////////////////////
- /// Unbind the socket from its previous port, if any
- ///
- /// \return True if operation has been successful
- ///
- ////////////////////////////////////////////////////////////
- bool Unbind();
-
- ////////////////////////////////////////////////////////////
- /// Send an array of bytes
- ///
- /// \param Data : Pointer to the bytes to send
- /// \param Size : Number of bytes to send
- /// \param Address : Address of the computer to send the packet to
- /// \param Port : Port to send the data to
- ///
- /// \return Status code
- ///
- ////////////////////////////////////////////////////////////
- Socket::Status Send(const char* Data, std::size_t Size, const IPAddress& Address, unsigned short Port);
-
- ////////////////////////////////////////////////////////////
- /// Receive an array of bytes.
- /// This function will block if the socket is blocking
- ///
- /// \param Data : Pointer to a byte array to fill (make sure it is big enough)
- /// \param MaxSize : Maximum number of bytes to read
- /// \param SizeReceived : Number of bytes received
- /// \param Address : Address of the computer which sent the data
- /// \param Port : Port on which the remote computer sent the data
- ///
- /// \return Status code
- ///
- ////////////////////////////////////////////////////////////
- Socket::Status Receive(char* Data, std::size_t MaxSize, std::size_t& SizeReceived, IPAddress& Address, unsigned short& Port);
-
- ////////////////////////////////////////////////////////////
- /// Send a packet of data
- ///
- /// \param PacketToSend : Packet to send
- /// \param Address : Address of the computer to send the packet to
- /// \param Port : Port to send the data to
- ///
- /// \return Status code
- ///
- ////////////////////////////////////////////////////////////
- Socket::Status Send(Packet& PacketToSend, const IPAddress& Address, unsigned short Port);
-
- ////////////////////////////////////////////////////////////
- /// Receive a packet.
- /// This function will block if the socket is blocking
- ///
- /// \param PacketToReceive : Packet to fill with received data
- /// \param Address : Address of the computer which sent the packet
- /// \param Port : Port on which the remote computer sent the data
- ///
- /// \return Status code
- ///
- ////////////////////////////////////////////////////////////
- Socket::Status Receive(Packet& PacketToReceive, IPAddress& Address, unsigned short& Port);
-
- ////////////////////////////////////////////////////////////
- /// Close the socket
- ///
- /// \return True if operation has been successful
- ///
- ////////////////////////////////////////////////////////////
- bool Close();
-
- ////////////////////////////////////////////////////////////
- /// Check if the socket is in a valid state ; this function
- /// can be called any time to check if the socket is OK
- ///
- /// \return True if the socket is valid
- ///
- ////////////////////////////////////////////////////////////
- bool IsValid() const;
-
- ////////////////////////////////////////////////////////////
- /// Get the port the socket is currently bound to
- ///
- /// \return Current port (0 means the socket is not bound)
- ///
- ////////////////////////////////////////////////////////////
- unsigned short GetPort() const;
-
- ////////////////////////////////////////////////////////////
- /// Comparison operator ==
- ///
- /// \param Other : Socket to compare
- ///
- /// \return True if *this == Other
- ///
- ////////////////////////////////////////////////////////////
- bool operator ==(const SocketUDP& Other) const;
-
- ////////////////////////////////////////////////////////////
- /// Comparison operator !=
- ///
- /// \param Other : Socket to compare
- ///
- /// \return True if *this != Other
- ///
- ////////////////////////////////////////////////////////////
- bool operator !=(const SocketUDP& Other) const;
-
- ////////////////////////////////////////////////////////////
- /// Comparison operator <.
- /// Provided for compatibility with standard containers, as
- /// comparing two sockets doesn't make much sense...
- ///
- /// \param Other : Socket to compare
- ///
- /// \return True if *this < Other
- ///
- ////////////////////////////////////////////////////////////
- bool operator <(const SocketUDP& Other) const;
-
-private :
-
- friend class Selector<SocketUDP>;
-
- ////////////////////////////////////////////////////////////
- /// Construct the socket from a socket descriptor
- /// (for internal use only)
- ///
- /// \param Descriptor : Socket descriptor
- ///
- ////////////////////////////////////////////////////////////
- SocketUDP(SocketHelper::SocketType Descriptor);
-
- ////////////////////////////////////////////////////////////
- /// Create the socket
- ///
- /// \param Descriptor : System socket descriptor to use (0 by default -- create a new socket)
- ///
- ////////////////////////////////////////////////////////////
- void Create(SocketHelper::SocketType Descriptor = 0);
-
- ////////////////////////////////////////////////////////////
- // Member data
- ////////////////////////////////////////////////////////////
- SocketHelper::SocketType mySocket; ///< Socket identifier
- unsigned short myPort; ///< Port to which the socket is bound
- Uint32 myPendingHeader; ///< Data of the current pending packet header, if any
- Uint32 myPendingHeaderSize; ///< Size of the current pending packet header, if any
- std::vector<char> myPendingPacket; ///< Data of the current pending packet, if any
- Int32 myPendingPacketSize; ///< Size of the current pending packet, if any
- bool myIsBlocking; ///< Is the socket blocking or non-blocking ?
-};
-
-} // namespace sf
-
-
-#endif // SFML_SOCKETUDP_HPP
diff --git a/include/SFML/Network/TcpListener.hpp b/include/SFML/Network/TcpListener.hpp new file mode 100644 index 0000000..5a5bdb3 --- /dev/null +++ b/include/SFML/Network/TcpListener.hpp @@ -0,0 +1,162 @@ +////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+// you must not claim that you wrote the original software.
+// If you use this software in a product, an acknowledgment
+// in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+// and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_TCPLISTENER_HPP
+#define SFML_TCPLISTENER_HPP
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Network/Export.hpp>
+#include <SFML/Network/Socket.hpp>
+
+
+namespace sf
+{
+class TcpSocket;
+
+////////////////////////////////////////////////////////////
+/// \brief Socket that listens to new TCP connections
+///
+////////////////////////////////////////////////////////////
+class SFML_NETWORK_API TcpListener : public Socket
+{
+public :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Default constructor
+ ///
+ ////////////////////////////////////////////////////////////
+ TcpListener();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the port to which the socket is bound locally
+ ///
+ /// If the socket is not listening to a port, this function
+ /// returns 0.
+ ///
+ /// \return Port to which the socket is bound
+ ///
+ /// \see listen
+ ///
+ ////////////////////////////////////////////////////////////
+ unsigned short getLocalPort() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Start listening for connections
+ ///
+ /// This functions makes the socket listen to the specified
+ /// port, waiting for new connections.
+ /// If the socket was previously listening to another port,
+ /// it will be stopped first and bound to the new port.
+ ///
+ /// \param port Port to listen for new connections
+ ///
+ /// \return Status code
+ ///
+ /// \see accept, close
+ ///
+ ////////////////////////////////////////////////////////////
+ Status listen(unsigned short port);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Stop listening and close the socket
+ ///
+ /// This function gracefully stops the listener. If the
+ /// socket is not listening, this function has no effect.
+ ///
+ /// \see listen
+ ///
+ ////////////////////////////////////////////////////////////
+ void close();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Accept a new connection
+ ///
+ /// If the socket is in blocking mode, this function will
+ /// not return until a connection is actually received.
+ ///
+ /// \param socket Socket that will hold the new connection
+ ///
+ /// \return Status code
+ ///
+ /// \see listen
+ ///
+ ////////////////////////////////////////////////////////////
+ Status accept(TcpSocket& socket);
+};
+
+
+} // namespace sf
+
+
+#endif // SFML_TCPLISTENER_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::TcpListener
+/// \ingroup network
+///
+/// A listener socket is a special type of socket that listens to
+/// a given port and waits for connections on that port.
+/// This is all it can do.
+///
+/// When a new connection is received, you must call accept and
+/// the listener returns a new instance of sf::TcpSocket that
+/// is properly initialized and can be used to communicate with
+/// the new client.
+///
+/// Listener sockets are specific to the TCP protocol,
+/// UDP sockets are connectionless and can therefore communicate
+/// directly. As a consequence, a listener socket will always
+/// return the new connections as sf::TcpSocket instances.
+///
+/// A listener is automatically closed on destruction, like all
+/// other types of socket. However if you want to stop listening
+/// before the socket is destroyed, you can call its close()
+/// function.
+///
+/// Usage example:
+/// \code
+/// // Create a listener socket and make it wait for new
+/// // connections on port 55001
+/// sf::TcpListener listener;
+/// listener.listen(55001);
+///
+/// // Endless loop that waits for new connections
+/// while (running)
+/// {
+/// sf::TcpSocket client;
+/// if (listener.accept(client) == sf::Socket::Done)
+/// {
+/// // A new client just connected!
+/// std::cout << "New connection received from " << client.getRemoteAddress() << std::endl;
+/// doSomethingWith(client);
+/// }
+/// }
+/// \endcode
+///
+/// \see sf::TcpSocket, sf::Socket
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Network/TcpSocket.hpp b/include/SFML/Network/TcpSocket.hpp new file mode 100644 index 0000000..2db2b72 --- /dev/null +++ b/include/SFML/Network/TcpSocket.hpp @@ -0,0 +1,292 @@ +////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+// you must not claim that you wrote the original software.
+// If you use this software in a product, an acknowledgment
+// in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+// and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_TCPSOCKET_HPP
+#define SFML_TCPSOCKET_HPP
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Network/Export.hpp>
+#include <SFML/Network/Socket.hpp>
+#include <SFML/System/Time.hpp>
+
+
+namespace sf
+{
+class TcpListener;
+class IpAddress;
+class Packet;
+
+////////////////////////////////////////////////////////////
+/// \brief Specialized socket using the TCP protocol
+///
+////////////////////////////////////////////////////////////
+class SFML_NETWORK_API TcpSocket : public Socket
+{
+public :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Default constructor
+ ///
+ ////////////////////////////////////////////////////////////
+ TcpSocket();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the port to which the socket is bound locally
+ ///
+ /// If the socket is not connected, this function returns 0.
+ ///
+ /// \return Port to which the socket is bound
+ ///
+ /// \see connect, getRemotePort
+ ///
+ ////////////////////////////////////////////////////////////
+ unsigned short getLocalPort() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the address of the connected peer
+ ///
+ /// It the socket is not connected, this function returns
+ /// sf::IpAddress::None.
+ ///
+ /// \return Address of the remote peer
+ ///
+ /// \see getRemotePort
+ ///
+ ////////////////////////////////////////////////////////////
+ IpAddress getRemoteAddress() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the port of the connected peer to which
+ /// the socket is connected
+ ///
+ /// If the socket is not connected, this function returns 0.
+ ///
+ /// \return Remote port to which the socket is connected
+ ///
+ /// \see getRemoteAddress
+ ///
+ ////////////////////////////////////////////////////////////
+ unsigned short getRemotePort() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Connect the socket to a remote peer
+ ///
+ /// In blocking mode, this function may take a while, especially
+ /// if the remote peer is not reachable. The last parameter allows
+ /// you to stop trying to connect after a given timeout.
+ /// If the socket was previously connected, it is first disconnected.
+ ///
+ /// \param remoteAddress Address of the remote peer
+ /// \param remotePort Port of the remote peer
+ /// \param timeout Optional maximum time to wait
+ ///
+ /// \return Status code
+ ///
+ /// \see disconnect
+ ///
+ ////////////////////////////////////////////////////////////
+ Status connect(const IpAddress& remoteAddress, unsigned short remotePort, Time timeout = Time::Zero);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Disconnect the socket from its remote peer
+ ///
+ /// This function gracefully closes the connection. If the
+ /// socket is not connected, this function has no effect.
+ ///
+ /// \see connect
+ ///
+ ////////////////////////////////////////////////////////////
+ void disconnect();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Send raw data to the remote peer
+ ///
+ /// This function will fail if the socket is not connected.
+ ///
+ /// \param data Pointer to the sequence of bytes to send
+ /// \param size Number of bytes to send
+ ///
+ /// \return Status code
+ ///
+ /// \see receive
+ ///
+ ////////////////////////////////////////////////////////////
+ Status send(const void* data, std::size_t size);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Receive raw data from the remote peer
+ ///
+ /// In blocking mode, this function will wait until some
+ /// bytes are actually received.
+ /// This function will fail if the socket is not connected.
+ ///
+ /// \param data Pointer to the array to fill with the received bytes
+ /// \param size Maximum number of bytes that can be received
+ /// \param received This variable is filled with the actual number of bytes received
+ ///
+ /// \return Status code
+ ///
+ /// \see send
+ ///
+ ////////////////////////////////////////////////////////////
+ Status receive(void* data, std::size_t size, std::size_t& received);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Send a formatted packet of data to the remote peer
+ ///
+ /// This function will fail if the socket is not connected.
+ ///
+ /// \param packet Packet to send
+ ///
+ /// \return Status code
+ ///
+ /// \see receive
+ ///
+ ////////////////////////////////////////////////////////////
+ Status send(Packet& packet);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Receive a formatted packet of data from the remote peer
+ ///
+ /// In blocking mode, this function will wait until the whole packet
+ /// has been received.
+ /// This function will fail if the socket is not connected.
+ ///
+ /// \param packet Packet to fill with the received data
+ ///
+ /// \return Status code
+ ///
+ /// \see send
+ ///
+ ////////////////////////////////////////////////////////////
+ Status receive(Packet& packet);
+
+private:
+
+ friend class TcpListener;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Structure holding the data of a pending packet
+ ///
+ ////////////////////////////////////////////////////////////
+ struct PendingPacket
+ {
+ PendingPacket();
+
+ Uint32 Size; ///< Data of packet size
+ std::size_t SizeReceived; ///< Number of size bytes received so far
+ std::vector<char> Data; ///< Data of the packet
+ };
+
+ ////////////////////////////////////////////////////////////
+ // Member data
+ ////////////////////////////////////////////////////////////
+ PendingPacket m_pendingPacket; ///< Temporary data of the packet currently being received
+};
+
+} // namespace sf
+
+
+#endif // SFML_TCPSOCKET_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::TcpSocket
+/// \ingroup network
+///
+/// TCP is a connected protocol, which means that a TCP
+/// socket can only communicate with the host it is connected
+/// to. It can't send or receive anything if it is not connected.
+///
+/// The TCP protocol is reliable but adds a slight overhead.
+/// It ensures that your data will always be received in order
+/// and without errors (no data corrupted, lost or duplicated).
+///
+/// When a socket is connected to a remote host, you can
+/// retrieve informations about this host with the
+/// getRemoteAddress and getRemotePort functions. You can
+/// also get the local port to which the socket is bound
+/// (which is automatically chosen when the socket is connected),
+/// with the getLocalPort function.
+///
+/// Sending and receiving data can use either the low-level
+/// or the high-level functions. The low-level functions
+/// process a raw sequence of bytes, and cannot ensure that
+/// one call to Send will exactly match one call to Receive
+/// at the other end of the socket.
+///
+/// The high-level interface uses packets (see sf::Packet),
+/// which are easier to use and provide more safety regarding
+/// the data that is exchanged. You can look at the sf::Packet
+/// class to get more details about how they work.
+///
+/// The socket is automatically disconnected when it is destroyed,
+/// but if you want to explicitely close the connection while
+/// the socket instance is still alive, you can call disconnect.
+///
+/// Usage example:
+/// \code
+/// // ----- The client -----
+///
+/// // Create a socket and connect it to 192.168.1.50 on port 55001
+/// sf::TcpSocket socket;
+/// socket.connect("192.168.1.50", 55001);
+///
+/// // Send a message to the connected host
+/// std::string message = "Hi, I am a client";
+/// socket.send(message.c_str(), message.size() + 1);
+///
+/// // Receive an answer from the server
+/// char buffer[1024];
+/// std::size_t received = 0;
+/// socket.receive(buffer, sizeof(buffer), received);
+/// std::cout << "The server said: " << buffer << std::endl;
+///
+/// // ----- The server -----
+///
+/// // Create a listener to wait for incoming connections on port 55001
+/// sf::TcpListener listener;
+/// listener.listen(55001);
+///
+/// // Wait for a connection
+/// sf::TcpSocket socket;
+/// listener.accept(socket);
+/// std::cout << "New client connected: " << socket.getRemoteAddress() << std::endl;
+///
+/// // Receive a message from the client
+/// char buffer[1024];
+/// std::size_t received = 0;
+/// socket.receive(buffer, sizeof(buffer), received);
+/// std::cout << "The client said: " << buffer << std::endl;
+///
+/// // Send an answer
+/// std::string message = "Welcome, client";
+/// socket.send(message.c_str(), message.size() + 1);
+/// \endcode
+///
+/// \see sf::Socket, sf::UdpSocket, sf::Packet
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Network/UdpSocket.hpp b/include/SFML/Network/UdpSocket.hpp new file mode 100644 index 0000000..e5fa3b0 --- /dev/null +++ b/include/SFML/Network/UdpSocket.hpp @@ -0,0 +1,283 @@ +////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+// you must not claim that you wrote the original software.
+// If you use this software in a product, an acknowledgment
+// in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+// and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_UDPSOCKET_HPP
+#define SFML_UDPSOCKET_HPP
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Network/Export.hpp>
+#include <SFML/Network/Socket.hpp>
+#include <vector>
+
+
+namespace sf
+{
+class IpAddress;
+class Packet;
+
+////////////////////////////////////////////////////////////
+/// \brief Specialized socket using the UDP protocol
+///
+////////////////////////////////////////////////////////////
+class SFML_NETWORK_API UdpSocket : public Socket
+{
+public :
+
+ ////////////////////////////////////////////////////////////
+ // Constants
+ ////////////////////////////////////////////////////////////
+ enum
+ {
+ MaxDatagramSize = 65507 ///< The maximum number of bytes that can be sent in a single UDP datagram
+ };
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Default constructor
+ ///
+ ////////////////////////////////////////////////////////////
+ UdpSocket();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the port to which the socket is bound locally
+ ///
+ /// If the socket is not bound to a port, this function
+ /// returns 0.
+ ///
+ /// \return Port to which the socket is bound
+ ///
+ /// \see bind
+ ///
+ ////////////////////////////////////////////////////////////
+ unsigned short getLocalPort() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Bind the socket to a specific port
+ ///
+ /// Binding the socket to a port is necessary for being
+ /// able to receive data on that port.
+ /// You can use the special value Socket::AnyPort to tell the
+ /// system to automatically pick an available port, and then
+ /// call getLocalPort to retrieve the chosen port.
+ ///
+ /// \param port Port to bind the socket to
+ ///
+ /// \return Status code
+ ///
+ /// \see unbind, getLocalPort
+ ///
+ ////////////////////////////////////////////////////////////
+ Status bind(unsigned short port);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Unbind the socket from the local port to which it is bound
+ ///
+ /// The port that the socket was previously using is immediately
+ /// available after this function is called. If the
+ /// socket is not bound to a port, this function has no effect.
+ ///
+ /// \see bind
+ ///
+ ////////////////////////////////////////////////////////////
+ void unbind();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Send raw data to a remote peer
+ ///
+ /// Make sure that \a size is not greater than
+ /// UdpSocket::MaxDatagramSize, otherwise this function will
+ /// fail and no data will be sent.
+ ///
+ /// \param data Pointer to the sequence of bytes to send
+ /// \param size Number of bytes to send
+ /// \param remoteAddress Address of the receiver
+ /// \param remotePort Port of the receiver to send the data to
+ ///
+ /// \return Status code
+ ///
+ /// \see receive
+ ///
+ ////////////////////////////////////////////////////////////
+ Status send(const void* data, std::size_t size, const IpAddress& remoteAddress, unsigned short remotePort);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Receive raw data from a remote peer
+ ///
+ /// In blocking mode, this function will wait until some
+ /// bytes are actually received.
+ /// Be careful to use a buffer which is large enough for
+ /// the data that you intend to receive, if it is too small
+ /// then an error will be returned and *all* the data will
+ /// be lost.
+ ///
+ /// \param data Pointer to the array to fill with the received bytes
+ /// \param size Maximum number of bytes that can be received
+ /// \param received This variable is filled with the actual number of bytes received
+ /// \param remoteAddress Address of the peer that sent the data
+ /// \param remotePort Port of the peer that sent the data
+ ///
+ /// \return Status code
+ ///
+ /// \see send
+ ///
+ ////////////////////////////////////////////////////////////
+ Status receive(void* data, std::size_t size, std::size_t& received, IpAddress& remoteAddress, unsigned short& remotePort);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Send a formatted packet of data to a remote peer
+ ///
+ /// Make sure that the packet size is not greater than
+ /// UdpSocket::MaxDatagramSize, otherwise this function will
+ /// fail and no data will be sent.
+ ///
+ /// \param packet Packet to send
+ /// \param remoteAddress Address of the receiver
+ /// \param remotePort Port of the receiver to send the data to
+ ///
+ /// \return Status code
+ ///
+ /// \see receive
+ ///
+ ////////////////////////////////////////////////////////////
+ Status send(Packet& packet, const IpAddress& remoteAddress, unsigned short remotePort);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Receive a formatted packet of data from a remote peer
+ ///
+ /// In blocking mode, this function will wait until the whole packet
+ /// has been received.
+ ///
+ /// \param packet Packet to fill with the received data
+ /// \param remoteAddress Address of the peer that sent the data
+ /// \param remotePort Port of the peer that sent the data
+ ///
+ /// \return Status code
+ ///
+ /// \see send
+ ///
+ ////////////////////////////////////////////////////////////
+ Status receive(Packet& packet, IpAddress& remoteAddress, unsigned short& remotePort);
+
+private:
+
+ ////////////////////////////////////////////////////////////
+ // Member data
+ ////////////////////////////////////////////////////////////
+ std::vector<char> m_buffer; ///< Temporary buffer holding the received data in Receive(Packet)
+};
+
+} // namespace sf
+
+
+#endif // SFML_UDPSOCKET_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::UdpSocket
+/// \ingroup network
+///
+/// A UDP socket is a connectionless socket. Instead of
+/// connecting once to a remote host, like TCP sockets,
+/// it can send to and receive from any host at any time.
+///
+/// It is a datagram protocol: bounded blocks of data (datagrams)
+/// are transfered over the network rather than a continuous
+/// stream of data (TCP). Therefore, one call to send will always
+/// match one call to receive (if the datagram is not lost),
+/// with the same data that was sent.
+///
+/// The UDP protocol is lightweight but unreliable. Unreliable
+/// means that datagrams may be duplicated, be lost or
+/// arrive reordered. However, if a datagram arrives, its
+/// data is guaranteed to be valid.
+///
+/// UDP is generally used for real-time communication
+/// (audio or video streaming, real-time games, etc.) where
+/// speed is crucial and lost data doesn't matter much.
+///
+/// Sending and receiving data can use either the low-level
+/// or the high-level functions. The low-level functions
+/// process a raw sequence of bytes, whereas the high-level
+/// interface uses packets (see sf::Packet), which are easier
+/// to use and provide more safety regarding the data that is
+/// exchanged. You can look at the sf::Packet class to get
+/// more details about how they work.
+///
+/// It is important to note that UdpSocket is unable to send
+/// datagrams bigger than MaxDatagramSize. In this case, it
+/// returns an error and doesn't send anything. This applies
+/// to both raw data and packets. Indeed, even packets are
+/// unable to split and recompose data, due to the unreliability
+/// of the protocol (dropped, mixed or duplicated datagrams may
+/// lead to a big mess when trying to recompose a packet).
+///
+/// If the socket is bound to a port, it is automatically
+/// unbound from it when the socket is destroyed. However,
+/// you can unbind the socket explicitely with the Unbind
+/// function if necessary, to stop receiving messages or
+/// make the port available for other sockets.
+///
+/// Usage example:
+/// \code
+/// // ----- The client -----
+///
+/// // Create a socket and bind it to the port 55001
+/// sf::UdpSocket socket;
+/// socket.bind(55001);
+///
+/// // Send a message to 192.168.1.50 on port 55002
+/// std::string message = "Hi, I am " + sf::IpAddress::getLocalAddress().toString();
+/// socket.send(message.c_str(), message.size() + 1, "192.168.1.50", 55002);
+///
+/// // Receive an answer (most likely from 192.168.1.50, but could be anyone else)
+/// char buffer[1024];
+/// std::size_t received = 0;
+/// sf::IpAddress sender;
+/// unsigned short port;
+/// socket.receive(buffer, sizeof(buffer), received, sender, port);
+/// std::cout << sender.ToString() << " said: " << buffer << std::endl;
+///
+/// // ----- The server -----
+///
+/// // Create a socket and bind it to the port 55002
+/// sf::UdpSocket socket;
+/// socket.bind(55002);
+///
+/// // Receive a message from anyone
+/// char buffer[1024];
+/// std::size_t received = 0;
+/// sf::IpAddress sender;
+/// unsigned short port;
+/// socket.receive(buffer, sizeof(buffer), received, sender, port);
+/// std::cout << sender.ToString() << " said: " << buffer << std::endl;
+///
+/// // Send an answer
+/// std::string message = "Welcome " + sender.toString();
+/// socket.send(message.c_str(), message.size() + 1, sender, port);
+/// \endcode
+///
+/// \see sf::Socket, sf::TcpSocket, sf::Packet
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Network/Unix/SocketHelper.hpp b/include/SFML/Network/Unix/SocketHelper.hpp deleted file mode 100755 index 1068cd8..0000000 --- a/include/SFML/Network/Unix/SocketHelper.hpp +++ /dev/null @@ -1,96 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_SOCKETHELPERUNIX_HPP
-#define SFML_SOCKETHELPERUNIX_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <unistd.h>
-
-
-namespace sf
-{
-////////////////////////////////////////////////////////////
-/// This class defines helper functions to do all the
-/// non-portable socket stuff. This class is meant for internal
-/// use only
-////////////////////////////////////////////////////////////
-class SFML_API SocketHelper
-{
-public :
-
- ////////////////////////////////////////////////////////////
- // Define some socket types
- ////////////////////////////////////////////////////////////
- typedef int SocketType;
- typedef socklen_t LengthType;
-
- ////////////////////////////////////////////////////////////
- /// Return the value of the invalid socket
- ///
- /// \return Unique value of the invalid socket
- ///
- ////////////////////////////////////////////////////////////
- static SocketType InvalidSocket();
-
- ////////////////////////////////////////////////////////////
- /// Close / destroy a socket
- ///
- /// \param Socket : Socket to close
- ///
- /// \return True on success
- ///
- ////////////////////////////////////////////////////////////
- static bool Close(SocketType Socket);
-
- ////////////////////////////////////////////////////////////
- /// Set a socket as blocking or non-blocking
- ///
- /// \param Socket : Socket to modify
- /// \param Block : New blocking state of the socket
- ///
- ////////////////////////////////////////////////////////////
- static void SetBlocking(SocketType Socket, bool Block);
-
- ////////////////////////////////////////////////////////////
- /// Get the last socket error status
- ///
- /// \return Status corresponding to the last socket error
- ///
- ////////////////////////////////////////////////////////////
- static Socket::Status GetErrorStatus();
-};
-
-} // namespace sf
-
-
-#endif // SFML_SOCKETHELPERUNIX_HPP
diff --git a/include/SFML/Network/Win32/SocketHelper.hpp b/include/SFML/Network/Win32/SocketHelper.hpp deleted file mode 100755 index 6199c0a..0000000 --- a/include/SFML/Network/Win32/SocketHelper.hpp +++ /dev/null @@ -1,90 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_SOCKETHELPERWIN32_HPP
-#define SFML_SOCKETHELPERWIN32_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <winsock2.h>
-
-
-namespace sf
-{
-////////////////////////////////////////////////////////////
-/// This class defines helper functions to do all the
-/// non-portable socket stuff. This class is meant for internal
-/// use only
-////////////////////////////////////////////////////////////
-class SFML_API SocketHelper
-{
-public :
-
- ////////////////////////////////////////////////////////////
- // Define some socket types
- ////////////////////////////////////////////////////////////
- typedef SOCKET SocketType;
- typedef int LengthType;
-
- ////////////////////////////////////////////////////////////
- /// Return the value of the invalid socket
- ///
- /// \return Unique value of the invalid socket
- ///
- ////////////////////////////////////////////////////////////
- static SocketType InvalidSocket();
-
- ////////////////////////////////////////////////////////////
- /// Close / destroy a socket
- ///
- /// \param Socket : Socket to close
- ///
- /// \return True on success
- ///
- ////////////////////////////////////////////////////////////
- static bool Close(SocketType Socket);
-
- ////////////////////////////////////////////////////////////
- /// Set a socket as blocking or non-blocking
- ///
- /// \param Socket : Socket to modify
- /// \param Block : New blocking state of the socket
- ///
- ////////////////////////////////////////////////////////////
- static void SetBlocking(SocketType Socket, bool Block);
-
- ////////////////////////////////////////////////////////////
- /// Get the last socket error status
- ///
- /// \return Status corresponding to the last socket error
- ///
- ////////////////////////////////////////////////////////////
- static Socket::Status GetErrorStatus();
-};
-
-} // namespace sf
-
-
-#endif // SFML_SOCKETHELPERWIN32_HPP
diff --git a/include/SFML/Window/OpenGL.hpp b/include/SFML/OpenGL.hpp index fcd4868..3d04603 100755..100644 --- a/include/SFML/Window/OpenGL.hpp +++ b/include/SFML/OpenGL.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -38,7 +38,11 @@ ////////////////////////////////////////////////////////////
#if defined(SFML_SYSTEM_WINDOWS)
- #include <windows.h>
+ // The Visual C++ version of gl.h uses WINGDIAPI and APIENTRY but doesn't define them
+ #ifdef _MSC_VER
+ #include <windows.h>
+ #endif
+
#include <GL/gl.h>
#include <GL/glu.h>
@@ -56,4 +60,3 @@ #endif // SFML_OPENGL_HPP
-
diff --git a/include/SFML/System.hpp b/include/SFML/System.hpp index f2b6844..9d2166b 100755..100644 --- a/include/SFML/System.hpp +++ b/include/SFML/System.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -31,13 +31,26 @@ #include <SFML/Config.hpp>
#include <SFML/System/Clock.hpp>
+#include <SFML/System/Err.hpp>
+#include <SFML/System/InputStream.hpp>
#include <SFML/System/Lock.hpp>
#include <SFML/System/Mutex.hpp>
-#include <SFML/System/Randomizer.hpp>
#include <SFML/System/Sleep.hpp>
+#include <SFML/System/String.hpp>
#include <SFML/System/Thread.hpp>
-#include <SFML/System/Unicode.hpp>
+#include <SFML/System/ThreadLocal.hpp>
+#include <SFML/System/ThreadLocalPtr.hpp>
+#include <SFML/System/Utf.hpp>
#include <SFML/System/Vector2.hpp>
#include <SFML/System/Vector3.hpp>
#endif // SFML_SYSTEM_HPP
+
+////////////////////////////////////////////////////////////
+/// \defgroup system System module
+///
+/// Base module of SFML, defining various utilities. It provides
+/// vector classes, unicode strings and conversion functions,
+/// threads and mutexes, timing classes.
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/System/Clock.hpp b/include/SFML/System/Clock.hpp index 76c0055..4ae0f2d 100755..100644 --- a/include/SFML/System/Clock.hpp +++ b/include/SFML/System/Clock.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,47 +28,90 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
+#include <SFML/System/Export.hpp>
+#include <SFML/System/Time.hpp>
namespace sf
{
////////////////////////////////////////////////////////////
-/// Clock is an utility class for manipulating time
+/// \brief Utility class that measures the elapsed time
+///
////////////////////////////////////////////////////////////
-class SFML_API Clock
+class SFML_SYSTEM_API Clock
{
public :
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
+ ///
+ /// The clock starts automatically after being constructed.
///
////////////////////////////////////////////////////////////
Clock();
////////////////////////////////////////////////////////////
- /// Get the time elapsed since last reset
+ /// \brief Get the elapsed time
+ ///
+ /// This function returns the time elapsed since the last call
+ /// to restart() (or the construction of the instance if restart()
+ /// has not been called).
///
- /// \return Time elapsed, in seconds
+ /// \return Time elapsed
///
////////////////////////////////////////////////////////////
- float GetElapsedTime() const;
+ Time getElapsedTime() const;
////////////////////////////////////////////////////////////
- /// Restart the timer
+ /// \brief Restart the clock
+ ///
+ /// This function puts the time counter back to zero.
+ /// It also returns the time elapsed since the clock was started.
+ ///
+ /// \return Time elapsed
///
////////////////////////////////////////////////////////////
- void Reset();
+ Time restart();
private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- double myStartTime; ///< Time of last reset
+ Time m_startTime; ///< Time of last reset, in microseconds
};
} // namespace sf
#endif // SFML_CLOCK_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Clock
+/// \ingroup system
+///
+/// sf::Clock is a lightweight class for measuring time.
+///
+/// Its provides the most precise time that the underlying
+/// OS can achieve (generally microseconds or nanoseconds).
+/// It also ensures monotonicity, which means that the returned
+/// time can never go backward, even if the system time is
+/// changed.
+///
+/// Usage example:
+/// \code
+/// sf::Clock clock;
+/// ...
+/// Time time1 = clock.getElapsedTime();
+/// ...
+/// Time time2 = clock.restart();
+/// \endcode
+///
+/// The sf::Time value returned by the clock can then be
+/// converted to a number of seconds, milliseconds or even
+/// microseconds.
+///
+/// \see sf::Time
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/System/Err.hpp b/include/SFML/System/Err.hpp new file mode 100644 index 0000000..7903020 --- /dev/null +++ b/include/SFML/System/Err.hpp @@ -0,0 +1,78 @@ +////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+// you must not claim that you wrote the original software.
+// If you use this software in a product, an acknowledgment
+// in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+// and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_ERR_HPP
+#define SFML_ERR_HPP
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/System/Export.hpp>
+#include <ostream>
+
+
+namespace sf
+{
+////////////////////////////////////////////////////////////
+/// \brief Standard stream used by SFML to output warnings and errors
+///
+////////////////////////////////////////////////////////////
+SFML_SYSTEM_API std::ostream& err();
+
+} // namespace sf
+
+
+#endif // SFML_ERR_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \fn sf::err
+/// \ingroup system
+///
+/// By default, sf::err() outputs to the same location as std::cerr,
+/// (-> the stderr descriptor) which is the console if there's
+/// one available.
+///
+/// It is a standard std::ostream instance, so it supports all the
+/// insertion operations defined by the STL
+/// (operator <<, manipulators, etc.).
+///
+/// sf::err() can be redirected to write to another output, independantly
+/// of std::cerr, by using the rdbuf() function provided by the
+/// std::ostream class.
+///
+/// Example:
+/// \code
+/// // Redirect to a file
+/// std::ofstream file("sfml-log.txt");
+/// std::streambuf* previous = sf::err().rdbuf(file.rdbuf());
+///
+/// // Redirect to nothing
+/// sf::err().rdbuf(NULL);
+///
+/// // Restore the original output
+/// sf::err().rdbuf(previous);
+/// \endcode
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/System/Export.hpp b/include/SFML/System/Export.hpp new file mode 100644 index 0000000..ec08fbe --- /dev/null +++ b/include/SFML/System/Export.hpp @@ -0,0 +1,48 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_SYSTEM_EXPORT_HPP +#define SFML_SYSTEM_EXPORT_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Config.hpp> + + +//////////////////////////////////////////////////////////// +// Define portable import / export macros +//////////////////////////////////////////////////////////// +#if defined(SFML_SYSTEM_EXPORTS) + + #define SFML_SYSTEM_API SFML_API_EXPORT + +#else + + #define SFML_SYSTEM_API SFML_API_IMPORT + +#endif + + +#endif // SFML_SYSTEM_EXPORT_HPP diff --git a/include/SFML/System/InputStream.hpp b/include/SFML/System/InputStream.hpp new file mode 100644 index 0000000..b79436a --- /dev/null +++ b/include/SFML/System/InputStream.hpp @@ -0,0 +1,151 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_INPUTSTREAM_HPP +#define SFML_INPUTSTREAM_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Config.hpp> + + +namespace sf +{ +//////////////////////////////////////////////////////////// +/// \brief Abstract class for custom file input streams +/// +//////////////////////////////////////////////////////////// +class InputStream +{ +public : + + //////////////////////////////////////////////////////////// + /// \brief Virtual destructor + /// + //////////////////////////////////////////////////////////// + virtual ~InputStream() {} + + //////////////////////////////////////////////////////////// + /// \brief Read data from the stream + /// + /// After reading, the stream's reading position must be + /// advanced by the amount of bytes read. + /// + /// \param data Buffer where to copy the read data + /// \param size Desired number of bytes to read + /// + /// \return The number of bytes actually read, or -1 on error + /// + //////////////////////////////////////////////////////////// + virtual Int64 read(void* data, Int64 size) = 0; + + //////////////////////////////////////////////////////////// + /// \brief Change the current reading position + /// + /// \param position The position to seek to, from the beginning + /// + /// \return The position actually sought to, or -1 on error + /// + //////////////////////////////////////////////////////////// + virtual Int64 seek(Int64 position) = 0; + + //////////////////////////////////////////////////////////// + /// \brief Get the current reading position in the stream + /// + /// \return The current position, or -1 on error. + /// + //////////////////////////////////////////////////////////// + virtual Int64 tell() = 0; + + //////////////////////////////////////////////////////////// + /// \brief Return the size of the stream + /// + /// \return The total number of bytes available in the stream, or -1 on error + /// + //////////////////////////////////////////////////////////// + virtual Int64 getSize() = 0; +}; + +} // namespace sf + + +#endif // SFML_INPUTSTREAM_HPP + + +//////////////////////////////////////////////////////////// +/// \class sf::InputStream +/// \ingroup system +/// +/// This class allows users to define their own file input sources +/// from which SFML can load resources. +/// +/// SFML resource classes like sf::Texture and +/// sf::SoundBuffer provide loadFromFile and loadFromMemory functions, +/// which read data from conventional sources. However, if you +/// have data coming from a different source (over a network, +/// embedded, encrypted, compressed, etc) you can derive your +/// own class from sf::InputStream and load SFML resources with +/// their loadFromStream function. +/// +/// Usage example: +/// \code +/// // custom stream class that reads from inside a zip file +/// class ZipStream : public sf::InputStream +/// { +/// public : +/// +/// ZipStream(std::string archive); +/// +/// bool open(std::string filename); +/// +/// Int64 read(void* data, Int64 size); +/// +/// Int64 seek(Int64 position); +/// +/// Int64 tell(); +/// +/// Int64 getSize(); +/// +/// private : +/// +/// ... +/// }; +/// +/// // now you can load textures... +/// sf::Texture texture; +/// ZipStream stream("resources.zip"); +/// stream.open("images/img.png"); +/// texture.loadFromStream(stream); +/// +/// // musics... +/// sf::Music music; +/// ZipStream stream("resources.zip"); +/// stream.open("musics/msc.ogg"); +/// music.openFromStream(stream); +/// +/// // etc. +/// \endcode +/// +//////////////////////////////////////////////////////////// diff --git a/include/SFML/System/Lock.hpp b/include/SFML/System/Lock.hpp index 6f84f73..09c2a8e 100755..100644 --- a/include/SFML/System/Lock.hpp +++ b/include/SFML/System/Lock.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,6 +28,7 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
+#include <SFML/System/Export.hpp>
#include <SFML/System/NonCopyable.hpp>
@@ -36,23 +37,27 @@ namespace sf class Mutex;
////////////////////////////////////////////////////////////
-/// Lock is an exception-safe automatic wrapper for
-/// locking and unlocking mutexes
+/// \brief Automatic wrapper for locking and unlocking mutexes
+///
////////////////////////////////////////////////////////////
-class SFML_API Lock : NonCopyable
+class SFML_SYSTEM_API Lock : NonCopyable
{
public :
////////////////////////////////////////////////////////////
- /// Construct the lock with a target mutex (lock it)
+ /// \brief Construct the lock with a target mutex
///
- /// @param Mutex : Mutex to lock
+ /// The mutex passed to sf::Lock is automatically locked.
+ ///
+ /// \param mutex Mutex to lock
///
////////////////////////////////////////////////////////////
- Lock(Mutex& Mutex);
+ explicit Lock(Mutex& mutex);
////////////////////////////////////////////////////////////
- /// Destructor (unlocks the mutex)
+ /// \brief Destructor
+ ///
+ /// The destructor of sf::Lock automatically unlocks its mutex.
///
////////////////////////////////////////////////////////////
~Lock();
@@ -62,10 +67,73 @@ private : ////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- Mutex& myMutex; ///< Mutex to lock / unlock
+ Mutex& m_mutex; ///< Mutex to lock / unlock
};
} // namespace sf
#endif // SFML_LOCK_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Lock
+/// \ingroup system
+///
+/// sf::Lock is a RAII wrapper for sf::Mutex. By unlocking
+/// it in its destructor, it ensures that the mutex will
+/// always be released when the current scope (most likely
+/// a function) ends.
+/// This is even more important when an exception or an early
+/// return statement can interrupt the execution flow of the
+/// function.
+///
+/// For maximum robustness, sf::Lock should always be used
+/// to lock/unlock a mutex.
+///
+/// Usage example:
+/// \code
+/// sf::Mutex mutex;
+///
+/// void function()
+/// {
+/// sf::Lock lock(mutex); // mutex is now locked
+///
+/// functionThatMayThrowAnException(); // mutex is unlocked if this function throws
+///
+/// if (someCondition)
+/// return; // mutex is unlocked
+///
+/// } // mutex is unlocked
+/// \endcode
+///
+/// Because the mutex is not explicitely unlocked in the code,
+/// it may remain locked longer than needed. If the region
+/// of the code that needs to be protected by the mutex is
+/// not the entire function, a good practice is to create a
+/// smaller, inner scope so that the lock is limited to this
+/// part of the code.
+///
+/// \code
+/// sf::Mutex mutex;
+///
+/// void function()
+/// {
+/// {
+/// sf::Lock lock(mutex);
+/// codeThatRequiresProtection();
+///
+/// } // mutex is unlocked here
+///
+/// codeThatDoesntCareAboutTheMutex();
+/// }
+/// \endcode
+///
+/// Having a mutex locked longer than required is a bad practice
+/// which can lead to bad performances. Don't forget that when
+/// a mutex is locked, other threads may be waiting doing nothing
+/// until it is released.
+///
+/// \see sf::Mutex
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/System/Mutex.hpp b/include/SFML/System/Mutex.hpp index 536c537..ac95236 100755..100644 --- a/include/SFML/System/Mutex.hpp +++ b/include/SFML/System/Mutex.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,18 +28,121 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
+#include <SFML/System/Export.hpp>
+#include <SFML/System/NonCopyable.hpp>
-#ifdef SFML_SYSTEM_WINDOWS
+namespace sf
+{
+namespace priv
+{
+ class MutexImpl;
+}
- #include <SFML/System/Win32/Mutex.hpp>
+////////////////////////////////////////////////////////////
+/// \brief Blocks concurrent access to shared resources
+/// from multiple threads
+///
+////////////////////////////////////////////////////////////
+class SFML_SYSTEM_API Mutex : NonCopyable
+{
+public :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Default constructor
+ ///
+ ////////////////////////////////////////////////////////////
+ Mutex();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Destructor
+ ///
+ ////////////////////////////////////////////////////////////
+ ~Mutex();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Lock the mutex
+ ///
+ /// If the mutex is already locked in another thread,
+ /// this call will block the execution until the mutex
+ /// is released.
+ ///
+ /// \see unlock
+ ///
+ ////////////////////////////////////////////////////////////
+ void lock();
-#else
+ ////////////////////////////////////////////////////////////
+ /// \brief Unlock the mutex
+ ///
+ /// \see lock
+ ///
+ ////////////////////////////////////////////////////////////
+ void unlock();
- #include <SFML/System/Unix/Mutex.hpp>
+private :
-#endif
+ ////////////////////////////////////////////////////////////
+ // Member data
+ ////////////////////////////////////////////////////////////
+ priv::MutexImpl* m_mutexImpl; ///< OS-specific implementation
+};
+
+} // namespace sf
#endif // SFML_MUTEX_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Mutex
+/// \ingroup system
+///
+/// Mutex stands for "MUTual EXclusion". A mutex is a
+/// synchronization object, used when multiple threads are involved.
+///
+/// When you want to protect a part of the code from being accessed
+/// simultaneously by multiple threads, you typically use a
+/// mutex. When a thread is locked by a mutex, any other thread
+/// trying to lock it will be blocked until the mutex is released
+/// by the thread that locked it. This way, you can allow only
+/// one thread at a time to access a critical region of your code.
+///
+/// Usage example:
+/// \code
+/// Database database; // this is a critical resource that needs some protection
+/// sf::Mutex mutex;
+///
+/// void thread1()
+/// {
+/// mutex.lock(); // this call will block the thread if the mutex is already locked by thread2
+/// database.write(...);
+/// mutex.unlock(); // if thread2 was waiting, it will now be unblocked
+/// }
+///
+/// void thread2()
+/// {
+/// mutex.lock(); // this call will block the thread if the mutex is already locked by thread1
+/// database.write(...);
+/// mutex.unlock(); // if thread1 was waiting, it will now be unblocked
+/// }
+/// \endcode
+///
+/// Be very careful with mutexes. A bad usage can lead to bad problems,
+/// like deadlocks (two threads are waiting for each other and the
+/// application is globally stuck).
+///
+/// To make the usage of mutexes more robust, particularly in
+/// environments where exceptions can be thrown, you should
+/// use the helper class sf::Lock to lock/unlock mutexes.
+///
+/// SFML mutexes are recursive, which means that you can lock
+/// a mutex multiple times in the same thread without creating
+/// a deadlock. In this case, the first call to lock() behaves
+/// as usual, and the following ones have no effect.
+/// However, you must call unlock() exactly as many times as you
+/// called lock(). If you don't, the mutex won't be released.
+///
+/// \see sf::Lock
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/System/NonCopyable.hpp b/include/SFML/System/NonCopyable.hpp index 3ac6719..8c9cdb6 100755..100644 --- a/include/SFML/System/NonCopyable.hpp +++ b/include/SFML/System/NonCopyable.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,21 +28,26 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
+#include <SFML/System/Export.hpp>
namespace sf
{
////////////////////////////////////////////////////////////
-/// Utility base class to easily declare non-copyable classes.
-/// Just inherit from NonCopyable to get a non-copyable class
+/// \brief Utility class that makes any derived
+/// class non-copyable
+///
////////////////////////////////////////////////////////////
-struct SFML_API NonCopyable
+class SFML_SYSTEM_API NonCopyable
{
protected :
////////////////////////////////////////////////////////////
- /// The default constructor won't be generated, so provide it
+ /// \brief Default constructor
+ ///
+ /// Because this class has a copy constructor, the compiler
+ /// will not automatically generate the default constructor.
+ /// That's why we must define it explicitely.
///
////////////////////////////////////////////////////////////
NonCopyable() {}
@@ -50,15 +55,25 @@ protected : private :
////////////////////////////////////////////////////////////
- /// Copy constructor : declare it private and don't implement
- /// it to prevent from calling it
+ /// \brief Disabled copy constructor
+ ///
+ /// By making the copy constructor private, the compiler will
+ /// trigger an error if anyone outside tries to use it.
+ /// To prevent NonCopyable or friend classes from using it,
+ /// we also give no definition, so that the linker will
+ /// produce an error if the first protection was inefficient.
///
////////////////////////////////////////////////////////////
NonCopyable(const NonCopyable&);
////////////////////////////////////////////////////////////
- /// Assignment operator : declare it private and don't implement
- /// it to prevent from calling it
+ /// \brief Disabled assignment operator
+ ///
+ /// By making the assignment operator private, the compiler will
+ /// trigger an error if anyone outside tries to use it.
+ /// To prevent NonCopyable or friend classes from using it,
+ /// we also give no definition, so that the linker will
+ /// produce an error if the first protection was inefficient.
///
////////////////////////////////////////////////////////////
NonCopyable& operator =(const NonCopyable&);
@@ -68,3 +83,37 @@ private : #endif // SFML_NONCOPYABLE_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::NonCopyable
+/// \ingroup system
+///
+/// This class makes its instances non-copyable, by explicitely
+/// disabling its copy constructor and its assignment operator.
+///
+/// To create a non-copyable class, simply inherit from
+/// sf::NonCopyable.
+///
+/// The type of inheritance (public or private) doesn't matter,
+/// the copy constructor and assignment operator are declared private
+/// in sf::NonCopyable so they will end up being inaccessible in both
+/// cases. Thus you can use a shorter syntax for inheriting from it
+/// (see below).
+///
+/// Usage example:
+/// \code
+/// class MyNonCopyableClass : sf::NonCopyable
+/// {
+/// ...
+/// };
+/// \endcode
+///
+/// Deciding whether the instances of a class can be copied
+/// or not is a very important design choice. You are strongly
+/// encouraged to think about it before writing a class,
+/// and to use sf::NonCopyable when necessary to prevent
+/// many potential future errors when using it. This is also
+/// a very important indication to users of your class.
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/System/Randomizer.hpp b/include/SFML/System/Randomizer.hpp deleted file mode 100755 index 8ed27cd..0000000 --- a/include/SFML/System/Randomizer.hpp +++ /dev/null @@ -1,94 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_RANDOMIZER_HPP
-#define SFML_RANDOMIZER_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
-
-
-namespace sf
-{
-////////////////////////////////////////////////////////////
-/// Randomizer is an utility class for generating pseudo-random
-/// numbers
-////////////////////////////////////////////////////////////
-class SFML_API Randomizer
-{
-public :
-
- ////////////////////////////////////////////////////////////
- /// Set the seed for the generator. Using a known seed
- /// allows you to reproduce the same sequence of random number
- ///
- /// \param Seed : Number to use as the seed
- ///
- ////////////////////////////////////////////////////////////
- static void SetSeed(unsigned int Seed);
-
- ////////////////////////////////////////////////////////////
- /// Get the seed used to generate random numbers the generator.
- ///
- /// \return Current seed
- ///
- ////////////////////////////////////////////////////////////
- static unsigned int GetSeed();
-
- ////////////////////////////////////////////////////////////
- /// Get a random float number in a given range
- ///
- /// \return Start : Start of the range
- /// \return End : End of the range
- ///
- /// \return Random number in [Begin, End]
- ///
- ////////////////////////////////////////////////////////////
- static float Random(float Begin, float End);
-
- ////////////////////////////////////////////////////////////
- /// Get a random integer number in a given range
- ///
- /// \return Start : Start of the range
- /// \return End : End of the range
- ///
- /// \return Random number in [Begin, End]
- ///
- ////////////////////////////////////////////////////////////
- static int Random(int Begin, int End);
-
-private :
-
- ////////////////////////////////////////////////////////////
- // Static member variables
- ////////////////////////////////////////////////////////////
- static unsigned int ourSeed;
-};
-
-} // namespace sf
-
-
-#endif // SFML_RANDOMIZER_HPP
diff --git a/include/SFML/System/Resource.hpp b/include/SFML/System/Resource.hpp deleted file mode 100755 index 8f5088d..0000000 --- a/include/SFML/System/Resource.hpp +++ /dev/null @@ -1,216 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_RESOURCE_HPP
-#define SFML_RESOURCE_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <set>
-
-
-namespace sf
-{
-////////////////////////////////////////////////////////////
-// These two classes are defined in the same header because
-// they depend on each other. And as they're template classes,
-// they must be entirely defined in header files, which
-// prevents from proper separate compiling
-////////////////////////////////////////////////////////////
-
-template <typename> class ResourcePtr;
-
-////////////////////////////////////////////////////////////
-/// Base class for every resource that needs to notify
-/// dependent classes about its destruction
-////////////////////////////////////////////////////////////
-template <typename T>
-class Resource
-{
-protected :
-
- ////////////////////////////////////////////////////////////
- /// Default constructor
- ///
- ////////////////////////////////////////////////////////////
- Resource();
-
- ////////////////////////////////////////////////////////////
- /// Copy constructor
- ///
- /// \param Copy : Resource to copy
- ///
- ////////////////////////////////////////////////////////////
- Resource(const Resource<T>& Copy);
-
- ////////////////////////////////////////////////////////////
- /// Destructor
- ///
- ////////////////////////////////////////////////////////////
- ~Resource();
-
- ////////////////////////////////////////////////////////////
- /// Assignment operator
- ///
- /// \param Other : Resource to copy
- ///
- /// \return Reference to this
- ///
- ////////////////////////////////////////////////////////////
- Resource<T>& operator =(const Resource<T>& Other);
-
-private :
-
- friend class ResourcePtr<T>;
-
- ////////////////////////////////////////////////////////////
- /// Connect a ResourcePtr to this resource
- ///
- /// \param Observer : Observer to add
- ///
- ////////////////////////////////////////////////////////////
- void Connect(ResourcePtr<T>& Observer) const;
-
- ////////////////////////////////////////////////////////////
- /// Disconnect a ResourcePtr from this resource
- ///
- /// \param Observer : Observer to remove
- ///
- ////////////////////////////////////////////////////////////
- void Disconnect(ResourcePtr<T>& Observer) const;
-
- ////////////////////////////////////////////////////////////
- // Member data
- ////////////////////////////////////////////////////////////
- mutable std::set<ResourcePtr<T>*> myObservers;
-};
-
-
-////////////////////////////////////////////////////////////
-/// Safe pointer to a T resource (inheriting from sf::Resource<T>),
-/// its pointer is automatically reseted when the resource is destroyed
-////////////////////////////////////////////////////////////
-template <typename T>
-class ResourcePtr
-{
-public :
-
- ////////////////////////////////////////////////////////////
- /// Default constructor
- ///
- ////////////////////////////////////////////////////////////
- ResourcePtr();
-
- ////////////////////////////////////////////////////////////
- /// Construct from a raw resource
- ///
- /// \param Resource : Internal resource
- ///
- ////////////////////////////////////////////////////////////
- ResourcePtr(const T* Resource);
-
- ////////////////////////////////////////////////////////////
- /// Copy constructor
- ///
- /// \param Copy : Instance to copy
- ///
- ////////////////////////////////////////////////////////////
- ResourcePtr(const ResourcePtr<T>& Copy);
-
- ////////////////////////////////////////////////////////////
- /// Destructor
- ///
- ////////////////////////////////////////////////////////////
- ~ResourcePtr();
-
- ////////////////////////////////////////////////////////////
- /// Assignment operator from another ResourcePtr
- ///
- /// \param Other : Resource pointer to assign
- ///
- /// \return Reference to this
- ///
- ////////////////////////////////////////////////////////////
- ResourcePtr<T>& operator =(const ResourcePtr<T>& Other);
-
- ////////////////////////////////////////////////////////////
- /// Assignment operator from a raw resource
- ///
- /// \param Resource : Resource to assign
- ///
- /// \return Reference to this
- ///
- ////////////////////////////////////////////////////////////
- ResourcePtr<T>& operator =(const T* Resource);
-
- ////////////////////////////////////////////////////////////
- /// Cast operator to implicitely convert the resource pointer to
- /// its raw pointer type.
- /// This might be dangerous in the general case, but in this context
- /// it is safe enough to define this operator
- ///
- /// \return Pointer to the actual resource
- ///
- ////////////////////////////////////////////////////////////
- operator const T*() const;
-
- ////////////////////////////////////////////////////////////
- /// Operator * overload to return a reference to the actual resource
- ///
- /// \return Reference to the internal resource
- ///
- ////////////////////////////////////////////////////////////
- const T& operator *() const;
-
- ////////////////////////////////////////////////////////////
- /// Operator -> overload to return a pointer to the actual resource
- ///
- /// \return Pointer to the internal resource
- ///
- ////////////////////////////////////////////////////////////
- const T* operator ->() const;
-
- ////////////////////////////////////////////////////////////
- /// Function called when the observed resource is about to be
- /// destroyed
- ///
- ////////////////////////////////////////////////////////////
- void OnResourceDestroyed();
-
-private :
-
- ////////////////////////////////////////////////////////////
- // Member data
- ////////////////////////////////////////////////////////////
- const T* myResource; /// Pointer to the actual resource
-};
-
-#include <SFML/System/Resource.inl>
-#include <SFML/System/ResourcePtr.inl>
-
-} // namespace sf
-
-
-#endif // SFML_RESOURCE_HPP
diff --git a/include/SFML/System/ResourcePtr.inl b/include/SFML/System/ResourcePtr.inl deleted file mode 100755 index dbfcd0d..0000000 --- a/include/SFML/System/ResourcePtr.inl +++ /dev/null @@ -1,149 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-
-////////////////////////////////////////////////////////////
-/// Default constructor
-////////////////////////////////////////////////////////////
-template <typename T>
-ResourcePtr<T>::ResourcePtr() :
-myResource(NULL)
-{
-
-}
-
-
-////////////////////////////////////////////////////////////
-/// Construct from a raw resource
-////////////////////////////////////////////////////////////
-template <typename T>
-ResourcePtr<T>::ResourcePtr(const T* Resource) :
-myResource(Resource)
-{
- if (myResource)
- myResource->Connect(*this);
-}
-
-
-////////////////////////////////////////////////////////////
-/// Copy constructor
-////////////////////////////////////////////////////////////
-template <typename T>
-ResourcePtr<T>::ResourcePtr(const ResourcePtr<T>& Copy) :
-myResource(Copy.myResource)
-{
- if (myResource)
- myResource->Connect(*this);
-}
-
-
-////////////////////////////////////////////////////////////
-/// Destructor
-////////////////////////////////////////////////////////////
-template <typename T>
-ResourcePtr<T>::~ResourcePtr()
-{
- if (myResource)
- myResource->Disconnect(*this);
-}
-
-
-////////////////////////////////////////////////////////////
-/// Assignment operator from another ResourcePtr
-////////////////////////////////////////////////////////////
-template <typename T>
-ResourcePtr<T>& ResourcePtr<T>::operator =(const ResourcePtr<T>& Other)
-{
- if (myResource)
- myResource->Disconnect(*this);
-
- myResource = Other.myResource;
-
- if (myResource)
- myResource->Connect(*this);
-
- return *this;
-}
-
-
-////////////////////////////////////////////////////////////
-/// Assignment operator from a raw resource
-////////////////////////////////////////////////////////////
-template <typename T>
-ResourcePtr<T>& ResourcePtr<T>::operator =(const T* Resource)
-{
- if (myResource)
- myResource->Disconnect(*this);
-
- myResource = Resource;
-
- if (myResource)
- myResource->Connect(*this);
-
- return *this;
-}
-
-
-////////////////////////////////////////////////////////////
-/// Cast operator to implicitely convert the resource pointer to
-/// its raw pointer type.
-/// This might be dangerous in the general case, but in this context
-/// it is safe enough to define this operator
-////////////////////////////////////////////////////////////
-template <typename T>
-ResourcePtr<T>::operator const T*() const
-{
- return myResource;
-}
-
-
-////////////////////////////////////////////////////////////
-/// Operator * overload to return a reference to the actual resource
-////////////////////////////////////////////////////////////
-template <typename T>
-const T& ResourcePtr<T>::operator *() const
-{
- return *myResource;
-}
-
-
-////////////////////////////////////////////////////////////
-/// Operator -> overload to return a pointer to the actual resource
-////////////////////////////////////////////////////////////
-template <typename T>
-const T* ResourcePtr<T>::operator ->() const
-{
- return myResource;
-}
-
-
-////////////////////////////////////////////////////////////
-/// Function called when the observed resource is about to be
-/// destroyed
-////////////////////////////////////////////////////////////
-template <typename T>
-void ResourcePtr<T>::OnResourceDestroyed()
-{
- myResource = NULL;
-}
diff --git a/include/SFML/System/Sleep.hpp b/include/SFML/System/Sleep.hpp index 2d0ebca..47567a9 100755..100644 --- a/include/SFML/System/Sleep.hpp +++ b/include/SFML/System/Sleep.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,18 +28,23 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
+#include <SFML/System/Export.hpp>
+#include <SFML/System/Time.hpp>
namespace sf
{
- ////////////////////////////////////////////////////////////
- /// Make the current thread sleep for a given time
- ///
- /// \param Duration : Time to sleep, in seconds (must be >= 0)
- ///
- ////////////////////////////////////////////////////////////
- void SFML_API Sleep(float Duration);
+////////////////////////////////////////////////////////////
+/// \ingroup system
+/// \brief Make the current thread sleep for a given duration
+///
+/// sf::sleep is the best way to block a program or one of its
+/// threads, as it doesn't consume any CPU power.
+///
+/// \param duration Time to sleep
+///
+////////////////////////////////////////////////////////////
+void SFML_SYSTEM_API sleep(Time duration);
} // namespace sf
diff --git a/include/SFML/System/String.hpp b/include/SFML/System/String.hpp new file mode 100644 index 0000000..080a809 --- /dev/null +++ b/include/SFML/System/String.hpp @@ -0,0 +1,543 @@ +////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+// you must not claim that you wrote the original software.
+// If you use this software in a product, an acknowledgment
+// in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+// and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_STRING_HPP
+#define SFML_STRING_HPP
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/System/Export.hpp>
+#include <locale>
+#include <string>
+
+
+namespace sf
+{
+////////////////////////////////////////////////////////////
+/// \brief Utility string class that automatically handles
+/// conversions between types and encodings
+///
+////////////////////////////////////////////////////////////
+class SFML_SYSTEM_API String
+{
+public :
+
+ ////////////////////////////////////////////////////////////
+ // Types
+ ////////////////////////////////////////////////////////////
+ typedef std::basic_string<Uint32>::iterator Iterator; ///< Iterator type
+ typedef std::basic_string<Uint32>::const_iterator ConstIterator; ///< Constant iterator type
+
+ ////////////////////////////////////////////////////////////
+ // Static member data
+ ////////////////////////////////////////////////////////////
+ static const std::size_t InvalidPos; ///< Represents an invalid position in the string
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Default constructor
+ ///
+ /// This constructor creates an empty string.
+ ///
+ ////////////////////////////////////////////////////////////
+ String();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Construct from a single ANSI character and a locale
+ ///
+ /// The source character is converted to UTF-32 according
+ /// to the given locale.
+ ///
+ /// \param ansiChar ANSI character to convert
+ /// \param locale Locale to use for conversion
+ ///
+ ////////////////////////////////////////////////////////////
+ String(char ansiChar, const std::locale& locale = std::locale());
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Construct from single wide character
+ ///
+ /// \param wideChar Wide character to convert
+ ///
+ ////////////////////////////////////////////////////////////
+ String(wchar_t wideChar);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Construct from single UTF-32 character
+ ///
+ /// \param utf32Char UTF-32 character to convert
+ ///
+ ////////////////////////////////////////////////////////////
+ String(Uint32 utf32Char);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Construct from a null-terminated C-style ANSI string and a locale
+ ///
+ /// The source string is converted to UTF-32 according
+ /// to the given locale.
+ ///
+ /// \param ansiString ANSI string to convert
+ /// \param locale Locale to use for conversion
+ ///
+ ////////////////////////////////////////////////////////////
+ String(const char* ansiString, const std::locale& locale = std::locale());
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Construct from an ANSI string and a locale
+ ///
+ /// The source string is converted to UTF-32 according
+ /// to the given locale.
+ ///
+ /// \param ansiString ANSI string to convert
+ /// \param locale Locale to use for conversion
+ ///
+ ////////////////////////////////////////////////////////////
+ String(const std::string& ansiString, const std::locale& locale = std::locale());
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Construct from null-terminated C-style wide string
+ ///
+ /// \param wideString Wide string to convert
+ ///
+ ////////////////////////////////////////////////////////////
+ String(const wchar_t* wideString);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Construct from a wide string
+ ///
+ /// \param wideString Wide string to convert
+ ///
+ ////////////////////////////////////////////////////////////
+ String(const std::wstring& wideString);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Construct from a null-terminated C-style UTF-32 string
+ ///
+ /// \param utf32String UTF-32 string to assign
+ ///
+ ////////////////////////////////////////////////////////////
+ String(const Uint32* utf32String);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Construct from an UTF-32 string
+ ///
+ /// \param utf32String UTF-32 string to assign
+ ///
+ ////////////////////////////////////////////////////////////
+ String(const std::basic_string<Uint32>& utf32String);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Copy constructor
+ ///
+ /// \param copy Instance to copy
+ ///
+ ////////////////////////////////////////////////////////////
+ String(const String& copy);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Implicit cast operator to std::string (ANSI string)
+ ///
+ /// The current global locale is used for conversion. If you
+ /// want to explicitely specify a locale, see toAnsiString.
+ /// Characters that do not fit in the target encoding are
+ /// discarded from the returned string.
+ /// This operator is defined for convenience, and is equivalent
+ /// to calling toAnsiString().
+ ///
+ /// \return Converted ANSI string
+ ///
+ /// \see toAnsiString, operator std::wstring
+ ///
+ ////////////////////////////////////////////////////////////
+ operator std::string() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Implicit cast operator to std::wstring (wide string)
+ ///
+ /// Characters that do not fit in the target encoding are
+ /// discarded from the returned string.
+ /// This operator is defined for convenience, and is equivalent
+ /// to calling toWideString().
+ ///
+ /// \return Converted wide string
+ ///
+ /// \see toWideString, operator std::string
+ ///
+ ////////////////////////////////////////////////////////////
+ operator std::wstring() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert the unicode string to an ANSI string
+ ///
+ /// The UTF-32 string is converted to an ANSI string in
+ /// the encoding defined by \a locale.
+ /// Characters that do not fit in the target encoding are
+ /// discarded from the returned string.
+ ///
+ /// \param locale Locale to use for conversion
+ ///
+ /// \return Converted ANSI string
+ ///
+ /// \see toWideString, operator std::string
+ ///
+ ////////////////////////////////////////////////////////////
+ std::string toAnsiString(const std::locale& locale = std::locale()) const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert the unicode string to a wide string
+ ///
+ /// Characters that do not fit in the target encoding are
+ /// discarded from the returned string.
+ ///
+ /// \return Converted wide string
+ ///
+ /// \see toAnsiString, operator std::wstring
+ ///
+ ////////////////////////////////////////////////////////////
+ std::wstring toWideString() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Overload of assignment operator
+ ///
+ /// \param right Instance to assign
+ ///
+ /// \return Reference to self
+ ///
+ ////////////////////////////////////////////////////////////
+ String& operator =(const String& right);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Overload of += operator to append an UTF-32 string
+ ///
+ /// \param right String to append
+ ///
+ /// \return Reference to self
+ ///
+ ////////////////////////////////////////////////////////////
+ String& operator +=(const String& right);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Overload of [] operator to access a character by its position
+ ///
+ /// This function provides read-only access to characters.
+ /// Note: this function doesn't throw if \a index is out of range.
+ ///
+ /// \param index Index of the character to get
+ ///
+ /// \return Character at position \a index
+ ///
+ ////////////////////////////////////////////////////////////
+ Uint32 operator [](std::size_t index) const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Overload of [] operator to access a character by its position
+ ///
+ /// This function provides read and write access to characters.
+ /// Note: this function doesn't throw if \a index is out of range.
+ ///
+ /// \param index Index of the character to get
+ ///
+ /// \return Reference to the character at position \a index
+ ///
+ ////////////////////////////////////////////////////////////
+ Uint32& operator [](std::size_t index);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Clear the string
+ ///
+ /// This function removes all the characters from the string.
+ ///
+ /// \see isEmpty, erase
+ ///
+ ////////////////////////////////////////////////////////////
+ void clear();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get the size of the string
+ ///
+ /// \return Number of characters in the string
+ ///
+ /// \see isEmpty
+ ///
+ ////////////////////////////////////////////////////////////
+ std::size_t getSize() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Check whether the string is empty or not
+ ///
+ /// \return True if the string is empty (i.e. contains no character)
+ ///
+ /// \see clear, getSize
+ ///
+ ////////////////////////////////////////////////////////////
+ bool isEmpty() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Erase one or more characters from the string
+ ///
+ /// This function removes a sequence of \a count characters
+ /// starting from \a position.
+ ///
+ /// \param position Position of the first character to erase
+ /// \param count Number of characters to erase
+ ///
+ ////////////////////////////////////////////////////////////
+ void erase(std::size_t position, std::size_t count = 1);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Insert one or more characters into the string
+ ///
+ /// This function inserts the characters of \a str
+ /// into the string, starting from \a position.
+ ///
+ /// \param position Position of insertion
+ /// \param str Characters to insert
+ ///
+ ////////////////////////////////////////////////////////////
+ void insert(std::size_t position, const String& str);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Find a sequence of one or more characters in the string
+ ///
+ /// This function searches for the characters of \a str
+ /// into the string, starting from \a start.
+ ///
+ /// \param str Characters to find
+ /// \param start Where to begin searching
+ ///
+ /// \return Position of \a str in the string, or String::InvalidPos if not found
+ ///
+ ////////////////////////////////////////////////////////////
+ std::size_t find(const String& str, std::size_t start = 0) const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Get a pointer to the C-style array of characters
+ ///
+ /// This functions provides a read-only access to a
+ /// null-terminated C-style representation of the string.
+ /// The returned pointer is temporary and is meant only for
+ /// immediate use, thus it is not recommended to store it.
+ ///
+ /// \return Read-only pointer to the array of characters
+ ///
+ ////////////////////////////////////////////////////////////
+ const Uint32* getData() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Return an iterator to the beginning of the string
+ ///
+ /// \return Read-write iterator to the beginning of the string characters
+ ///
+ /// \see end
+ ///
+ ////////////////////////////////////////////////////////////
+ Iterator begin();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Return an iterator to the beginning of the string
+ ///
+ /// \return Read-only iterator to the beginning of the string characters
+ ///
+ /// \see end
+ ///
+ ////////////////////////////////////////////////////////////
+ ConstIterator begin() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Return an iterator to the beginning of the string
+ ///
+ /// The end iterator refers to 1 position past the last character;
+ /// thus it represents an invalid character and should never be
+ /// accessed.
+ ///
+ /// \return Read-write iterator to the end of the string characters
+ ///
+ /// \see begin
+ ///
+ ////////////////////////////////////////////////////////////
+ Iterator end();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Return an iterator to the beginning of the string
+ ///
+ /// The end iterator refers to 1 position past the last character;
+ /// thus it represents an invalid character and should never be
+ /// accessed.
+ ///
+ /// \return Read-only iterator to the end of the string characters
+ ///
+ /// \see begin
+ ///
+ ////////////////////////////////////////////////////////////
+ ConstIterator end() const;
+
+private :
+
+ friend SFML_SYSTEM_API bool operator ==(const String& left, const String& right);
+ friend SFML_SYSTEM_API bool operator <(const String& left, const String& right);
+
+ ////////////////////////////////////////////////////////////
+ // Member data
+ ////////////////////////////////////////////////////////////
+ std::basic_string<Uint32> m_string; ///< Internal string of UTF-32 characters
+};
+
+////////////////////////////////////////////////////////////
+/// \relates String
+/// \brief Overload of == operator to compare two UTF-32 strings
+///
+/// \param left Left operand (a string)
+/// \param right Right operand (a string)
+///
+/// \return True if both strings are equal
+///
+////////////////////////////////////////////////////////////
+SFML_SYSTEM_API bool operator ==(const String& left, const String& right);
+
+////////////////////////////////////////////////////////////
+/// \relates String
+/// \brief Overload of != operator to compare two UTF-32 strings
+///
+/// \param left Left operand (a string)
+/// \param right Right operand (a string)
+///
+/// \return True if both strings are different
+///
+////////////////////////////////////////////////////////////
+SFML_SYSTEM_API bool operator !=(const String& left, const String& right);
+
+////////////////////////////////////////////////////////////
+/// \relates String
+/// \brief Overload of < operator to compare two UTF-32 strings
+///
+/// \param left Left operand (a string)
+/// \param right Right operand (a string)
+///
+/// \return True if \a left is alphabetically lesser than \a right
+///
+////////////////////////////////////////////////////////////
+SFML_SYSTEM_API bool operator <(const String& left, const String& right);
+
+////////////////////////////////////////////////////////////
+/// \relates String
+/// \brief Overload of > operator to compare two UTF-32 strings
+///
+/// \param left Left operand (a string)
+/// \param right Right operand (a string)
+///
+/// \return True if \a left is alphabetically greater than \a right
+///
+////////////////////////////////////////////////////////////
+SFML_SYSTEM_API bool operator >(const String& left, const String& right);
+
+////////////////////////////////////////////////////////////
+/// \relates String
+/// \brief Overload of <= operator to compare two UTF-32 strings
+///
+/// \param left Left operand (a string)
+/// \param right Right operand (a string)
+///
+/// \return True if \a left is alphabetically lesser or equal than \a right
+///
+////////////////////////////////////////////////////////////
+SFML_SYSTEM_API bool operator <=(const String& left, const String& right);
+
+////////////////////////////////////////////////////////////
+/// \relates String
+/// \brief Overload of >= operator to compare two UTF-32 strings
+///
+/// \param left Left operand (a string)
+/// \param right Right operand (a string)
+///
+/// \return True if \a left is alphabetically greater or equal than \a right
+///
+////////////////////////////////////////////////////////////
+SFML_SYSTEM_API bool operator >=(const String& left, const String& right);
+
+////////////////////////////////////////////////////////////
+/// \relates String
+/// \brief Overload of binary + operator to concatenate two strings
+///
+/// \param left Left operand (a string)
+/// \param right Right operand (a string)
+///
+/// \return Concatenated string
+///
+////////////////////////////////////////////////////////////
+SFML_SYSTEM_API String operator +(const String& left, const String& right);
+
+} // namespace sf
+
+
+#endif // SFML_STRING_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::String
+/// \ingroup system
+///
+/// sf::String is a utility string class defined mainly for
+/// convenience. It is a Unicode string (implemented using
+/// UTF-32), thus it can store any character in the world
+/// (european, chinese, arabic, hebrew, etc.).
+///
+/// It automatically handles conversions from/to ANSI and
+/// wide strings, so that you can work with standard string
+/// classes and still be compatible with functions taking a
+/// sf::String.
+///
+/// \code
+/// sf::String s;
+///
+/// std::string s1 = s; // automatically converted to ANSI string
+/// std::wstring s2 = s; // automatically converted to wide string
+/// s = "hello"; // automatically converted from ANSI string
+/// s = L"hello"; // automatically converted from wide string
+/// s += 'a'; // automatically converted from ANSI string
+/// s += L'a'; // automatically converted from wide string
+/// \endcode
+///
+/// Conversions involving ANSI strings use the default user locale. However
+/// it is possible to use a custom locale if necessary:
+/// \code
+/// std::locale locale;
+/// sf::String s;
+/// ...
+/// std::string s1 = s.toAnsiString(locale);
+/// s = sf::String("hello", locale);
+/// \endcode
+///
+/// sf::String defines the most important functions of the
+/// standard std::string class: removing, random access, iterating,
+/// appending, comparing, etc. However it is a simple class
+/// provided for convenience, and you may have to consider using
+/// a more optimized class if your program requires complex string
+/// handling. The automatic conversion functions will then take
+/// care of converting your string to sf::String whenever SFML
+/// requires it.
+///
+/// Please note that SFML also defines a low-level, generic
+/// interface for Unicode handling, see the sf::Utf classes.
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/System/Thread.hpp b/include/SFML/System/Thread.hpp index 1cfe1e6..8313646 100755..100644 --- a/include/SFML/System/Thread.hpp +++ b/include/SFML/System/Thread.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,18 +28,255 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
+#include <SFML/System/Export.hpp>
+#include <SFML/System/NonCopyable.hpp>
+#include <cstdlib>
-#ifdef SFML_SYSTEM_WINDOWS
+namespace sf
+{
+namespace priv
+{
+ class ThreadImpl;
+ struct ThreadFunc;
+}
- #include <SFML/System/Win32/Thread.hpp>
+////////////////////////////////////////////////////////////
+/// \brief Utility class to manipulate threads
+///
+////////////////////////////////////////////////////////////
+class SFML_SYSTEM_API Thread : NonCopyable
+{
+public :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Construct the thread from a functor with no argument
+ ///
+ /// This constructor works for function objects, as well
+ /// as free function.
+ ///
+ /// Use this constructor for this kind of function:
+ /// \code
+ /// void function();
+ ///
+ /// // --- or ----
+ ///
+ /// struct Functor
+ /// {
+ /// void operator()();
+ /// };
+ /// \endcode
+ /// Note: this does *not* run the thread, use Launch().
+ ///
+ /// \param function Functor or free function to use as the entry point of the thread
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename F>
+ Thread(F function);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Construct the thread from a functor with an argument
+ ///
+ /// This constructor works for function objects, as well
+ /// as free function.
+ /// It is a template, which means that the argument can
+ /// have any type (int, std::string, void*, Toto, ...).
+ ///
+ /// Use this constructor for this kind of function:
+ /// \code
+ /// void function(int arg);
+ ///
+ /// // --- or ----
+ ///
+ /// struct Functor
+ /// {
+ /// void operator()(std::string arg);
+ /// };
+ /// \endcode
+ /// Note: this does *not* run the thread, use Launch().
+ ///
+ /// \param function Functor or free function to use as the entry point of the thread
+ /// \param argument argument to forward to the function
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename F, typename A>
+ Thread(F function, A argument);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Construct the thread from a member function and an object
+ ///
+ /// This constructor is template, which means that you can
+ /// use it with any class.
+ /// Use this constructor for this kind of function:
+ /// \code
+ /// class MyClass
+ /// {
+ /// public :
+ ///
+ /// void function();
+ /// };
+ /// \endcode
+ /// Note: this does *not* run the thread, use Launch().
+ ///
+ /// \param function Entry point of the thread
+ /// \param object Pointer to the object to use
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename C>
+ Thread(void(C::*function)(), C* object);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Destructor
+ ///
+ /// This destructor calls Wait(), so that the internal thread
+ /// cannot survive after its sf::Thread instance is destroyed.
+ ///
+ ////////////////////////////////////////////////////////////
+ ~Thread();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Run the thread
+ ///
+ /// This function starts the entry point passed to the
+ /// thread's constructor, and returns immediately.
+ /// After this function returns, the thread's function is
+ /// running in parallel to the calling code.
+ ///
+ ////////////////////////////////////////////////////////////
+ void launch();
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Wait until the thread finishes
+ ///
+ /// This function will block the execution until the
+ /// thread's function ends.
+ /// Warning: if the thread function never ends, the calling
+ /// thread will block forever.
+ /// If this function is called from its owner thread, it
+ /// returns without doing anything.
+ ///
+ ////////////////////////////////////////////////////////////
+ void wait();
-#else
+ ////////////////////////////////////////////////////////////
+ /// \brief Terminate the thread
+ ///
+ /// This function immediately stops the thread, without waiting
+ /// for its function to finish.
+ /// Terminating a thread with this function is not safe,
+ /// and can lead to local variables not being destroyed
+ /// on some operating systems. You should rather try to make
+ /// the thread function terminate by itself.
+ ///
+ ////////////////////////////////////////////////////////////
+ void terminate();
- #include <SFML/System/Unix/Thread.hpp>
+private :
-#endif
+ friend class priv::ThreadImpl;
+ ////////////////////////////////////////////////////////////
+ /// \brief Internal entry point of the thread
+ ///
+ /// This function is called by the thread implementation.
+ ///
+ ////////////////////////////////////////////////////////////
+ void run();
+
+ ////////////////////////////////////////////////////////////
+ // Member data
+ ////////////////////////////////////////////////////////////
+ priv::ThreadImpl* m_impl; ///< OS-specific implementation of the thread
+ priv::ThreadFunc* m_entryPoint; ///< Abstraction of the function to run
+};
+
+#include <SFML/System/Thread.inl>
+
+} // namespace sf
#endif // SFML_THREAD_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Thread
+/// \ingroup system
+///
+/// Threads provide a way to run multiple parts of the code
+/// in parallel. When you launch a new thread, the execution
+/// is split and both the new thread and the caller run
+/// in parallel.
+///
+/// To use a sf::Thread, you construct it directly with the
+/// function to execute as the entry point of the thread.
+/// sf::Thread has multiple template constructors, which means
+/// that you can use several types of entry points:
+/// \li non-member functions with no argument
+/// \li non-member functions with one argument of any type
+/// \li functors with no argument (this one is particularly useful for compatibility with boost/std::bind)
+/// \li functors with one argument of any type
+/// \li member functions from any class with no argument
+///
+/// The function argument, if any, is copied in the sf::Thread
+/// instance, as well as the functor (if the corresponding
+/// constructor is used). Class instances, however, are passed
+/// by pointer so you must make sure that the object won't be
+/// destroyed while the thread is still using it.
+///
+/// The thread ends when its function is terminated. If the
+/// owner sf::Thread instance is destroyed before the
+/// thread is finished, the destructor will wait (see wait())
+///
+/// Usage examples:
+/// \code
+/// // example 1: non member function with one argument
+///
+/// void threadFunc(int argument)
+/// {
+/// ...
+/// }
+///
+/// sf::Thread thread(&threadFunc, 5);
+/// thread.launch(); // start the thread (internally calls threadFunc(5))
+/// \endcode
+///
+/// \code
+/// // example 2: member function
+///
+/// class Task
+/// {
+/// public :
+/// void run()
+/// {
+/// ...
+/// }
+/// };
+///
+/// Task task;
+/// sf::Thread thread(&Task::run, &task);
+/// thread.launch(); // start the thread (internally calls task.run())
+/// \endcode
+///
+/// \code
+/// // example 3: functor
+///
+/// struct Task
+/// {
+/// void operator()()
+/// {
+/// ...
+/// }
+/// };
+///
+/// sf::Thread thread(Task());
+/// thread.launch(); // start the thread (internally calls operator() on the Task instance)
+/// \endcode
+///
+/// Creating parallel threads of execution can be dangerous:
+/// all threads inside the same process share the same memory space,
+/// which means that you may end up accessing the same variable
+/// from multiple threads at the same time. To prevent this
+/// kind of situations, you can use mutexes (see sf::Mutex).
+///
+/// \see sf::Mutex
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/System/Thread.inl b/include/SFML/System/Thread.inl new file mode 100644 index 0000000..126228a --- /dev/null +++ b/include/SFML/System/Thread.inl @@ -0,0 +1,90 @@ +////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2012 Laurent Gomila (laurent.gom@gmail.com)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+// you must not claim that you wrote the original software.
+// If you use this software in a product, an acknowledgment
+// in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+// and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+namespace priv
+{
+// Base class for abstract thread functions
+struct ThreadFunc
+{
+ virtual ~ThreadFunc() {}
+ virtual void run() = 0;
+};
+
+// Specialization using a functor (including free functions) with no argument
+template <typename T>
+struct ThreadFunctor : ThreadFunc
+{
+ ThreadFunctor(T functor) : m_functor(functor) {}
+ virtual void run() {m_functor();}
+ T m_functor;
+};
+
+// Specialization using a functor (including free functions) with one argument
+template <typename F, typename A>
+struct ThreadFunctorWithArg : ThreadFunc
+{
+ ThreadFunctorWithArg(F function, A arg) : m_function(function), m_arg(arg) {}
+ virtual void run() {m_function(m_arg);}
+ F m_function;
+ A m_arg;
+};
+
+// Specialization using a member function
+template <typename C>
+struct ThreadMemberFunc : ThreadFunc
+{
+ ThreadMemberFunc(void(C::*function)(), C* object) : m_function(function), m_object(object) {}
+ virtual void run() {(m_object->*m_function)();}
+ void(C::*m_function)();
+ C* m_object;
+};
+
+} // namespace priv
+
+
+////////////////////////////////////////////////////////////
+template <typename F>
+Thread::Thread(F functor) :
+m_impl (NULL),
+m_entryPoint(new priv::ThreadFunctor<F>(functor))
+{
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename F, typename A>
+Thread::Thread(F function, A argument) :
+m_impl (NULL),
+m_entryPoint(new priv::ThreadFunctorWithArg<F, A>(function, argument))
+{
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename C>
+Thread::Thread(void(C::*function)(), C* object) :
+m_impl (NULL),
+m_entryPoint(new priv::ThreadMemberFunc<C>(function, object))
+{
+}
diff --git a/include/SFML/System/Win32/Mutex.hpp b/include/SFML/System/ThreadLocal.hpp index 3cf5f9d..fe2ba82 100755..100644 --- a/include/SFML/System/Win32/Mutex.hpp +++ b/include/SFML/System/ThreadLocal.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,63 +22,82 @@ //
////////////////////////////////////////////////////////////
-#ifndef SFML_MUTEXWIN32_HPP
-#define SFML_MUTEXWIN32_HPP
+#ifndef SFML_THREADLOCAL_HPP
+#define SFML_THREADLOCAL_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
+#include <SFML/System/Export.hpp>
#include <SFML/System/NonCopyable.hpp>
-#include <windows.h>
+#include <cstdlib>
namespace sf
{
+namespace priv
+{
+ class ThreadLocalImpl;
+}
+
////////////////////////////////////////////////////////////
-/// Mutex defines a mutex (MUTual EXclusion) object,
-/// that allows a thread to lock critical instructions
-/// to avoid simultaneous access with other threads.
-/// The Win32 version uses critical sections, as it is
-/// faster than mutexes.<br/>
-/// See Lock for an efficient way of using it.
+/// \brief Defines variables with thread-local storage
+///
////////////////////////////////////////////////////////////
-class SFML_API Mutex : NonCopyable
+class SFML_SYSTEM_API ThreadLocal : NonCopyable
{
public :
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
+ ///
+ /// \param value Optional value to initalize the variable
///
////////////////////////////////////////////////////////////
- Mutex();
+ ThreadLocal(void* value = NULL);
////////////////////////////////////////////////////////////
- /// Destructor
+ /// \brief Destructor
///
////////////////////////////////////////////////////////////
- ~Mutex();
+ ~ThreadLocal();
////////////////////////////////////////////////////////////
- /// Lock the mutex
+ /// \brief Set the thread-specific value of the variable
+ ///
+ /// \param value Value of the variable for the current thread
///
////////////////////////////////////////////////////////////
- void Lock();
+ void setValue(void* value);
////////////////////////////////////////////////////////////
- /// Unlock the mutex
+ /// \brief Retrieve the thread-specific value of the variable
+ ///
+ /// \return Value of the variable for the current thread
///
////////////////////////////////////////////////////////////
- void Unlock();
+ void* getValue() const;
private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- CRITICAL_SECTION myHandle; ///< Win32 handle of the mutex
+ priv::ThreadLocalImpl* m_impl; ///< Pointer to the OS specific implementation
};
} // namespace sf
-#endif // SFML_MUTEXWIN32_HPP
+#endif // SFML_THREADLOCAL_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::ThreadLocal
+/// \ingroup system
+///
+/// This class manipulates void* parameters and thus is not
+/// appropriate for strongly-typed variables. You should rather
+/// use the sf::ThreadLocalPtr template class.
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/System/ThreadLocalPtr.hpp b/include/SFML/System/ThreadLocalPtr.hpp new file mode 100644 index 0000000..e6dc1eb --- /dev/null +++ b/include/SFML/System/ThreadLocalPtr.hpp @@ -0,0 +1,158 @@ +////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+// you must not claim that you wrote the original software.
+// If you use this software in a product, an acknowledgment
+// in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+// and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_THREADLOCALPTR_HPP
+#define SFML_THREADLOCALPTR_HPP
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/System/ThreadLocal.hpp>
+
+
+namespace sf
+{
+////////////////////////////////////////////////////////////
+/// \brief Pointer to a thread-local variable
+///
+////////////////////////////////////////////////////////////
+template <typename T>
+class ThreadLocalPtr : private ThreadLocal
+{
+public :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Default constructor
+ ///
+ /// \param value Optional value to initalize the variable
+ ///
+ ////////////////////////////////////////////////////////////
+ ThreadLocalPtr(T* value = NULL);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Overload of unary operator *
+ ///
+ /// Like raw pointers, applying the * operator returns a
+ /// reference to the pointed object.
+ ///
+ /// \return Reference to the pointed object
+ ///
+ ////////////////////////////////////////////////////////////
+ T& operator *() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Overload of operator ->
+ ///
+ /// Like raw pointers, applying the -> operator returns the
+ /// pointed object.
+ ///
+ /// \return Pointed object
+ ///
+ ////////////////////////////////////////////////////////////
+ T* operator ->() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Cast operator to implicitely convert the
+ /// pointer to its raw pointer type (T*)
+ ///
+ /// \return Pointer to the actual object
+ ///
+ ////////////////////////////////////////////////////////////
+ operator T*() const;
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Assignment operator for a raw pointer parameter
+ ///
+ /// \param value Pointer to assign
+ ///
+ /// \return Reference to self
+ ///
+ ////////////////////////////////////////////////////////////
+ ThreadLocalPtr<T>& operator =(T* value);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Assignment operator for a ThreadLocalPtr parameter
+ ///
+ /// \param right ThreadLocalPtr to assign
+ ///
+ /// \return Reference to self
+ ///
+ ////////////////////////////////////////////////////////////
+ ThreadLocalPtr<T>& operator =(const ThreadLocalPtr<T>& right);
+};
+
+} // namespace sf
+
+#include <SFML/System/ThreadLocalPtr.inl>
+
+
+#endif // SFML_THREADLOCALPTR_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::ThreadLocalPtr
+/// \ingroup system
+///
+/// sf::ThreadLocalPtr is a type-safe wrapper for storing
+/// pointers to thread-local variables. A thread-local
+/// variable holds a different value for each different
+/// thread, unlike normal variable that are shared.
+///
+/// Its usage is completely transparent, so that it is similar
+/// to manipulating the raw pointer directly (like any smart pointer).
+///
+/// Usage example:
+/// \code
+/// MyClass object1;
+/// MyClass object2;
+/// sf::ThreadLocalPtr<MyClass> objectPtr;
+///
+/// void thread1()
+/// {
+/// objectPtr = &object1; // doesn't impact thread2
+/// ...
+/// }
+///
+/// void thread2()
+/// {
+/// objectPtr = &object2; // doesn't impact thread1
+/// ...
+/// }
+///
+/// int main()
+/// {
+/// // Create and launch the two threads
+/// sf::Thread t1(&thread1);
+/// sf::Thread t2(&thread2);
+/// t1.launch();
+/// t2.launch();
+///
+/// return 0;
+/// }
+/// \endcode
+///
+/// ThreadLocalPtr is designed for internal use; however you
+/// can use it if you feel like it fits well your implementation.
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/System/Resource.inl b/include/SFML/System/ThreadLocalPtr.inl index c4276a1..8442025 100755..100644 --- a/include/SFML/System/Resource.inl +++ b/include/SFML/System/ThreadLocalPtr.inl @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2012 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -23,66 +23,55 @@ ////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////
-/// Default constructor
+namespace sf
+{
////////////////////////////////////////////////////////////
template <typename T>
-Resource<T>::Resource()
+ThreadLocalPtr<T>::ThreadLocalPtr(T* value) :
+ThreadLocal(value)
{
- // Nothing to do
}
////////////////////////////////////////////////////////////
-/// Copy constructor
-////////////////////////////////////////////////////////////
template <typename T>
-Resource<T>::Resource(const Resource<T>&)
+T& ThreadLocalPtr<T>::operator *() const
{
- // Nothing to do, we don't want to copy observers
+ return *static_cast<T*>(getValue());
}
////////////////////////////////////////////////////////////
-/// Destructor
-////////////////////////////////////////////////////////////
template <typename T>
-Resource<T>::~Resource()
+T* ThreadLocalPtr<T>::operator ->() const
{
- // Notify all observers
- for (typename std::set<ResourcePtr<T>*>::iterator i = myObservers.begin(); i != myObservers.end(); ++i)
- {
- (*i)->OnResourceDestroyed();
- }
+ return static_cast<T*>(getValue());
}
////////////////////////////////////////////////////////////
-/// Assignment operator
-////////////////////////////////////////////////////////////
template <typename T>
-Resource<T>& Resource<T>::operator =(const Resource<T>&)
+ThreadLocalPtr<T>::operator T*() const
{
- // Nothing to do, we don't want to copy observers
- return *this;
+ return static_cast<T*>(getValue());
}
////////////////////////////////////////////////////////////
-/// Connect a ResourcePtr to this resource
-////////////////////////////////////////////////////////////
template <typename T>
-void Resource<T>::Connect(ResourcePtr<T>& Observer) const
+ThreadLocalPtr<T>& ThreadLocalPtr<T>::operator =(T* value)
{
- myObservers.insert(&Observer);
+ setValue(value);
+ return *this;
}
////////////////////////////////////////////////////////////
-/// Disconnect a ResourcePtr from this resource
-////////////////////////////////////////////////////////////
template <typename T>
-void Resource<T>::Disconnect(ResourcePtr<T>& Observer) const
+ThreadLocalPtr<T>& ThreadLocalPtr<T>::operator =(const ThreadLocalPtr<T>& right)
{
- myObservers.erase(&Observer);
+ setValue(right.getValue());
+ return *this;
}
+
+} // namespace sf
diff --git a/include/SFML/System/Time.hpp b/include/SFML/System/Time.hpp new file mode 100644 index 0000000..5037f52 --- /dev/null +++ b/include/SFML/System/Time.hpp @@ -0,0 +1,452 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_TIME_HPP +#define SFML_TIME_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/System/Export.hpp> + + +namespace sf +{ +//////////////////////////////////////////////////////////// +/// \brief Represents a time value +/// +//////////////////////////////////////////////////////////// +class SFML_SYSTEM_API Time +{ +public : + + //////////////////////////////////////////////////////////// + /// \brief Default constructor + /// + /// Sets the time value to zero. + /// + //////////////////////////////////////////////////////////// + Time(); + + //////////////////////////////////////////////////////////// + /// \brief Return the time value as a number of seconds + /// + /// \return Time in seconds + /// + /// \see asMilliseconds, asMicroseconds + /// + //////////////////////////////////////////////////////////// + float asSeconds() const; + + //////////////////////////////////////////////////////////// + /// \brief Return the time value as a number of milliseconds + /// + /// \return Time in milliseconds + /// + /// \see asSeconds, asMicroseconds + /// + //////////////////////////////////////////////////////////// + Int32 asMilliseconds() const; + + //////////////////////////////////////////////////////////// + /// \brief Return the time value as a number of microseconds + /// + /// \return Time in microseconds + /// + /// \see asSeconds, asMilliseconds + /// + //////////////////////////////////////////////////////////// + Int64 asMicroseconds() const; + + //////////////////////////////////////////////////////////// + // Static member data + //////////////////////////////////////////////////////////// + static const Time Zero; ///< Predefined "zero" time value + +private : + + friend SFML_SYSTEM_API Time seconds(float); + friend SFML_SYSTEM_API Time milliseconds(Int32); + friend SFML_SYSTEM_API Time microseconds(Int64); + + //////////////////////////////////////////////////////////// + /// \brief Construct from a number of microseconds + /// + /// This function is internal. To construct time values, + /// use sf::seconds, sf::milliseconds or sf::microseconds instead. + /// + /// \param microseconds Number of microseconds + /// + //////////////////////////////////////////////////////////// + explicit Time(Int64 microseconds); + +private : + + //////////////////////////////////////////////////////////// + // Member data + //////////////////////////////////////////////////////////// + Int64 m_microseconds; ///< Time value stored as microseconds +}; + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Construct a time value from a number of seconds +/// +/// \param amount Number of seconds +/// +/// \return Time value constructed from the amount of seconds +/// +/// \see milliseconds, microseconds +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API Time seconds(float amount); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Construct a time value from a number of milliseconds +/// +/// \param amount Number of milliseconds +/// +/// \return Time value constructed from the amount of milliseconds +/// +/// \see seconds, microseconds +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API Time milliseconds(Int32 amount); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Construct a time value from a number of microseconds +/// +/// \param amount Number of microseconds +/// +/// \return Time value constructed from the amount of microseconds +/// +/// \see seconds, milliseconds +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API Time microseconds(Int64 amount); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of == operator to compare two time values +/// +/// \param left Left operand (a time) +/// \param right Right operand (a time) +/// +/// \return True if both time values are equal +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API bool operator ==(Time left, Time right); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of != operator to compare two time values +/// +/// \param left Left operand (a time) +/// \param right Right operand (a time) +/// +/// \return True if both time values are different +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API bool operator !=(Time left, Time right); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of < operator to compare two time values +/// +/// \param left Left operand (a time) +/// \param right Right operand (a time) +/// +/// \return True if \a left is lesser than \a right +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API bool operator <(Time left, Time right); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of > operator to compare two time values +/// +/// \param left Left operand (a time) +/// \param right Right operand (a time) +/// +/// \return True if \a left is greater than \a right +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API bool operator >(Time left, Time right); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of <= operator to compare two time values +/// +/// \param left Left operand (a time) +/// \param right Right operand (a time) +/// +/// \return True if \a left is lesser or equal than \a right +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API bool operator <=(Time left, Time right); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of >= operator to compare two time values +/// +/// \param left Left operand (a time) +/// \param right Right operand (a time) +/// +/// \return True if \a left is greater or equal than \a right +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API bool operator >=(Time left, Time right); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of unary - operator to negate a time value +/// +/// \param right Right operand (a time) +/// +/// \return Opposite of the time value +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API Time operator -(Time right); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of binary + operator to add two time values +/// +/// \param left Left operand (a time) +/// \param right Right operand (a time) +/// +/// \return Sum of the two times values +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API Time operator +(Time left, Time right); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of binary += operator to add/assign two time values +/// +/// \param left Left operand (a time) +/// \param right Right operand (a time) +/// +/// \return Sum of the two times values +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API Time& operator +=(Time& left, Time right); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of binary - operator to subtract two time values +/// +/// \param left Left operand (a time) +/// \param right Right operand (a time) +/// +/// \return Difference of the two times values +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API Time operator -(Time left, Time right); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of binary -= operator to subtract/assign two time values +/// +/// \param left Left operand (a time) +/// \param right Right operand (a time) +/// +/// \return Difference of the two times values +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API Time& operator -=(Time& left, Time right); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of binary * operator to scale a time value +/// +/// \param left Left operand (a time) +/// \param right Right operand (a number) +/// +/// \return \a left multiplied by \a right +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API Time operator *(Time left, float right); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of binary * operator to scale a time value +/// +/// \param left Left operand (a time) +/// \param right Right operand (a number) +/// +/// \return \a left multiplied by \a right +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API Time operator *(Time left, Int64 right); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of binary * operator to scale a time value +/// +/// \param left Left operand (a number) +/// \param right Right operand (a time) +/// +/// \return \a left multiplied by \a right +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API Time operator *(float left, Time right); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of binary * operator to scale a time value +/// +/// \param left Left operand (a number) +/// \param right Right operand (a time) +/// +/// \return \a left multiplied by \a right +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API Time operator *(Int64 left, Time right); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of binary *= operator to scale/assign a time value +/// +/// \param left Left operand (a time) +/// \param right Right operand (a number) +/// +/// \return \a left multiplied by \a right +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API Time& operator *=(Time& left, float right); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of binary *= operator to scale/assign a time value +/// +/// \param left Left operand (a time) +/// \param right Right operand (a number) +/// +/// \return \a left multiplied by \a right +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API Time& operator *=(Time& left, Int64 right); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of binary / operator to scale a time value +/// +/// \param left Left operand (a time) +/// \param right Right operand (a number) +/// +/// \return \a left divided by \a right +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API Time operator /(Time left, float right); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of binary / operator to scale a time value +/// +/// \param left Left operand (a time) +/// \param right Right operand (a number) +/// +/// \return \a left divided by \a right +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API Time operator /(Time left, Int64 right); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of binary /= operator to scale/assign a time value +/// +/// \param left Left operand (a time) +/// \param right Right operand (a number) +/// +/// \return \a left divided by \a right +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API Time& operator /=(Time& left, float right); + +//////////////////////////////////////////////////////////// +/// \relates Time +/// \brief Overload of binary /= operator to scale/assign a time value +/// +/// \param left Left operand (a time) +/// \param right Right operand (a number) +/// +/// \return \a left divided by \a right +/// +//////////////////////////////////////////////////////////// +SFML_SYSTEM_API Time& operator /=(Time& left, Int64 right); + +} // namespace sf + + +#endif // SFML_TIME_HPP + + +//////////////////////////////////////////////////////////// +/// \class sf::Time +/// \ingroup system +/// +/// sf::Time encapsulates a time value in a flexible way. +/// It allows to define a time value either as a number of +/// seconds, milliseconds or microseconds. It also works the +/// other way round: you can read a time value as either +/// a number of seconds, milliseconds or microseconds. +/// +/// By using such a flexible interface, the API doesn't +/// impose any fixed type or resolution for time values, +/// and let the user choose its own favorite representation. +/// +/// Time values support the usual mathematical operations: +/// you can add or subtract two times, multiply or divide +/// a time by a number, compare two times, etc. +/// +/// Since they represent a time span and not an absolute time +/// value, times can also be negative. +/// +/// Usage example: +/// \code +/// sf::Time t1 = sf::seconds(0.1f); +/// Int32 milli = t1.asMilliseconds(); // 100 +/// +/// sf::Time t2 = sf::milliseconds(30); +/// Int64 micro = t2.asMicroseconds(); // 30000 +/// +/// sf::Time t3 = sf::microseconds(-800000); +/// float sec = t3.asSeconds(); // -0.8 +/// \endcode +/// +/// \code +/// void update(sf::Time elapsed) +/// { +/// position += speed * elapsed.asSeconds(); +/// } +/// +/// update(sf::milliseconds(100)); +/// \endcode +/// +/// \see sf::Clock +/// +//////////////////////////////////////////////////////////// diff --git a/include/SFML/System/Unicode.hpp b/include/SFML/System/Unicode.hpp deleted file mode 100755 index f807fb3..0000000 --- a/include/SFML/System/Unicode.hpp +++ /dev/null @@ -1,290 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_UNICODE_HPP
-#define SFML_UNICODE_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
-#include <iterator>
-#include <locale>
-#include <string>
-#include <stdlib.h>
-
-
-namespace sf
-{
-////////////////////////////////////////////////////////////
-/// Provides utility functions to convert from and to
-/// any unicode and ASCII encoding
-////////////////////////////////////////////////////////////
-class SFML_API Unicode
-{
-public :
-
- ////////////////////////////////////////////////////////////
- /// Define a string type for each encoding
- /// Warning : in UTF8 and UTF16 strings, one element doesn't
- /// necessarily maps to one character ; only an UTF32 element
- /// is wide enough to hold all possible unicode values
- ////////////////////////////////////////////////////////////
- typedef std::basic_string<Uint8> UTF8String;
- typedef std::basic_string<Uint16> UTF16String;
- typedef std::basic_string<Uint32> UTF32String;
-
- ////////////////////////////////////////////////////////////
- /// This class is an abstract definition of a unicode text,
- /// it can be converted from and to any kind of string
- /// and encoding
- ////////////////////////////////////////////////////////////
- class SFML_API Text
- {
- public :
-
- ////////////////////////////////////////////////////////////
- /// Default constructor (empty text)
- ///
- ////////////////////////////////////////////////////////////
- Text();
-
- ////////////////////////////////////////////////////////////
- /// Construct the unicode text from any type of string
- ///
- /// \param Str : String to convert
- ///
- ////////////////////////////////////////////////////////////
- Text(const char* Str);
- Text(const wchar_t* Str);
- Text(const Uint8* Str);
- Text(const Uint16* Str);
- Text(const Uint32* Str);
- Text(const std::string& Str);
- Text(const std::wstring& Str);
- Text(const Unicode::UTF8String& Str);
- Text(const Unicode::UTF16String& Str);
- Text(const Unicode::UTF32String& Str);
-
- ////////////////////////////////////////////////////////////
- /// Operator to cast the text to any type of string
- ///
- /// \return Converted string
- ///
- ////////////////////////////////////////////////////////////
- operator std::string () const;
- operator std::wstring () const;
- operator Unicode::UTF8String () const;
- operator Unicode::UTF16String () const;
- operator const Unicode::UTF32String&() const;
-
- private :
-
- ////////////////////////////////////////////////////////////
- // Data member
- ////////////////////////////////////////////////////////////
- sf::Unicode::UTF32String myUTF32String; ///< UTF-32 unicode text
- };
-
- ////////////////////////////////////////////////////////////
- /// Generic function to convert an UTF-32 characters range
- /// to an ANSI characters range, using the given locale
- ///
- /// \param Begin : Iterator pointing to the beginning of the input sequence
- /// \param End : Iterator pointing to the end of the input sequence
- /// \param Output : Iterator pointing to the beginning of the output sequence
- /// \param Replacement : Replacement character for characters not convertible to output encoding ('?' by default -- use 0 to use no replacement character)
- /// \param Locale : Locale to use for conversion (uses the current one by default)
- ///
- /// \return Iterator to the end of the output sequence which has been written
- ///
- ////////////////////////////////////////////////////////////
- template <typename In, typename Out>
- static Out UTF32ToANSI(In Begin, In End, Out Output, char Replacement = '?', const std::locale& Locale = GetDefaultLocale());
-
- ////////////////////////////////////////////////////////////
- /// Generic function to convert an ANSI characters range
- /// to an UTF-32 characters range, using the given locale
- ///
- /// \param Begin : Iterator pointing to the beginning of the input sequence
- /// \param End : Iterator pointing to the end of the input sequence
- /// \param Output : Iterator pointing to the beginning of the output sequence
- /// \param Locale : Locale to use for conversion (uses the current one by default)
- ///
- /// \return Iterator to the end of the output sequence which has been written
- ///
- ////////////////////////////////////////////////////////////
- template <typename In, typename Out>
- static Out ANSIToUTF32(In Begin, In End, Out Output, const std::locale& Locale = GetDefaultLocale());
-
- ////////////////////////////////////////////////////////////
- /// Generic function to convert an UTF-8 characters range
- /// to an UTF-16 characters range, using the given locale
- ///
- /// \param Begin : Iterator pointing to the beginning of the input sequence
- /// \param End : Iterator pointing to the end of the input sequence
- /// \param Output : Iterator pointing to the beginning of the output sequence
- /// \param Replacement : Replacement character for characters not convertible to output encoding ('?' by default -- use 0 to use no replacement character)
- ///
- /// \return Iterator to the end of the output sequence which has been written
- ///
- ////////////////////////////////////////////////////////////
- template <typename In, typename Out>
- static Out UTF8ToUTF16(In Begin, In End, Out Output, Uint16 Replacement = '?');
-
- ////////////////////////////////////////////////////////////
- /// Generic function to convert an UTF-8 characters range
- /// to an UTF-32 characters range, using the given locale
- ///
- /// \param Begin : Iterator pointing to the beginning of the input sequence
- /// \param End : Iterator pointing to the end of the input sequence
- /// \param Output : Iterator pointing to the beginning of the output sequence
- /// \param Replacement : Replacement character for characters not convertible to output encoding ('?' by default -- use 0 to use no replacement character)
- ///
- /// \return Iterator to the end of the output sequence which has been written
- ///
- ////////////////////////////////////////////////////////////
- template <typename In, typename Out>
- static Out UTF8ToUTF32(In Begin, In End, Out Output, Uint32 Replacement = '?');
-
- ////////////////////////////////////////////////////////////
- /// Generic function to convert an UTF-16 characters range
- /// to an UTF-8 characters range, using the given locale
- ///
- /// \param Begin : Iterator pointing to the beginning of the input sequence
- /// \param End : Iterator pointing to the end of the input sequence
- /// \param Output : Iterator pointing to the beginning of the output sequence
- /// \param Replacement : Replacement character for characters not convertible to output encoding ('?' by default -- use 0 to use no replacement character)
- ///
- /// \return Iterator to the end of the output sequence which has been written
- ///
- ////////////////////////////////////////////////////////////
- template <typename In, typename Out>
- static Out UTF16ToUTF8(In Begin, In End, Out Output, Uint8 Replacement = '?');
-
- ////////////////////////////////////////////////////////////
- /// Generic function to convert an UTF-16 characters range
- /// to an UTF-32 characters range, using the given locale
- ///
- /// \param Begin : Iterator pointing to the beginning of the input sequence
- /// \param End : Iterator pointing to the end of the input sequence
- /// \param Output : Iterator pointing to the beginning of the output sequence
- /// \param Replacement : Replacement character for characters not convertible to output encoding ('?' by default -- use 0 to use no replacement character)
- ///
- /// \return Iterator to the end of the output sequence which has been written
- ///
- ////////////////////////////////////////////////////////////
- template <typename In, typename Out>
- static Out UTF16ToUTF32(In Begin, In End, Out Output, Uint32 Replacement = '?');
-
- ////////////////////////////////////////////////////////////
- /// Generic function to convert an UTF-32 characters range
- /// to an UTF-8 characters range, using the given locale
- ///
- /// \param Begin : Iterator pointing to the beginning of the input sequence
- /// \param End : Iterator pointing to the end of the input sequence
- /// \param Output : Iterator pointing to the beginning of the output sequence
- /// \param Replacement : Replacement character for characters not convertible to output encoding ('?' by default -- use 0 to use no replacement character)
- ///
- /// \return Iterator to the end of the output sequence which has been written
- ///
- ////////////////////////////////////////////////////////////
- template <typename In, typename Out>
- static Out UTF32ToUTF8(In Begin, In End, Out Output, Uint8 Replacement = '?');
-
- ////////////////////////////////////////////////////////////
- /// Generic function to convert an UTF-32 characters range
- /// to an UTF-16 characters range, using the given locale
- ///
- /// \param Begin : Iterator pointing to the beginning of the input sequence
- /// \param End : Iterator pointing to the end of the input sequence
- /// \param Output : Iterator pointing to the beginning of the output sequence
- /// \param Replacement : Replacement character for characters not convertible to output encoding ('?' by default -- use 0 to use no replacement character)
- ///
- /// \return Iterator to the end of the output sequence which has been written
- ///
- ////////////////////////////////////////////////////////////
- template <typename In, typename Out>
- static Out UTF32ToUTF16(In Begin, In End, Out Output, Uint16 Replacement = '?');
-
- ////////////////////////////////////////////////////////////
- /// Get the number of characters composing an UTF-8 string
- ///
- /// \param Begin : Iterator pointing to the beginning of the input sequence
- /// \param End : Iterator pointing to the end of the input sequence
- ///
- /// \return Count of the characters in the string
- ///
- ////////////////////////////////////////////////////////////
- template <typename In>
- static std::size_t GetUTF8Length(In Begin, In End);
-
- ////////////////////////////////////////////////////////////
- /// Get the number of characters composing an UTF-16 string
- ///
- /// \param Begin : Iterator pointing to the beginning of the input sequence
- /// \param End : Iterator pointing to the end of the input sequence
- ///
- /// \return Count of the characters in the string
- ///
- ////////////////////////////////////////////////////////////
- template <typename In>
- static std::size_t GetUTF16Length(In Begin, In End);
-
- ////////////////////////////////////////////////////////////
- /// Get the number of characters composing an UTF-32 string
- ///
- /// \param Begin : Iterator pointing to the beginning of the input sequence
- /// \param End : Iterator pointing to the end of the input sequence
- ///
- /// \return Count of the characters in the string
- ///
- ////////////////////////////////////////////////////////////
- template <typename In>
- static std::size_t GetUTF32Length(In Begin, In End);
-
-private :
-
- ////////////////////////////////////////////////////////////
- /// Get the default system locale
- ///
- /// \return Reference to the default system locale
- ///
- ////////////////////////////////////////////////////////////
- static const std::locale& GetDefaultLocale();
-
- ////////////////////////////////////////////////////////////
- // Static member data
- ////////////////////////////////////////////////////////////
- static const int UTF8TrailingBytes[256]; ///< Lookup table to find the length of an UTF-8 sequence
- static const Uint32 UTF8Offsets[6]; ///< Magic values to subtract during UTF-8 conversions
- static const Uint8 UTF8FirstBytes[7]; ///< First bytes for UTF-8 sequences
-};
-
-#include <SFML/System/Unicode.inl>
-
-} // namespace sf
-
-
-#endif // SFML_UNICODE_HPP
diff --git a/include/SFML/System/Unicode.inl b/include/SFML/System/Unicode.inl deleted file mode 100755 index a169811..0000000 --- a/include/SFML/System/Unicode.inl +++ /dev/null @@ -1,474 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-
-////////////////////////////////////////////////////////////
-/// Generic function to convert an UTF-32 characters range
-/// to an ANSI characters range, using the given locale
-////////////////////////////////////////////////////////////
-template <typename In, typename Out>
-inline Out Unicode::UTF32ToANSI(In Begin, In End, Out Output, char Replacement, const std::locale& Locale)
-{
- #ifdef __MINGW32__
-
- // MinGW has a almost no support for unicode stuff
- // As a consequence, the MinGW version of this function can only use the default locale
- // and ignores the one passed as parameter
- while (Begin < End)
- {
- char Char = 0;
- if (wctomb(&Char, static_cast<wchar_t>(*Begin++)) >= 0)
- *Output++ = Char;
- else if (Replacement)
- *Output++ = Replacement;
- }
-
- #else
-
- // Get the facet of the locale which deals with character conversion
- const std::ctype<wchar_t>& Facet = std::use_facet< std::ctype<wchar_t> >(Locale);
-
- // Use the facet to convert each character of the input string
- while (Begin < End)
- *Output++ = Facet.narrow(static_cast<wchar_t>(*Begin++), Replacement);
-
- #endif
-
- return Output;
-}
-
-
-////////////////////////////////////////////////////////////
-/// Generic function to convert an ANSI characters range
-/// to an UTF-32 characters range, using the given locale
-////////////////////////////////////////////////////////////
-template <typename In, typename Out>
-inline Out Unicode::ANSIToUTF32(In Begin, In End, Out Output, const std::locale& Locale)
-{
- #ifdef __MINGW32__
-
- // MinGW has a almost no support for unicode stuff
- // As a consequence, the MinGW version of this function can only use the default locale
- // and ignores the one passed as parameter
- while (Begin < End)
- {
- wchar_t Char = 0;
- mbtowc(&Char, &*Begin, 1);
- Begin++;
- *Output++ = static_cast<Uint32>(Char);
- }
-
- #else
-
- // Get the facet of the locale which deals with character conversion
- const std::ctype<wchar_t>& Facet = std::use_facet< std::ctype<wchar_t> >(Locale);
-
- // Use the facet to convert each character of the input string
- while (Begin < End)
- *Output++ = static_cast<Uint32>(Facet.widen(*Begin++));
-
- #endif
-
- return Output;
-}
-
-
-////////////////////////////////////////////////////////////
-/// Generic function to convert an UTF-8 characters range
-/// to an UTF-16 characters range, using the given locale
-////////////////////////////////////////////////////////////
-template <typename In, typename Out>
-inline Out Unicode::UTF8ToUTF16(In Begin, In End, Out Output, Uint16 Replacement)
-{
- while (Begin < End)
- {
- Uint32 c = 0;
- int TrailingBytes = UTF8TrailingBytes[static_cast<int>(*Begin)];
- if (Begin + TrailingBytes < End)
- {
- // First decode the UTF-8 character
- switch (TrailingBytes)
- {
- case 5 : c += *Begin++; c <<= 6;
- case 4 : c += *Begin++; c <<= 6;
- case 3 : c += *Begin++; c <<= 6;
- case 2 : c += *Begin++; c <<= 6;
- case 1 : c += *Begin++; c <<= 6;
- case 0 : c += *Begin++;
- }
- c -= UTF8Offsets[TrailingBytes];
-
- // Then encode it in UTF-16
- if (c < 0xFFFF)
- {
- // Character can be converted directly to 16 bits, just need to check it's in the valid range
- if ((c >= 0xD800) && (c <= 0xDFFF))
- {
- // Invalid character (this range is reserved)
- if (Replacement)
- *Output++ = Replacement;
- }
- else
- {
- // Valid character directly convertible to 16 bits
- *Output++ = static_cast<Uint16>(c);
- }
- }
- else if (c > 0x0010FFFF)
- {
- // Invalid character (greater than the maximum unicode value)
- if (Replacement)
- *Output++ = Replacement;
- }
- else
- {
- // Character will be converted to 2 UTF-16 elements
- c -= 0x0010000;
- *Output++ = static_cast<Uint16>((c >> 10) + 0xD800);
- *Output++ = static_cast<Uint16>((c & 0x3FFUL) + 0xDC00);
- }
- }
- }
-
- return Output;
-}
-
-
-////////////////////////////////////////////////////////////
-/// Generic function to convert an UTF-8 characters range
-/// to an UTF-32 characters range, using the given locale
-////////////////////////////////////////////////////////////
-template <typename In, typename Out>
-inline Out Unicode::UTF8ToUTF32(In Begin, In End, Out Output, Uint32 Replacement)
-{
- while (Begin < End)
- {
- Uint32 c = 0;
- int TrailingBytes = UTF8TrailingBytes[static_cast<int>(*Begin)];
- if (Begin + TrailingBytes < End)
- {
- // First decode the UTF-8 character
- switch (TrailingBytes)
- {
- case 5 : c += *Begin++; c <<= 6;
- case 4 : c += *Begin++; c <<= 6;
- case 3 : c += *Begin++; c <<= 6;
- case 2 : c += *Begin++; c <<= 6;
- case 1 : c += *Begin++; c <<= 6;
- case 0 : c += *Begin++;
- }
- c -= UTF8Offsets[TrailingBytes];
-
- // Then write it if valid
- if ((c < 0xD800) || (c > 0xDFFF))
- {
- // Valid UTF-32 character
- *Output++ = c;
- }
- else
- {
- // Invalid UTF-32 character
- if (Replacement)
- *Output++ = Replacement;
- }
- }
- }
-
- return Output;
-}
-
-
-////////////////////////////////////////////////////////////
-/// Generic function to convert an UTF-16 characters range
-/// to an UTF-8 characters range, using the given locale
-////////////////////////////////////////////////////////////
-template <typename In, typename Out>
-inline Out Unicode::UTF16ToUTF8(In Begin, In End, Out Output, Uint8 Replacement)
-{
- while (Begin < End)
- {
- Uint32 c = *Begin++;
-
- // If it's a surrogate pair, first convert to a single UTF-32 character
- if ((c >= 0xD800) && (c <= 0xDBFF))
- {
- if (Begin < End)
- {
- // The second element is valid : convert the two elements to a UTF-32 character
- Uint32 d = *Begin++;
- if ((d >= 0xDC00) && (d <= 0xDFFF))
- c = static_cast<Uint32>(((c - 0xD800) << 10) + (d - 0xDC00) + 0x0010000);
- }
- else
- {
- // Invalid second element
- if (Replacement)
- *Output++ = Replacement;
- }
- }
-
- // Then convert to UTF-8
- if (c > 0x0010FFFF)
- {
- // Invalid character (greater than the maximum unicode value)
- if (Replacement)
- *Output++ = Replacement;
- }
- else
- {
- // Valid character
-
- // Get number of bytes to write
- int BytesToWrite = 1;
- if (c < 0x80) BytesToWrite = 1;
- else if (c < 0x800) BytesToWrite = 2;
- else if (c < 0x10000) BytesToWrite = 3;
- else if (c <= 0x0010FFFF) BytesToWrite = 4;
-
- // Extract bytes to write
- Uint8 Bytes[4];
- switch (BytesToWrite)
- {
- case 4 : Bytes[3] = static_cast<Uint8>((c | 0x80) & 0xBF); c >>= 6;
- case 3 : Bytes[2] = static_cast<Uint8>((c | 0x80) & 0xBF); c >>= 6;
- case 2 : Bytes[1] = static_cast<Uint8>((c | 0x80) & 0xBF); c >>= 6;
- case 1 : Bytes[0] = static_cast<Uint8> (c | UTF8FirstBytes[BytesToWrite]);
- }
-
- // Add them to the output
- const Uint8* CurByte = Bytes;
- switch (BytesToWrite)
- {
- case 4 : *Output++ = *CurByte++;
- case 3 : *Output++ = *CurByte++;
- case 2 : *Output++ = *CurByte++;
- case 1 : *Output++ = *CurByte++;
- }
- }
- }
-
- return Output;
-}
-
-
-////////////////////////////////////////////////////////////
-/// Generic function to convert an UTF-16 characters range
-/// to an UTF-32 characters range, using the given locale
-////////////////////////////////////////////////////////////
-template <typename In, typename Out>
-inline Out Unicode::UTF16ToUTF32(In Begin, In End, Out Output, Uint32 Replacement)
-{
- while (Begin < End)
- {
- Uint16 c = *Begin++;
- if ((c >= 0xD800) && (c <= 0xDBFF))
- {
- // We have a surrogate pair, ie. a character composed of two elements
- if (Begin < End)
- {
- Uint16 d = *Begin++;
- if ((d >= 0xDC00) && (d <= 0xDFFF))
- {
- // The second element is valid : convert the two elements to a UTF-32 character
- *Output++ = static_cast<Uint32>(((c - 0xD800) << 10) + (d - 0xDC00) + 0x0010000);
- }
- else
- {
- // Invalid second element
- if (Replacement)
- *Output++ = Replacement;
- }
- }
- }
- else if ((c >= 0xDC00) && (c <= 0xDFFF))
- {
- // Invalid character
- if (Replacement)
- *Output++ = Replacement;
- }
- else
- {
- // Valid character directly convertible to UTF-32
- *Output++ = static_cast<Uint32>(c);
- }
- }
-
- return Output;
-}
-
-
-////////////////////////////////////////////////////////////
-/// Generic function to convert an UTF-32 characters range
-/// to an UTF-8 characters range, using the given locale
-////////////////////////////////////////////////////////////
-template <typename In, typename Out>
-inline Out Unicode::UTF32ToUTF8(In Begin, In End, Out Output, Uint8 Replacement)
-{
- while (Begin < End)
- {
- Uint32 c = *Begin++;
- if (c > 0x0010FFFF)
- {
- // Invalid character (greater than the maximum unicode value)
- if (Replacement)
- *Output++ = Replacement;
- }
- else
- {
- // Valid character
-
- // Get number of bytes to write
- int BytesToWrite = 1;
- if (c < 0x80) BytesToWrite = 1;
- else if (c < 0x800) BytesToWrite = 2;
- else if (c < 0x10000) BytesToWrite = 3;
- else if (c <= 0x0010FFFF) BytesToWrite = 4;
-
- // Extract bytes to write
- Uint8 Bytes[4];
- switch (BytesToWrite)
- {
- case 4 : Bytes[3] = static_cast<Uint8>((c | 0x80) & 0xBF); c >>= 6;
- case 3 : Bytes[2] = static_cast<Uint8>((c | 0x80) & 0xBF); c >>= 6;
- case 2 : Bytes[1] = static_cast<Uint8>((c | 0x80) & 0xBF); c >>= 6;
- case 1 : Bytes[0] = static_cast<Uint8> (c | UTF8FirstBytes[BytesToWrite]);
- }
-
- // Add them to the output
- const Uint8* CurByte = Bytes;
- switch (BytesToWrite)
- {
- case 4 : *Output++ = *CurByte++;
- case 3 : *Output++ = *CurByte++;
- case 2 : *Output++ = *CurByte++;
- case 1 : *Output++ = *CurByte++;
- }
- }
- }
-
- return Output;
-}
-
-
-////////////////////////////////////////////////////////////
-/// Generic function to convert an UTF-32 characters range
-/// to an UTF-16 characters range, using the given locale
-////////////////////////////////////////////////////////////
-template <typename In, typename Out>
-inline Out Unicode::UTF32ToUTF16(In Begin, In End, Out Output, Uint16 Replacement)
-{
- while (Begin < End)
- {
- Uint32 c = *Begin++;
- if (c < 0xFFFF)
- {
- // Character can be converted directly to 16 bits, just need to check it's in the valid range
- if ((c >= 0xD800) && (c <= 0xDFFF))
- {
- // Invalid character (this range is reserved)
- if (Replacement)
- *Output++ = Replacement;
- }
- else
- {
- // Valid character directly convertible to 16 bits
- *Output++ = static_cast<Uint16>(c);
- }
- }
- else if (c > 0x0010FFFF)
- {
- // Invalid character (greater than the maximum unicode value)
- if (Replacement)
- *Output++ = Replacement;
- }
- else
- {
- // Character will be converted to 2 UTF-16 elements
- c -= 0x0010000;
- *Output++ = static_cast<Uint16>((c >> 10) + 0xD800);
- *Output++ = static_cast<Uint16>((c & 0x3FFUL) + 0xDC00);
- }
- }
-
- return Output;
-}
-
-
-////////////////////////////////////////////////////////////
-/// Get the number of characters composing an UTF-8 string
-////////////////////////////////////////////////////////////
-template <typename In>
-inline std::size_t Unicode::GetUTF8Length(In Begin, In End)
-{
- std::size_t Length = 0;
- while (Begin < End)
- {
- int NbBytes = UTF8TrailingBytes[static_cast<int>(*Begin)];
- if (Begin + NbBytes < End)
- ++Length;
-
- Begin += NbBytes + 1;
- }
-
- return Length;
-}
-
-
-////////////////////////////////////////////////////////////
-/// Get the number of characters composing an UTF-16 string
-////////////////////////////////////////////////////////////
-template <typename In>
-inline std::size_t Unicode::GetUTF16Length(In Begin, In End)
-{
- std::size_t Length = 0;
- while (Begin < End)
- {
- if ((*Begin >= 0xD800) && (*Begin <= 0xDBFF))
- {
- ++Begin;
- if ((Begin < End) && ((*Begin >= 0xDC00) && (*Begin <= 0xDFFF)))
- {
- ++Length;
- }
- }
- else
- {
- ++Length;
- }
-
- ++Begin;
- }
-
- return Length;
-}
-
-
-////////////////////////////////////////////////////////////
-/// Get the number of characters composing an UTF-32 string
-////////////////////////////////////////////////////////////
-template <typename In>
-inline std::size_t Unicode::GetUTF32Length(In Begin, In End)
-{
- return End - Begin;
-}
diff --git a/include/SFML/System/Unix/Mutex.hpp b/include/SFML/System/Unix/Mutex.hpp deleted file mode 100755 index f8f24b6..0000000 --- a/include/SFML/System/Unix/Mutex.hpp +++ /dev/null @@ -1,82 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_MUTEXUNIX_HPP
-#define SFML_MUTEXUNIX_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/System/NonCopyable.hpp>
-#include <pthread.h>
-
-
-namespace sf
-{
-////////////////////////////////////////////////////////////
-/// Mutex defines a mutex (MUTual EXclusion) object,
-/// that allows a thread to lock critical instructions
-/// to avoid simultaneous access with other threads.
-/// See Lock for an efficient way of using it.
-////////////////////////////////////////////////////////////
-class SFML_API Mutex : NonCopyable
-{
-public :
-
- ////////////////////////////////////////////////////////////
- /// Default constructor
- ///
- ////////////////////////////////////////////////////////////
- Mutex();
-
- ////////////////////////////////////////////////////////////
- /// Destructor
- ///
- ////////////////////////////////////////////////////////////
- ~Mutex();
-
- ////////////////////////////////////////////////////////////
- /// Lock the mutex
- ///
- ////////////////////////////////////////////////////////////
- void Lock();
-
- ////////////////////////////////////////////////////////////
- /// Unlock the mutex
- ///
- ////////////////////////////////////////////////////////////
- void Unlock();
-
-private :
-
- ////////////////////////////////////////////////////////////
- // Member data
- ////////////////////////////////////////////////////////////
- pthread_mutex_t myMutex; ///< pthread instance of the mutex
-};
-
-} // namespace sf
-
-
-#endif // SFML_MUTEXUNIX_HPP
diff --git a/include/SFML/System/Unix/Thread.hpp b/include/SFML/System/Unix/Thread.hpp deleted file mode 100755 index b26d38f..0000000 --- a/include/SFML/System/Unix/Thread.hpp +++ /dev/null @@ -1,124 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_THREADUNIX_HPP
-#define SFML_THREADUNIX_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/System/NonCopyable.hpp>
-#include <pthread.h>
-
-
-namespace sf
-{
-////////////////////////////////////////////////////////////
-/// Thread defines a thread.
-/// There is two ways to use Thread :
-/// - Inherit from it and override the Run() virtual function
-/// - Construct a sfThread instance and pass it a function
-/// pointer to call
-////////////////////////////////////////////////////////////
-class SFML_API Thread : NonCopyable
-{
-public :
-
- typedef void (*FuncType)(void*);
-
- ////////////////////////////////////////////////////////////
- /// Construct the thread from a function pointer
- ///
- /// \param Function : Entry point of the thread
- /// \param UserData : Data to pass to the thread function (NULL by default)
- ///
- ////////////////////////////////////////////////////////////
- Thread(FuncType Function, void* UserData = NULL);
-
- ////////////////////////////////////////////////////////////
- /// Virtual destructor
- ///
- ////////////////////////////////////////////////////////////
- virtual ~Thread();
-
- ////////////////////////////////////////////////////////////
- /// Create and run the thread
- ///
- ////////////////////////////////////////////////////////////
- void Launch();
-
- ////////////////////////////////////////////////////////////
- /// Wait until the thread finishes
- ///
- ////////////////////////////////////////////////////////////
- void Wait();
-
- ////////////////////////////////////////////////////////////
- /// Terminate the thread
- /// Terminating a thread with this function is not safe,
- /// you should rather try to make the thread function
- /// terminate by itself
- ///
- ////////////////////////////////////////////////////////////
- void Terminate();
-
-protected :
-
- ////////////////////////////////////////////////////////////
- /// Default constructor
- ///
- ////////////////////////////////////////////////////////////
- Thread();
-
-private :
-
- ////////////////////////////////////////////////////////////
- /// Function called as the thread entry point
- ///
- ////////////////////////////////////////////////////////////
- virtual void Run();
-
- ////////////////////////////////////////////////////////////
- /// Actual thread entry point, dispatches to instances
- ///
- /// \param UserData : Data to pass to the thread function
- ///
- /// \return Error code
- ///
- ////////////////////////////////////////////////////////////
- static void* ThreadFunc(void* UserData);
-
- ////////////////////////////////////////////////////////////
- // Member data
- ////////////////////////////////////////////////////////////
- pthread_t myThread; ///< Unix thread instance
- bool myIsActive; ///< Thread state (active or inactive)
- FuncType myFunction; ///< Function to call as the thread entry point
- void* myUserData; ///< Data to pass to the thread function
-};
-
-} // namespace sf
-
-
-#endif // SFML_THREADUNIX_HPP
diff --git a/include/SFML/System/Utf.hpp b/include/SFML/System/Utf.hpp new file mode 100644 index 0000000..48e6e1b --- /dev/null +++ b/include/SFML/System/Utf.hpp @@ -0,0 +1,763 @@ +////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+// you must not claim that you wrote the original software.
+// If you use this software in a product, an acknowledgment
+// in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+// and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_UTF_HPP
+#define SFML_UTF_HPP
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Config.hpp>
+#include <algorithm>
+#include <locale>
+#include <string>
+#include <cstdlib>
+
+
+namespace sf
+{
+template <unsigned int N>
+class Utf;
+
+////////////////////////////////////////////////////////////
+/// \brief Specialization of the Utf template for UTF-8
+///
+////////////////////////////////////////////////////////////
+template <>
+class Utf<8>
+{
+public :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Decode a single UTF-8 character
+ ///
+ /// Decoding a character means finding its unique 32-bits
+ /// code (called the codepoint) in the Unicode standard.
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Codepoint of the decoded UTF-8 character
+ /// \param replacement Replacement character to use in case the UTF-8 sequence is invalid
+ ///
+ /// \return Iterator pointing to one past the last read element of the input sequence
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In>
+ static In decode(In begin, In end, Uint32& output, Uint32 replacement = 0);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Encode a single UTF-8 character
+ ///
+ /// Encoding a character means converting a unique 32-bits
+ /// code (called the codepoint) in the target encoding, UTF-8.
+ ///
+ /// \param input Codepoint to encode as UTF-8
+ /// \param output Iterator pointing to the beginning of the output sequence
+ /// \param replacement Replacement for characters not convertible to UTF-8 (use 0 to skip them)
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename Out>
+ static Out encode(Uint32 input, Out output, Uint8 replacement = 0);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Advance to the next UTF-8 character
+ ///
+ /// This function is necessary for multi-elements encodings, as
+ /// a single character may use more than 1 storage element.
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ ///
+ /// \return Iterator pointing to one past the last read element of the input sequence
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In>
+ static In next(In begin, In end);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Count the number of characters of a UTF-8 sequence
+ ///
+ /// This function is necessary for multi-elements encodings, as
+ /// a single character may use more than 1 storage element, thus the
+ /// total size can be different from (begin - end).
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ ///
+ /// \return Iterator pointing to one past the last read element of the input sequence
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In>
+ static std::size_t count(In begin, In end);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert an ANSI characters range to UTF-8
+ ///
+ /// The current global locale will be used by default, unless you
+ /// pass a custom one in the \a locale parameter.
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ /// \param locale Locale to use for conversion
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out fromAnsi(In begin, In end, Out output, const std::locale& locale = std::locale());
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert a wide characters range to UTF-8
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out fromWide(In begin, In end, Out output);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert a latin-1 (ISO-5589-1) characters range to UTF-8
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out fromLatin1(In begin, In end, Out output);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert an UTF-8 characters range to ANSI characters
+ ///
+ /// The current global locale will be used by default, unless you
+ /// pass a custom one in the \a locale parameter.
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ /// \param replacement Replacement for characters not convertible to ANSI (use 0 to skip them)
+ /// \param locale Locale to use for conversion
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out toAnsi(In begin, In end, Out output, char replacement = 0, const std::locale& locale = std::locale());
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert an UTF-8 characters range to wide characters
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ /// \param replacement Replacement for characters not convertible to wide (use 0 to skip them)
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out toWide(In begin, In end, Out output, wchar_t replacement = 0);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert an UTF-8 characters range to latin-1 (ISO-5589-1) characters
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ /// \param replacement Replacement for characters not convertible to wide (use 0 to skip them)
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out toLatin1(In begin, In end, Out output, char replacement = 0);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert a UTF-8 characters range to UTF-8
+ ///
+ /// This functions does nothing more than a direct copy;
+ /// it is defined only to provide the same interface as other
+ /// specializations of the sf::Utf<> template, and allow
+ /// generic code to be written on top of it.
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out toUtf8(In begin, In end, Out output);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert a UTF-8 characters range to UTF-16
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out toUtf16(In begin, In end, Out output);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert a UTF-8 characters range to UTF-32
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out toUtf32(In begin, In end, Out output);
+};
+
+////////////////////////////////////////////////////////////
+/// \brief Specialization of the Utf template for UTF-16
+///
+////////////////////////////////////////////////////////////
+template <>
+class Utf<16>
+{
+public :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Decode a single UTF-16 character
+ ///
+ /// Decoding a character means finding its unique 32-bits
+ /// code (called the codepoint) in the Unicode standard.
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Codepoint of the decoded UTF-16 character
+ /// \param replacement Replacement character to use in case the UTF-8 sequence is invalid
+ ///
+ /// \return Iterator pointing to one past the last read element of the input sequence
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In>
+ static In decode(In begin, In end, Uint32& output, Uint32 replacement = 0);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Encode a single UTF-16 character
+ ///
+ /// Encoding a character means converting a unique 32-bits
+ /// code (called the codepoint) in the target encoding, UTF-16.
+ ///
+ /// \param input Codepoint to encode as UTF-16
+ /// \param output Iterator pointing to the beginning of the output sequence
+ /// \param replacement Replacement for characters not convertible to UTF-16 (use 0 to skip them)
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename Out>
+ static Out encode(Uint32 input, Out output, Uint16 replacement = 0);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Advance to the next UTF-16 character
+ ///
+ /// This function is necessary for multi-elements encodings, as
+ /// a single character may use more than 1 storage element.
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ ///
+ /// \return Iterator pointing to one past the last read element of the input sequence
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In>
+ static In next(In begin, In end);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Count the number of characters of a UTF-16 sequence
+ ///
+ /// This function is necessary for multi-elements encodings, as
+ /// a single character may use more than 1 storage element, thus the
+ /// total size can be different from (begin - end).
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ ///
+ /// \return Iterator pointing to one past the last read element of the input sequence
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In>
+ static std::size_t count(In begin, In end);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert an ANSI characters range to UTF-16
+ ///
+ /// The current global locale will be used by default, unless you
+ /// pass a custom one in the \a locale parameter.
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ /// \param locale Locale to use for conversion
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out fromAnsi(In begin, In end, Out output, const std::locale& locale = std::locale());
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert a wide characters range to UTF-16
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out fromWide(In begin, In end, Out output);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert a latin-1 (ISO-5589-1) characters range to UTF-16
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out fromLatin1(In begin, In end, Out output);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert an UTF-16 characters range to ANSI characters
+ ///
+ /// The current global locale will be used by default, unless you
+ /// pass a custom one in the \a locale parameter.
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ /// \param replacement Replacement for characters not convertible to ANSI (use 0 to skip them)
+ /// \param locale Locale to use for conversion
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out toAnsi(In begin, In end, Out output, char replacement = 0, const std::locale& locale = std::locale());
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert an UTF-16 characters range to wide characters
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ /// \param replacement Replacement for characters not convertible to wide (use 0 to skip them)
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out toWide(In begin, In end, Out output, wchar_t replacement = 0);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert an UTF-16 characters range to latin-1 (ISO-5589-1) characters
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ /// \param replacement Replacement for characters not convertible to wide (use 0 to skip them)
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out toLatin1(In begin, In end, Out output, char replacement = 0);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert a UTF-16 characters range to UTF-8
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out toUtf8(In begin, In end, Out output);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert a UTF-16 characters range to UTF-16
+ ///
+ /// This functions does nothing more than a direct copy;
+ /// it is defined only to provide the same interface as other
+ /// specializations of the sf::Utf<> template, and allow
+ /// generic code to be written on top of it.
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out toUtf16(In begin, In end, Out output);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert a UTF-16 characters range to UTF-32
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out toUtf32(In begin, In end, Out output);
+};
+
+////////////////////////////////////////////////////////////
+/// \brief Specialization of the Utf template for UTF-32
+///
+////////////////////////////////////////////////////////////
+template <>
+class Utf<32>
+{
+public :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Decode a single UTF-32 character
+ ///
+ /// Decoding a character means finding its unique 32-bits
+ /// code (called the codepoint) in the Unicode standard.
+ /// For UTF-32, the character value is the same as the codepoint.
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Codepoint of the decoded UTF-32 character
+ /// \param replacement Replacement character to use in case the UTF-8 sequence is invalid
+ ///
+ /// \return Iterator pointing to one past the last read element of the input sequence
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In>
+ static In decode(In begin, In end, Uint32& output, Uint32 replacement = 0);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Encode a single UTF-32 character
+ ///
+ /// Encoding a character means converting a unique 32-bits
+ /// code (called the codepoint) in the target encoding, UTF-32.
+ /// For UTF-32, the codepoint is the same as the character value.
+ ///
+ /// \param input Codepoint to encode as UTF-32
+ /// \param output Iterator pointing to the beginning of the output sequence
+ /// \param replacement Replacement for characters not convertible to UTF-32 (use 0 to skip them)
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename Out>
+ static Out encode(Uint32 input, Out output, Uint32 replacement = 0);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Advance to the next UTF-32 character
+ ///
+ /// This function is trivial for UTF-32, which can store
+ /// every character in a single storage element.
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ ///
+ /// \return Iterator pointing to one past the last read element of the input sequence
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In>
+ static In next(In begin, In end);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Count the number of characters of a UTF-32 sequence
+ ///
+ /// This function is trivial for UTF-32, which can store
+ /// every character in a single storage element.
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ ///
+ /// \return Iterator pointing to one past the last read element of the input sequence
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In>
+ static std::size_t count(In begin, In end);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert an ANSI characters range to UTF-32
+ ///
+ /// The current global locale will be used by default, unless you
+ /// pass a custom one in the \a locale parameter.
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ /// \param locale Locale to use for conversion
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out fromAnsi(In begin, In end, Out output, const std::locale& locale = std::locale());
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert a wide characters range to UTF-32
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out fromWide(In begin, In end, Out output);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert a latin-1 (ISO-5589-1) characters range to UTF-32
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out fromLatin1(In begin, In end, Out output);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert an UTF-32 characters range to ANSI characters
+ ///
+ /// The current global locale will be used by default, unless you
+ /// pass a custom one in the \a locale parameter.
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ /// \param replacement Replacement for characters not convertible to ANSI (use 0 to skip them)
+ /// \param locale Locale to use for conversion
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out toAnsi(In begin, In end, Out output, char replacement = 0, const std::locale& locale = std::locale());
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert an UTF-32 characters range to wide characters
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ /// \param replacement Replacement for characters not convertible to wide (use 0 to skip them)
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out toWide(In begin, In end, Out output, wchar_t replacement = 0);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert an UTF-16 characters range to latin-1 (ISO-5589-1) characters
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ /// \param replacement Replacement for characters not convertible to wide (use 0 to skip them)
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out toLatin1(In begin, In end, Out output, char replacement = 0);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert a UTF-32 characters range to UTF-8
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out toUtf8(In begin, In end, Out output);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert a UTF-32 characters range to UTF-16
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out toUtf16(In begin, In end, Out output);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Convert a UTF-32 characters range to UTF-32
+ ///
+ /// This functions does nothing more than a direct copy;
+ /// it is defined only to provide the same interface as other
+ /// specializations of the sf::Utf<> template, and allow
+ /// generic code to be written on top of it.
+ ///
+ /// \param begin Iterator pointing to the beginning of the input sequence
+ /// \param end Iterator pointing to the end of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In, typename Out>
+ static Out toUtf32(In begin, In end, Out output);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Decode a single ANSI character to UTF-32
+ ///
+ /// This function does not exist in other specializations
+ /// of sf::Utf<>, it is defined for convenience (it is used by
+ /// several other conversion functions).
+ ///
+ /// \param input Input ANSI character
+ /// \param locale Locale to use for conversion
+ ///
+ /// \return Converted character
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In>
+ static Uint32 decodeAnsi(In input, const std::locale& locale = std::locale());
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Decode a single wide character to UTF-32
+ ///
+ /// This function does not exist in other specializations
+ /// of sf::Utf<>, it is defined for convenience (it is used by
+ /// several other conversion functions).
+ ///
+ /// \param input Input wide character
+ ///
+ /// \return Converted character
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename In>
+ static Uint32 decodeWide(In input);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Encode a single UTF-32 character to ANSI
+ ///
+ /// This function does not exist in other specializations
+ /// of sf::Utf<>, it is defined for convenience (it is used by
+ /// several other conversion functions).
+ ///
+ /// \param codepoint Iterator pointing to the beginning of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ /// \param replacement Replacement if the input character is not convertible to ANSI (use 0 to skip it)
+ /// \param locale Locale to use for conversion
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename Out>
+ static Out encodeAnsi(Uint32 codepoint, Out output, char replacement = 0, const std::locale& locale = std::locale());
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Encode a single UTF-32 character to wide
+ ///
+ /// This function does not exist in other specializations
+ /// of sf::Utf<>, it is defined for convenience (it is used by
+ /// several other conversion functions).
+ ///
+ /// \param codepoint Iterator pointing to the beginning of the input sequence
+ /// \param output Iterator pointing to the beginning of the output sequence
+ /// \param replacement Replacement if the input character is not convertible to wide (use 0 to skip it)
+ ///
+ /// \return Iterator to the end of the output sequence which has been written
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename Out>
+ static Out encodeWide(Uint32 codepoint, Out output, wchar_t replacement = 0);
+};
+
+#include <SFML/System/Utf.inl>
+
+// Make typedefs to get rid of the template syntax
+typedef Utf<8> Utf8;
+typedef Utf<16> Utf16;
+typedef Utf<32> Utf32;
+
+} // namespace sf
+
+
+#endif // SFML_UTF_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Utf
+/// \ingroup system
+///
+/// Utility class providing generic functions for UTF conversions.
+///
+/// sf::Utf is a low-level, generic interface for counting, iterating,
+/// encoding and decoding Unicode characters and strings. It is able
+/// to handle ANSI, wide, latin-1, UTF-8, UTF-16 and UTF-32 encodings.
+///
+/// sf::Utf<X> functions are all static, these classes are not meant to
+/// be instanciated. All the functions are template, so that you
+/// can use any character / string type for a given encoding.
+///
+/// It has 3 specializations:
+/// \li sf::Utf<8> (typedef'd to sf::Utf8)
+/// \li sf::Utf<16> (typedef'd to sf::Utf16)
+/// \li sf::Utf<32> (typedef'd to sf::Utf32)
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/System/Utf.inl b/include/SFML/System/Utf.inl new file mode 100644 index 0000000..672a0fa --- /dev/null +++ b/include/SFML/System/Utf.inl @@ -0,0 +1,752 @@ +////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2012 Laurent Gomila (laurent.gom@gmail.com)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+// you must not claim that you wrote the original software.
+// If you use this software in a product, an acknowledgment
+// in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+// and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////
+// References :
+//
+// http://www.unicode.org/
+// http://www.unicode.org/Public/PROGRAMS/CVTUTF/ConvertUTF.c
+// http://www.unicode.org/Public/PROGRAMS/CVTUTF/ConvertUTF.h
+// http://people.w3.org/rishida/scripts/uniview/conversion
+//
+////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////
+template <typename In>
+In Utf<8>::decode(In begin, In end, Uint32& output, Uint32 replacement)
+{
+ // Some useful precomputed data
+ static const int trailing[256] =
+ {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5
+ };
+ static const Uint32 offsets[6] =
+ {
+ 0x00000000, 0x00003080, 0x000E2080, 0x03C82080, 0xFA082080, 0x82082080
+ };
+
+ // decode the character
+ int trailingBytes = trailing[static_cast<Uint8>(*begin)];
+ if (begin + trailingBytes < end)
+ {
+ output = 0;
+ switch (trailingBytes)
+ {
+ case 5 : output += static_cast<Uint8>(*begin++); output <<= 6;
+ case 4 : output += static_cast<Uint8>(*begin++); output <<= 6;
+ case 3 : output += static_cast<Uint8>(*begin++); output <<= 6;
+ case 2 : output += static_cast<Uint8>(*begin++); output <<= 6;
+ case 1 : output += static_cast<Uint8>(*begin++); output <<= 6;
+ case 0 : output += static_cast<Uint8>(*begin++);
+ }
+ output -= offsets[trailingBytes];
+ }
+ else
+ {
+ // Incomplete character
+ begin = end;
+ output = replacement;
+ }
+
+ return begin;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename Out>
+Out Utf<8>::encode(Uint32 input, Out output, Uint8 replacement)
+{
+ // Some useful precomputed data
+ static const Uint8 firstBytes[7] =
+ {
+ 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC
+ };
+
+ // encode the character
+ if ((input > 0x0010FFFF) || ((input >= 0xD800) && (input <= 0xDBFF)))
+ {
+ // Invalid character
+ if (replacement)
+ *output++ = replacement;
+ }
+ else
+ {
+ // Valid character
+
+ // Get the number of bytes to write
+ std::size_t bytestoWrite = 1;
+ if (input < 0x80) bytestoWrite = 1;
+ else if (input < 0x800) bytestoWrite = 2;
+ else if (input < 0x10000) bytestoWrite = 3;
+ else if (input <= 0x0010FFFF) bytestoWrite = 4;
+
+ // Extract the bytes to write
+ Uint8 bytes[4];
+ switch (bytestoWrite)
+ {
+ case 4 : bytes[3] = static_cast<Uint8>((input | 0x80) & 0xBF); input >>= 6;
+ case 3 : bytes[2] = static_cast<Uint8>((input | 0x80) & 0xBF); input >>= 6;
+ case 2 : bytes[1] = static_cast<Uint8>((input | 0x80) & 0xBF); input >>= 6;
+ case 1 : bytes[0] = static_cast<Uint8> (input | firstBytes[bytestoWrite]);
+ }
+
+ // Add them to the output
+ output = std::copy(bytes, bytes + bytestoWrite, output);
+ }
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In>
+In Utf<8>::next(In begin, In end)
+{
+ Uint32 codepoint;
+ return decode(begin, end, codepoint);
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In>
+std::size_t Utf<8>::count(In begin, In end)
+{
+ std::size_t length = 0;
+ while (begin < end)
+ {
+ begin = next(begin, end);
+ ++length;
+ }
+
+ return length;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<8>::fromAnsi(In begin, In end, Out output, const std::locale& locale)
+{
+ while (begin < end)
+ {
+ Uint32 codepoint = Utf<32>::decodeAnsi(*begin++, locale);
+ output = encode(codepoint, output);
+ }
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<8>::fromWide(In begin, In end, Out output)
+{
+ while (begin < end)
+ {
+ Uint32 codepoint = Utf<32>::decodeWide(*begin++);
+ output = encode(codepoint, output);
+ }
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<8>::fromLatin1(In begin, In end, Out output)
+{
+ // Latin-1 is directly compatible with Unicode encodings,
+ // and can thus be treated as (a sub-range of) UTF-32
+ while (begin < end)
+ output = encode(*begin++, output);
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<8>::toAnsi(In begin, In end, Out output, char replacement, const std::locale& locale)
+{
+ while (begin < end)
+ {
+ Uint32 codepoint;
+ begin = decode(begin, end, codepoint);
+ output = Utf<32>::encodeAnsi(codepoint, output, replacement, locale);
+ }
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<8>::toWide(In begin, In end, Out output, wchar_t replacement)
+{
+ while (begin < end)
+ {
+ Uint32 codepoint;
+ begin = decode(begin, end, codepoint);
+ output = Utf<32>::encodeWide(codepoint, output, replacement);
+ }
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<8>::toLatin1(In begin, In end, Out output, char replacement)
+{
+ // Latin-1 is directly compatible with Unicode encodings,
+ // and can thus be treated as (a sub-range of) UTF-32
+ while (begin < end)
+ {
+ Uint32 codepoint;
+ begin = decode(begin, end, codepoint);
+ *output++ = codepoint < 256 ? static_cast<char>(codepoint) : replacement;
+ }
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<8>::toUtf8(In begin, In end, Out output)
+{
+ return std::copy(begin, end, output);
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<8>::toUtf16(In begin, In end, Out output)
+{
+ while (begin < end)
+ {
+ Uint32 codepoint;
+ begin = decode(begin, end, codepoint);
+ output = Utf<16>::encode(codepoint, output);
+ }
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<8>::toUtf32(In begin, In end, Out output)
+{
+ while (begin < end)
+ {
+ Uint32 codepoint;
+ begin = decode(begin, end, codepoint);
+ *output++ = codepoint;
+ }
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In>
+In Utf<16>::decode(In begin, In end, Uint32& output, Uint32 replacement)
+{
+ Uint16 first = *begin++;
+
+ // If it's a surrogate pair, first convert to a single UTF-32 character
+ if ((first >= 0xD800) && (first <= 0xDBFF))
+ {
+ if (begin < end)
+ {
+ Uint32 second = *begin++;
+ if ((second >= 0xDC00) && (second <= 0xDFFF))
+ {
+ // The second element is valid: convert the two elements to a UTF-32 character
+ output = static_cast<Uint32>(((first - 0xD800) << 10) + (second - 0xDC00) + 0x0010000);
+ }
+ else
+ {
+ // Invalid character
+ output = replacement;
+ }
+ }
+ else
+ {
+ // Invalid character
+ begin = end;
+ output = replacement;
+ }
+ }
+ else
+ {
+ // We can make a direct copy
+ output = first;
+ }
+
+ return begin;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename Out>
+Out Utf<16>::encode(Uint32 input, Out output, Uint16 replacement)
+{
+ if (input < 0xFFFF)
+ {
+ // The character can be copied directly, we just need to check if it's in the valid range
+ if ((input >= 0xD800) && (input <= 0xDFFF))
+ {
+ // Invalid character (this range is reserved)
+ if (replacement)
+ *output++ = replacement;
+ }
+ else
+ {
+ // Valid character directly convertible to a single UTF-16 character
+ *output++ = static_cast<Uint16>(input);
+ }
+ }
+ else if (input > 0x0010FFFF)
+ {
+ // Invalid character (greater than the maximum unicode value)
+ if (replacement)
+ *output++ = replacement;
+ }
+ else
+ {
+ // The input character will be converted to two UTF-16 elements
+ input -= 0x0010000;
+ *output++ = static_cast<Uint16>((input >> 10) + 0xD800);
+ *output++ = static_cast<Uint16>((input & 0x3FFUL) + 0xDC00);
+ }
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In>
+In Utf<16>::next(In begin, In end)
+{
+ Uint32 codepoint;
+ return decode(begin, end, codepoint);
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In>
+std::size_t Utf<16>::count(In begin, In end)
+{
+ std::size_t length = 0;
+ while (begin < end)
+ {
+ begin = next(begin, end);
+ ++length;
+ }
+
+ return length;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<16>::fromAnsi(In begin, In end, Out output, const std::locale& locale)
+{
+ while (begin < end)
+ {
+ Uint32 codepoint = Utf<32>::decodeAnsi(*begin++, locale);
+ output = encode(codepoint, output);
+ }
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<16>::fromWide(In begin, In end, Out output)
+{
+ while (begin < end)
+ {
+ Uint32 codepoint = Utf<32>::decodeWide(*begin++);
+ output = encode(codepoint, output);
+ }
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<16>::fromLatin1(In begin, In end, Out output)
+{
+ // Latin-1 is directly compatible with Unicode encodings,
+ // and can thus be treated as (a sub-range of) UTF-32
+ return std::copy(begin, end, output);
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<16>::toAnsi(In begin, In end, Out output, char replacement, const std::locale& locale)
+{
+ while (begin < end)
+ {
+ Uint32 codepoint;
+ begin = decode(begin, end, codepoint);
+ output = Utf<32>::encodeAnsi(codepoint, output, replacement, locale);
+ }
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<16>::toWide(In begin, In end, Out output, wchar_t replacement)
+{
+ while (begin < end)
+ {
+ Uint32 codepoint;
+ begin = decode(begin, end, codepoint);
+ output = Utf<32>::encodeWide(codepoint, output, replacement);
+ }
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<16>::toLatin1(In begin, In end, Out output, char replacement)
+{
+ // Latin-1 is directly compatible with Unicode encodings,
+ // and can thus be treated as (a sub-range of) UTF-32
+ while (begin < end)
+ {
+ *output++ = *begin < 256 ? static_cast<char>(*begin) : replacement;
+ begin++;
+ }
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<16>::toUtf8(In begin, In end, Out output)
+{
+ while (begin < end)
+ {
+ Uint32 codepoint;
+ begin = decode(begin, end, codepoint);
+ output = Utf<8>::encode(codepoint, output);
+ }
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<16>::toUtf16(In begin, In end, Out output)
+{
+ return std::copy(begin, end, output);
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<16>::toUtf32(In begin, In end, Out output)
+{
+ while (begin < end)
+ {
+ Uint32 codepoint;
+ begin = decode(begin, end, codepoint);
+ *output++ = codepoint;
+ }
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In>
+In Utf<32>::decode(In begin, In /*end*/, Uint32& output, Uint32 /*replacement*/)
+{
+ output = *begin++;
+ return begin;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename Out>
+Out Utf<32>::encode(Uint32 input, Out output, Uint32 /*replacement*/)
+{
+ *output++ = input;
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In>
+In Utf<32>::next(In begin, In /*end*/)
+{
+ return ++begin;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In>
+std::size_t Utf<32>::count(In begin, In end)
+{
+ return begin - end;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<32>::fromAnsi(In begin, In end, Out output, const std::locale& locale)
+{
+ while (begin < end)
+ *output++ = decodeAnsi(*begin++, locale);
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<32>::fromWide(In begin, In end, Out output)
+{
+ while (begin < end)
+ *output++ = decodeWide(*begin++);
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<32>::fromLatin1(In begin, In end, Out output)
+{
+ // Latin-1 is directly compatible with Unicode encodings,
+ // and can thus be treated as (a sub-range of) UTF-32
+ return std::copy(begin, end, output);
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<32>::toAnsi(In begin, In end, Out output, char replacement, const std::locale& locale)
+{
+ while (begin < end)
+ output = encodeAnsi(*begin++, output, replacement, locale);
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<32>::toWide(In begin, In end, Out output, wchar_t replacement)
+{
+ while (begin < end)
+ output = encodeWide(*begin++, output, replacement);
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<32>::toLatin1(In begin, In end, Out output, char replacement)
+{
+ // Latin-1 is directly compatible with Unicode encodings,
+ // and can thus be treated as (a sub-range of) UTF-32
+ while (begin < end)
+ {
+ *output++ = *begin < 256 ? static_cast<char>(*begin) : replacement;
+ begin++;
+ }
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<32>::toUtf8(In begin, In end, Out output)
+{
+ while (begin < end)
+ output = Utf<8>::encode(*begin++, output);
+
+ return output;
+}
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<32>::toUtf16(In begin, In end, Out output)
+{
+ while (begin < end)
+ output = Utf<16>::encode(*begin++, output);
+
+ return output;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In, typename Out>
+Out Utf<32>::toUtf32(In begin, In end, Out output)
+{
+ return std::copy(begin, end, output);
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In>
+Uint32 Utf<32>::decodeAnsi(In input, const std::locale& locale)
+{
+ // On Windows, gcc's standard library (glibc++) has almost
+ // no support for Unicode stuff. As a consequence, in this
+ // context we can only use the default locale and ignore
+ // the one passed as parameter.
+
+ #if defined(SFML_SYSTEM_WINDOWS) && /* if Windows ... */ \
+ (defined(__GLIBCPP__) || defined (__GLIBCXX__)) && /* ... and standard library is glibc++ ... */ \
+ !(defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)) /* ... and STLPort is not used on top of it */
+
+ (void)locale; // to avoid warnings
+
+ wchar_t character = 0;
+ mbtowc(&character, &input, 1);
+ return static_cast<Uint32>(character);
+
+ #else
+
+ // Get the facet of the locale which deals with character conversion
+ const std::ctype<wchar_t>& facet = std::use_facet< std::ctype<wchar_t> >(locale);
+
+ // Use the facet to convert each character of the input string
+ return static_cast<Uint32>(facet.widen(input));
+
+ #endif
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename In>
+Uint32 Utf<32>::decodeWide(In input)
+{
+ // The encoding of wide characters is not well defined and is left to the system;
+ // however we can safely assume that it is UCS-2 on Windows and
+ // UCS-4 on Unix systems.
+ // In both cases, a simple copy is enough (UCS-2 is a subset of UCS-4,
+ // and UCS-4 *is* UTF-32).
+
+ return input;
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename Out>
+Out Utf<32>::encodeAnsi(Uint32 codepoint, Out output, char replacement, const std::locale& locale)
+{
+ // On Windows, gcc's standard library (glibc++) has almost
+ // no support for Unicode stuff. As a consequence, in this
+ // context we can only use the default locale and ignore
+ // the one passed as parameter.
+
+ #if defined(SFML_SYSTEM_WINDOWS) && /* if Windows ... */ \
+ (defined(__GLIBCPP__) || defined (__GLIBCXX__)) && /* ... and standard library is glibc++ ... */ \
+ !(defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)) /* ... and STLPort is not used on top of it */
+
+ (void)locale; // to avoid warnings
+
+ char character = 0;
+ if (wctomb(&character, static_cast<wchar_t>(codepoint)) >= 0)
+ *output++ = character;
+ else if (replacement)
+ *output++ = replacement;
+
+ return output;
+
+ #else
+
+ // Get the facet of the locale which deals with character conversion
+ const std::ctype<wchar_t>& facet = std::use_facet< std::ctype<wchar_t> >(locale);
+
+ // Use the facet to convert each character of the input string
+ *output++ = facet.narrow(static_cast<wchar_t>(codepoint), replacement);
+
+ return output;
+
+ #endif
+}
+
+
+////////////////////////////////////////////////////////////
+template <typename Out>
+Out Utf<32>::encodeWide(Uint32 codepoint, Out output, wchar_t replacement)
+{
+ // The encoding of wide characters is not well defined and is left to the system;
+ // however we can safely assume that it is UCS-2 on Windows and
+ // UCS-4 on Unix systems.
+ // For UCS-2 we need to check if the source characters fits in (UCS-2 is a subset of UCS-4).
+ // For UCS-4 we can do a direct copy (UCS-4 *is* UTF-32).
+
+ switch (sizeof(wchar_t))
+ {
+ case 4:
+ {
+ *output++ = static_cast<wchar_t>(codepoint);
+ break;
+ }
+
+ default:
+ {
+ if ((codepoint <= 0xFFFF) && ((codepoint < 0xD800) || (codepoint > 0xDFFF)))
+ {
+ *output++ = static_cast<wchar_t>(codepoint);
+ }
+ else if (replacement)
+ {
+ *output++ = replacement;
+ }
+ break;
+ }
+ }
+
+ return output;
+}
diff --git a/include/SFML/System/Vector2.hpp b/include/SFML/System/Vector2.hpp index 0a5267c..5c3bb64 100755..100644 --- a/include/SFML/System/Vector2.hpp +++ b/include/SFML/System/Vector2.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -29,9 +29,9 @@ namespace sf
{
////////////////////////////////////////////////////////////
-/// Vector2 is an utility class for manipulating 2 dimensional
-/// vectors. Template parameter defines the type of coordinates
-/// (integer, float, ...)
+/// \brief Utility template class for manipulating
+/// 2-dimensional vectors
+///
////////////////////////////////////////////////////////////
template <typename T>
class Vector2
@@ -39,21 +39,37 @@ class Vector2 public :
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
+ ///
+ /// Creates a Vector2(0, 0).
///
////////////////////////////////////////////////////////////
Vector2();
////////////////////////////////////////////////////////////
- /// Construct the vector from its coordinates
+ /// \brief Construct the vector from its coordinates
///
- /// \param X : X coordinate
- /// \param Y : Y coordinate
+ /// \param X X coordinate
+ /// \param Y Y coordinate
///
////////////////////////////////////////////////////////////
Vector2(T X, T Y);
////////////////////////////////////////////////////////////
+ /// \brief Construct the vector from another type of vector
+ ///
+ /// This constructor doesn't replace the copy constructor,
+ /// it's called only when U != T.
+ /// A call to this constructor will fail to compile if U
+ /// is not convertible to T.
+ ///
+ /// \param vector Vector to convert
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename U>
+ explicit Vector2(const Vector2<U>& vector);
+
+ ////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
T x; ///< X coordinate of the vector
@@ -61,155 +77,225 @@ public : };
////////////////////////////////////////////////////////////
-/// Operator - overload ; returns the opposite of a vector
+/// \relates Vector2
+/// \brief Overload of unary operator -
///
-/// \param V : Vector to negate
+/// \param right Vector to negate
///
-/// \return -V
+/// \return Memberwise opposite of the vector
///
////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T> operator -(const Vector2<T>& V);
+Vector2<T> operator -(const Vector2<T>& right);
////////////////////////////////////////////////////////////
-/// Operator += overload ; add two vectors and assign to the first op
+/// \relates Vector2
+/// \brief Overload of binary operator +=
+///
+/// This operator performs a memberwise addition of both vectors,
+/// and assigns the result to \a left.
///
-/// \param V1 : First vector
-/// \param V2 : Second vector
+/// \param left Left operand (a vector)
+/// \param right Right operand (a vector)
///
-/// \return V1 + V2
+/// \return Reference to \a left
///
////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T>& operator +=(Vector2<T>& V1, const Vector2<T>& V2);
+Vector2<T>& operator +=(Vector2<T>& left, const Vector2<T>& right);
////////////////////////////////////////////////////////////
-/// Operator -= overload ; subtract two vectors and assign to the first op
+/// \relates Vector2
+/// \brief Overload of binary operator -=
///
-/// \param V1 : First vector
-/// \param V2 : Second vector
+/// This operator performs a memberwise subtraction of both vectors,
+/// and assigns the result to \a left.
///
-/// \return V1 - V2
+/// \param left Left operand (a vector)
+/// \param right Right operand (a vector)
+///
+/// \return Reference to \a left
///
////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T>& operator -=(Vector2<T>& V1, const Vector2<T>& V2);
+Vector2<T>& operator -=(Vector2<T>& left, const Vector2<T>& right);
////////////////////////////////////////////////////////////
-/// Operator + overload ; adds two vectors
+/// \relates Vector2
+/// \brief Overload of binary operator +
///
-/// \param V1 : First vector
-/// \param V2 : Second vector
+/// \param left Left operand (a vector)
+/// \param right Right operand (a vector)
///
-/// \return V1 + V2
+/// \return Memberwise addition of both vectors
///
////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T> operator +(const Vector2<T>& V1, const Vector2<T>& V2);
+Vector2<T> operator +(const Vector2<T>& left, const Vector2<T>& right);
////////////////////////////////////////////////////////////
-/// Operator - overload ; subtracts two vectors
+/// \relates Vector2
+/// \brief Overload of binary operator -
///
-/// \param V1 : First vector
-/// \param V2 : Second vector
+/// \param left Left operand (a vector)
+/// \param right Right operand (a vector)
///
-/// \return V1 - V2
+/// \return Memberwise subtraction of both vectors
///
////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T> operator -(const Vector2<T>& V1, const Vector2<T>& V2);
+Vector2<T> operator -(const Vector2<T>& left, const Vector2<T>& right);
////////////////////////////////////////////////////////////
-/// Operator * overload ; multiply a vector by a scalar value
+/// \relates Vector2
+/// \brief Overload of binary operator *
///
-/// \param V : Vector
-/// \param X : Scalar value
+/// \param left Left operand (a vector)
+/// \param right Right operand (a scalar value)
///
-/// \return V * X
+/// \return Memberwise multiplication by \a right
///
////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T> operator *(const Vector2<T>& V, T X);
+Vector2<T> operator *(const Vector2<T>& left, T right);
////////////////////////////////////////////////////////////
-/// Operator * overload ; multiply a scalar value by a vector
+/// \relates Vector2
+/// \brief Overload of binary operator *
///
-/// \param X : Scalar value
-/// \param V : Vector
+/// \param left Left operand (a scalar value)
+/// \param right Right operand (a vector)
///
-/// \return X * V
+/// \return Memberwise multiplication by \a left
///
////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T> operator *(T X, const Vector2<T>& V);
+Vector2<T> operator *(T left, const Vector2<T>& right);
////////////////////////////////////////////////////////////
-/// Operator *= overload ; multiply-assign a vector by a scalar value
+/// \relates Vector2
+/// \brief Overload of binary operator *=
+///
+/// This operator performs a memberwise multiplication by \a right,
+/// and assigns the result to \a left.
///
-/// \param V : Vector
-/// \param X : Scalar value
+/// \param left Left operand (a vector)
+/// \param right Right operand (a scalar value)
///
-/// \return V * X
+/// \return Reference to \a left
///
////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T>& operator *=(Vector2<T>& V, T X);
+Vector2<T>& operator *=(Vector2<T>& left, T right);
////////////////////////////////////////////////////////////
-/// Operator / overload ; divide a vector by a scalar value
+/// \relates Vector2
+/// \brief Overload of binary operator /
///
-/// \param V : Vector
-/// \param X : Scalar value
+/// \param left Left operand (a vector)
+/// \param right Right operand (a scalar value)
///
-/// \return V / X
+/// \return Memberwise division by \a right
///
////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T> operator /(const Vector2<T>& V, T X);
+Vector2<T> operator /(const Vector2<T>& left, T right);
////////////////////////////////////////////////////////////
-/// Operator /= overload ; divide-assign a vector by a scalar value
+/// \relates Vector2
+/// \brief Overload of binary operator /=
///
-/// \param V : Vector
-/// \param X : Scalar value
+/// This operator performs a memberwise division by \a right,
+/// and assigns the result to \a left.
///
-/// \return V / X
+/// \param left Left operand (a vector)
+/// \param right Right operand (a scalar value)
+///
+/// \return Reference to \a left
///
////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T>& operator /=(Vector2<T>& V, T X);
+Vector2<T>& operator /=(Vector2<T>& left, T right);
////////////////////////////////////////////////////////////
-/// Operator == overload ; compares the equality of two vectors
+/// \relates Vector2
+/// \brief Overload of binary operator ==
+///
+/// This operator compares strict equality between two vectors.
///
-/// \param V1 : First vector
-/// \param V2 : Second vector
+/// \param left Left operand (a vector)
+/// \param right Right operand (a vector)
///
-/// \return True if V1 is equal to V2
+/// \return True if \a left is equal to \a right
///
////////////////////////////////////////////////////////////
template <typename T>
-bool operator ==(const Vector2<T>& V1, const Vector2<T>& V2);
+bool operator ==(const Vector2<T>& left, const Vector2<T>& right);
////////////////////////////////////////////////////////////
-/// Operator != overload ; compares the difference of two vectors
+/// \relates Vector2
+/// \brief Overload of binary operator !=
+///
+/// This operator compares strict difference between two vectors.
///
-/// \param V1 : First vector
-/// \param V2 : Second vector
+/// \param left Left operand (a vector)
+/// \param right Right operand (a vector)
///
-/// \return True if V1 is different than V2
+/// \return True if \a left is not equal to \a right
///
////////////////////////////////////////////////////////////
template <typename T>
-bool operator !=(const Vector2<T>& V1, const Vector2<T>& V2);
+bool operator !=(const Vector2<T>& left, const Vector2<T>& right);
#include <SFML/System/Vector2.inl>
// Define the most common types
-typedef Vector2<int> Vector2i;
-typedef Vector2<float> Vector2f;
+typedef Vector2<int> Vector2i;
+typedef Vector2<unsigned int> Vector2u;
+typedef Vector2<float> Vector2f;
} // namespace sf
#endif // SFML_VECTOR2_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Vector2
+/// \ingroup system
+///
+/// sf::Vector2 is a simple class that defines a mathematical
+/// vector with two coordinates (x and y). It can be used to
+/// represent anything that has two dimensions: a size, a point,
+/// a velocity, etc.
+///
+/// The template parameter T is the type of the coordinates. It
+/// can be any type that supports arithmetic operations (+, -, /, *)
+/// and comparisons (==, !=), for example int or float.
+///
+/// You generally don't have to care about the templated form (sf::Vector2<T>),
+/// the most common specializations have special typedefs:
+/// \li sf::Vector2<float> is sf::Vector2f
+/// \li sf::Vector2<int> is sf::Vector2i
+/// \li sf::Vector2<unsigned int> is sf::Vector2u
+///
+/// The sf::Vector2 class has a small and simple interface, its x and y members
+/// can be accessed directly (there's no accessor like setX(), getX()) and it
+/// contains no mathematical function like dot product, cross product, length, etc.
+///
+/// Usage example:
+/// \code
+/// sf::Vector2f v1(16.5f, 24.f);
+/// v1.x = 18.2f;
+/// float y = v1.y;
+///
+/// sf::Vector2f v2 = v1 * 5.f;
+/// sf::Vector2f v3;
+/// v3 = v1 + v2;
+///
+/// bool different = (v2 != v3);
+/// \endcode
+///
+/// Note: for 3-dimensional vectors, see sf::Vector3.
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/System/Vector2.inl b/include/SFML/System/Vector2.inl index febd493..e1a87ae 100755..100644 --- a/include/SFML/System/Vector2.inl +++ b/include/SFML/System/Vector2.inl @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2012 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -24,10 +24,8 @@ ////////////////////////////////////////////////////////////
-/// Default constructor
-////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T>::Vector2() :
+inline Vector2<T>::Vector2() :
x(0),
y(0)
{
@@ -36,10 +34,8 @@ y(0) ////////////////////////////////////////////////////////////
-/// Construct the color from its coordinates
-////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T>::Vector2(T X, T Y) :
+inline Vector2<T>::Vector2(T X, T Y) :
x(X),
y(Y)
{
@@ -48,132 +44,118 @@ y(Y) ////////////////////////////////////////////////////////////
-/// Operator - overload ; returns the opposite of a vector
-////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T> operator -(const Vector2<T>& V)
+template <typename U>
+inline Vector2<T>::Vector2(const Vector2<U>& vector) :
+x(static_cast<T>(vector.x)),
+y(static_cast<T>(vector.y))
{
- return Vector2<T>(-V.x, -V.y);
}
////////////////////////////////////////////////////////////
-/// Operator += overload ; add two vectors and assign to the first op
+template <typename T>
+inline Vector2<T> operator -(const Vector2<T>& right)
+{
+ return Vector2<T>(-right.x, -right.y);
+}
+
+
////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T>& operator +=(Vector2<T>& V1, const Vector2<T>& V2)
+inline Vector2<T>& operator +=(Vector2<T>& left, const Vector2<T>& right)
{
- V1.x += V2.x;
- V1.y += V2.y;
+ left.x += right.x;
+ left.y += right.y;
- return V1;
+ return left;
}
////////////////////////////////////////////////////////////
-/// Operator -= overload ; subtract two vectors and assign to the first op
-////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T>& operator -=(Vector2<T>& V1, const Vector2<T>& V2)
+inline Vector2<T>& operator -=(Vector2<T>& left, const Vector2<T>& right)
{
- V1.x -= V2.x;
- V1.y -= V2.y;
+ left.x -= right.x;
+ left.y -= right.y;
- return V1;
+ return left;
}
////////////////////////////////////////////////////////////
-/// Operator + overload ; adds two vectors
-////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T> operator +(const Vector2<T>& V1, const Vector2<T>& V2)
+inline Vector2<T> operator +(const Vector2<T>& left, const Vector2<T>& right)
{
- return Vector2<T>(V1.x + V2.x, V1.y + V2.y);
+ return Vector2<T>(left.x + right.x, left.y + right.y);
}
////////////////////////////////////////////////////////////
-/// Operator - overload ; subtracts two vectors
-////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T> operator -(const Vector2<T>& V1, const Vector2<T>& V2)
+inline Vector2<T> operator -(const Vector2<T>& left, const Vector2<T>& right)
{
- return Vector2<T>(V1.x - V2.x, V1.y - V2.y);
+ return Vector2<T>(left.x - right.x, left.y - right.y);
}
////////////////////////////////////////////////////////////
-/// Operator * overload ; multiply a vector by a scalar value
-////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T> operator *(const Vector2<T>& V, T X)
+inline Vector2<T> operator *(const Vector2<T>& left, T right)
{
- return Vector2<T>(V.x * X, V.y * X);
+ return Vector2<T>(left.x * right, left.y * right);
}
////////////////////////////////////////////////////////////
-/// Operator * overload ; multiply a scalar value by a vector
-////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T> operator *(T X, const Vector2<T>& V)
+inline Vector2<T> operator *(T left, const Vector2<T>& right)
{
- return Vector2<T>(V.x * X, V.y * X);
+ return Vector2<T>(right.x * left, right.y * left);
}
////////////////////////////////////////////////////////////
-/// Operator *= overload ; multiply-assign a vector by a scalar value
-////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T>& operator *=(Vector2<T>& V, T X)
+inline Vector2<T>& operator *=(Vector2<T>& left, T right)
{
- V.x *= X;
- V.y *= X;
+ left.x *= right;
+ left.y *= right;
- return V;
+ return left;
}
////////////////////////////////////////////////////////////
-/// Operator / overload ; divide a vector by a scalar value
-////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T> operator /(const Vector2<T>& V, T X)
+inline Vector2<T> operator /(const Vector2<T>& left, T right)
{
- return Vector2<T>(V.x / X, V.y / X);
+ return Vector2<T>(left.x / right, left.y / right);
}
////////////////////////////////////////////////////////////
-/// Operator /= overload ; divide-assign a vector by a scalar value
-////////////////////////////////////////////////////////////
template <typename T>
-Vector2<T>& operator /=(Vector2<T>& V, T X)
+inline Vector2<T>& operator /=(Vector2<T>& left, T right)
{
- V.x /= X;
- V.y /= X;
+ left.x /= right;
+ left.y /= right;
- return V;
+ return left;
}
////////////////////////////////////////////////////////////
-/// Operator == overload ; compares the equality of two vectors
-////////////////////////////////////////////////////////////
template <typename T>
-bool operator ==(const Vector2<T>& V1, const Vector2<T>& V2)
+inline bool operator ==(const Vector2<T>& left, const Vector2<T>& right)
{
- return (V1.x == V2.x) && (V1.y == V2.y);
+ return (left.x == right.x) && (left.y == right.y);
}
////////////////////////////////////////////////////////////
-/// Operator != overload ; compares the difference of two vectors
-////////////////////////////////////////////////////////////
template <typename T>
-bool operator !=(const Vector2<T>& V1, const Vector2<T>& V2)
+inline bool operator !=(const Vector2<T>& left, const Vector2<T>& right)
{
- return (V1.x != V2.x) || (V1.y != V2.y);
+ return (left.x != right.x) || (left.y != right.y);
}
diff --git a/include/SFML/System/Vector3.hpp b/include/SFML/System/Vector3.hpp index 6ab4b84..76a26cb 100755..100644 --- a/include/SFML/System/Vector3.hpp +++ b/include/SFML/System/Vector3.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -29,9 +29,9 @@ namespace sf
{
////////////////////////////////////////////////////////////
-/// Vector3 is an utility class for manipulating 3 dimensional
-/// vectors. Template parameter defines the type of coordinates
-/// (integer, float, ...)
+/// \brief Utility template class for manipulating
+/// 3-dimensional vectors
+///
////////////////////////////////////////////////////////////
template <typename T>
class Vector3
@@ -39,22 +39,38 @@ class Vector3 public :
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
+ ///
+ /// Creates a Vector3(0, 0, 0).
///
////////////////////////////////////////////////////////////
Vector3();
////////////////////////////////////////////////////////////
- /// Construct the vector from its coordinates
+ /// \brief Construct the vector from its coordinates
///
- /// \param X : X coordinate
- /// \param Y : Y coordinate
- /// \param Z : Z coordinate
+ /// \param X X coordinate
+ /// \param Y Y coordinate
+ /// \param Z Z coordinate
///
////////////////////////////////////////////////////////////
Vector3(T X, T Y, T Z);
////////////////////////////////////////////////////////////
+ /// \brief Construct the vector from another type of vector
+ ///
+ /// This constructor doesn't replace the copy constructor,
+ /// it's called only when U != T.
+ /// A call to this constructor will fail to compile if U
+ /// is not convertible to T.
+ ///
+ /// \param vector Vector to convert
+ ///
+ ////////////////////////////////////////////////////////////
+ template <typename U>
+ explicit Vector3(const Vector3<U>& vector);
+
+ ////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
T x; ///< X coordinate of the vector
@@ -63,147 +79,175 @@ public : };
////////////////////////////////////////////////////////////
-/// Operator - overload ; returns the opposite of a vector
+/// \relates Vector3
+/// \brief Overload of unary operator -
///
-/// \param V : Vector to negate
+/// \param left Vector to negate
///
-/// \return -V
+/// \return Memberwise opposite of the vector
///
////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T> operator -(const Vector3<T>& V);
+Vector3<T> operator -(const Vector3<T>& left);
////////////////////////////////////////////////////////////
-/// Operator += overload ; add two vectors and assign to the first op
+/// \relates Vector3
+/// \brief Overload of binary operator +=
+///
+/// This operator performs a memberwise addition of both vectors,
+/// and assigns the result to \a left.
///
-/// \param V1 : First vector
-/// \param V2 : Second vector
+/// \param left Left operand (a vector)
+/// \param right Right operand (a vector)
///
-/// \return V1 + V2
+/// \return Reference to \a left
///
////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T>& operator +=(Vector3<T>& V1, const Vector3<T>& V2);
+Vector3<T>& operator +=(Vector3<T>& left, const Vector3<T>& right);
////////////////////////////////////////////////////////////
-/// Operator -= overload ; subtract two vectors and assign to the first op
+/// \relates Vector3
+/// \brief Overload of binary operator -=
///
-/// \param V1 : First vector
-/// \param V2 : Second vector
+/// This operator performs a memberwise subtraction of both vectors,
+/// and assigns the result to \a left.
///
-/// \return V1 - V2
+/// \param left Left operand (a vector)
+/// \param right Right operand (a vector)
+///
+/// \return Reference to \a left
///
////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T>& operator -=(Vector3<T>& V1, const Vector3<T>& V2);
+Vector3<T>& operator -=(Vector3<T>& left, const Vector3<T>& right);
////////////////////////////////////////////////////////////
-/// Operator + overload ; adds two vectors
+/// \relates Vector3
+/// \brief Overload of binary operator +
///
-/// \param V1 : First vector
-/// \param V2 : Second vector
+/// \param left Left operand (a vector)
+/// \param right Right operand (a vector)
///
-/// \return V1 + V2
+/// \return Memberwise addition of both vectors
///
////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T> operator +(const Vector3<T>& V1, const Vector3<T>& V2);
+Vector3<T> operator +(const Vector3<T>& left, const Vector3<T>& right);
////////////////////////////////////////////////////////////
-/// Operator - overload ; subtracts two vectors
+/// \relates Vector3
+/// \brief Overload of binary operator -
///
-/// \param V1 : First vector
-/// \param V2 : Second vector
+/// \param left Left operand (a vector)
+/// \param right Right operand (a vector)
///
-/// \return V1 - V2
+/// \return Memberwise subtraction of both vectors
///
////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T> operator -(const Vector3<T>& V1, const Vector3<T>& V2);
+Vector3<T> operator -(const Vector3<T>& left, const Vector3<T>& right);
////////////////////////////////////////////////////////////
-/// Operator * overload ; multiply a vector by a scalar value
+/// \relates Vector3
+/// \brief Overload of binary operator *
///
-/// \param V : Vector
-/// \param X : Scalar value
+/// \param left Left operand (a vector)
+/// \param right Right operand (a scalar value)
///
-/// \return V * X
+/// \return Memberwise multiplication by \a right
///
////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T> operator *(const Vector3<T>& V, T X);
+Vector3<T> operator *(const Vector3<T>& left, T right);
////////////////////////////////////////////////////////////
-/// Operator * overload ; multiply a scalar value by a vector
+/// \relates Vector3
+/// \brief Overload of binary operator *
///
-/// \param X : Scalar value
-/// \param V : Vector
+/// \param left Left operand (a scalar value)
+/// \param right Right operand (a vector)
///
-/// \return X * V
+/// \return Memberwise multiplication by \a left
///
////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T> operator *(T X, const Vector3<T>& V);
+Vector3<T> operator *(T left, const Vector3<T>& right);
////////////////////////////////////////////////////////////
-/// Operator *= overload ; multiply-assign a vector by a scalar value
+/// \relates Vector3
+/// \brief Overload of binary operator *=
+///
+/// This operator performs a memberwise multiplication by \a right,
+/// and assigns the result to \a left.
///
-/// \param V : Vector
-/// \param X : Scalar value
+/// \param left Left operand (a vector)
+/// \param right Right operand (a scalar value)
///
-/// \return V * X
+/// \return Reference to \a left
///
////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T>& operator *=(Vector3<T>& V, T X);
+Vector3<T>& operator *=(Vector3<T>& left, T right);
////////////////////////////////////////////////////////////
-/// Operator / overload ; divide a vector by a scalar value
+/// \relates Vector3
+/// \brief Overload of binary operator /
///
-/// \param V : Vector
-/// \param X : Scalar value
+/// \param left Left operand (a vector)
+/// \param right Right operand (a scalar value)
///
-/// \return V / X
+/// \return Memberwise division by \a right
///
////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T> operator /(const Vector3<T>& V, T X);
+Vector3<T> operator /(const Vector3<T>& left, T right);
////////////////////////////////////////////////////////////
-/// Operator /= overload ; divide-assign a vector by a scalar value
+/// \relates Vector3
+/// \brief Overload of binary operator /=
///
-/// \param V : Vector
-/// \param X : Scalar value
+/// This operator performs a memberwise division by \a right,
+/// and assigns the result to \a left.
///
-/// \return V / X
+/// \param left Left operand (a vector)
+/// \param right Right operand (a scalar value)
+///
+/// \return Reference to \a left
///
////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T>& operator /=(Vector3<T>& V, T X);
+Vector3<T>& operator /=(Vector3<T>& left, T right);
////////////////////////////////////////////////////////////
-/// Operator == overload ; compares the equality of two vectors
+/// \relates Vector3
+/// \brief Overload of binary operator ==
+///
+/// This operator compares strict equality between two vectors.
///
-/// \param V1 : First vector
-/// \param V2 : Second vector
+/// \param left Left operand (a vector)
+/// \param right Right operand (a vector)
///
-/// \return True if V1 is equal to V2
+/// \return True if \a left is equal to \a right
///
////////////////////////////////////////////////////////////
template <typename T>
-bool operator ==(const Vector3<T>& V1, const Vector3<T>& V2);
+bool operator ==(const Vector3<T>& left, const Vector3<T>& right);
////////////////////////////////////////////////////////////
-/// Operator != overload ; compares the difference of two vectors
+/// \relates Vector3
+/// \brief Overload of binary operator !=
+///
+/// This operator compares strict difference between two vectors.
///
-/// \param V1 : First vector
-/// \param V2 : Second vector
+/// \param left Left operand (a vector)
+/// \param right Right operand (a vector)
///
-/// \return True if V1 is different than V2
+/// \return True if \a left is not equal to \a right
///
////////////////////////////////////////////////////////////
template <typename T>
-bool operator !=(const Vector3<T>& V1, const Vector3<T>& V2);
+bool operator !=(const Vector3<T>& left, const Vector3<T>& right);
#include <SFML/System/Vector3.inl>
@@ -215,3 +259,44 @@ typedef Vector3<float> Vector3f; #endif // SFML_VECTOR3_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Vector3
+/// \ingroup system
+///
+/// sf::Vector3 is a simple class that defines a mathematical
+/// vector with three coordinates (x, y and z). It can be used to
+/// represent anything that has three dimensions: a size, a point,
+/// a velocity, etc.
+///
+/// The template parameter T is the type of the coordinates. It
+/// can be any type that supports arithmetic operations (+, -, /, *)
+/// and comparisons (==, !=), for example int or float.
+///
+/// You generally don't have to care about the templated form (sf::Vector3<T>),
+/// the most common specializations have special typedefs:
+/// \li sf::Vector3<float> is sf::Vector3f
+/// \li sf::Vector3<int> is sf::Vector3i
+///
+/// The sf::Vector3 class has a small and simple interface, its x and y members
+/// can be accessed directly (there's no accessor like setX(), getX()) and it
+/// contains no mathematical function like dot product, cross product, length, etc.
+///
+/// Usage example:
+/// \code
+/// sf::Vector3f v1(16.5f, 24.f, -8.2f);
+/// v1.x = 18.2f;
+/// float y = v1.y;
+/// float z = v1.z;
+///
+/// sf::Vector3f v2 = v1 * 5.f;
+/// sf::Vector3f v3;
+/// v3 = v1 + v2;
+///
+/// bool different = (v2 != v3);
+/// \endcode
+///
+/// Note: for 2-dimensional vectors, see sf::Vector2.
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/System/Vector3.inl b/include/SFML/System/Vector3.inl index 8594601..cff1a30 100755..100644 --- a/include/SFML/System/Vector3.inl +++ b/include/SFML/System/Vector3.inl @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2012 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -24,10 +24,8 @@ ////////////////////////////////////////////////////////////
-/// Default constructor
-////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T>::Vector3() :
+inline Vector3<T>::Vector3() :
x(0),
y(0),
z(0)
@@ -37,10 +35,8 @@ z(0) ////////////////////////////////////////////////////////////
-/// Construct the color from its coordinates
-////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T>::Vector3(T X, T Y, T Z) :
+inline Vector3<T>::Vector3(T X, T Y, T Z) :
x(X),
y(Y),
z(Z)
@@ -50,136 +46,123 @@ z(Z) ////////////////////////////////////////////////////////////
-/// Operator - overload ; returns the opposite of a vector
-////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T> operator -(const Vector3<T>& V)
+template <typename U>
+inline Vector3<T>::Vector3(const Vector3<U>& vector) :
+x(static_cast<T>(vector.x)),
+y(static_cast<T>(vector.y)),
+z(static_cast<T>(vector.z))
{
- return Vector3<T>(-V.x, -V.y, -V.z);
}
////////////////////////////////////////////////////////////
-/// Operator += overload ; add two vectors and assign to the first op
+template <typename T>
+inline Vector3<T> operator -(const Vector3<T>& left)
+{
+ return Vector3<T>(-left.x, -left.y, -left.z);
+}
+
+
////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T>& operator +=(Vector3<T>& V1, const Vector3<T>& V2)
+inline Vector3<T>& operator +=(Vector3<T>& left, const Vector3<T>& right)
{
- V1.x += V2.x;
- V1.y += V2.y;
- V1.z += V2.z;
+ left.x += right.x;
+ left.y += right.y;
+ left.z += right.z;
- return V1;
+ return left;
}
////////////////////////////////////////////////////////////
-/// Operator -= overload ; subtract two vectors and assign to the first op
-////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T>& operator -=(Vector3<T>& V1, const Vector3<T>& V2)
+inline Vector3<T>& operator -=(Vector3<T>& left, const Vector3<T>& right)
{
- V1.x -= V2.x;
- V1.y -= V2.y;
- V1.z -= V2.z;
+ left.x -= right.x;
+ left.y -= right.y;
+ left.z -= right.z;
- return V1;
+ return left;
}
////////////////////////////////////////////////////////////
-/// Operator + overload ; adds two vectors
-////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T> operator +(const Vector3<T>& V1, const Vector3<T>& V2)
+inline Vector3<T> operator +(const Vector3<T>& left, const Vector3<T>& right)
{
- return Vector3<T>(V1.x + V2.x, V1.y + V2.y, V1.z + V2.z);
+ return Vector3<T>(left.x + right.x, left.y + right.y, left.z + right.z);
}
////////////////////////////////////////////////////////////
-/// Operator - overload ; subtracts two vectors
-////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T> operator -(const Vector3<T>& V1, const Vector3<T>& V2)
+inline Vector3<T> operator -(const Vector3<T>& left, const Vector3<T>& right)
{
- return Vector3<T>(V1.x - V2.x, V1.y - V2.y, V1.z - V2.z);
+ return Vector3<T>(left.x - right.x, left.y - right.y, left.z - right.z);
}
////////////////////////////////////////////////////////////
-/// Operator * overload ; multiply a vector by a scalar value
-////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T> operator *(const Vector3<T>& V, T X)
+inline Vector3<T> operator *(const Vector3<T>& left, T right)
{
- return Vector3<T>(V.x * X, V.y * X, V.z * X);
+ return Vector3<T>(left.x * right, left.y * right, left.z * right);
}
////////////////////////////////////////////////////////////
-/// Operator * overload ; multiply a scalar value by a vector
-////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T> operator *(T X, const Vector3<T>& V)
+inline Vector3<T> operator *(T left, const Vector3<T>& right)
{
- return Vector3<T>(V.x * X, V.y * X, V.z * X);
+ return Vector3<T>(right.x * left, right.y * left, right.z * left);
}
////////////////////////////////////////////////////////////
-/// Operator *= overload ; multiply-assign a vector by a scalar value
-////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T>& operator *=(Vector3<T>& V, T X)
+inline Vector3<T>& operator *=(Vector3<T>& left, T right)
{
- V.x *= X;
- V.y *= X;
- V.z *= X;
+ left.x *= right;
+ left.y *= right;
+ left.z *= right;
- return V;
+ return left;
}
////////////////////////////////////////////////////////////
-/// Operator / overload ; divide a vector by a scalar value
-////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T> operator /(const Vector3<T>& V, T X)
+inline Vector3<T> operator /(const Vector3<T>& left, T right)
{
- return Vector3<T>(V.x / X, V.y / X, V.z / X);
+ return Vector3<T>(left.x / right, left.y / right, left.z / right);
}
////////////////////////////////////////////////////////////
-/// Operator /= overload ; divide-assign a vector by a scalar value
-////////////////////////////////////////////////////////////
template <typename T>
-Vector3<T>& operator /=(Vector3<T>& V, T X)
+inline Vector3<T>& operator /=(Vector3<T>& left, T right)
{
- V.x /= X;
- V.y /= X;
- V.z /= X;
+ left.x /= right;
+ left.y /= right;
+ left.z /= right;
- return V;
+ return left;
}
////////////////////////////////////////////////////////////
-/// Operator == overload ; compares the equality of two vectors
-////////////////////////////////////////////////////////////
template <typename T>
-bool operator ==(const Vector3<T>& V1, const Vector3<T>& V2)
+inline bool operator ==(const Vector3<T>& left, const Vector3<T>& right)
{
- return (V1.x == V2.x) && (V1.y == V2.y) && (V1.z == V2.z);
+ return (left.x == right.x) && (left.y == right.y) && (left.z == right.z);
}
////////////////////////////////////////////////////////////
-/// Operator != overload ; compares the difference of two vectors
-////////////////////////////////////////////////////////////
template <typename T>
-bool operator !=(const Vector3<T>& V1, const Vector3<T>& V2)
+inline bool operator !=(const Vector3<T>& left, const Vector3<T>& right)
{
- return (V1.x != V2.x) || (V1.y != V2.y) || (V1.z != V2.z);
+ return (left.x != right.x) || (left.y != right.y) || (left.z != right.z);
}
diff --git a/include/SFML/System/Win32/Thread.hpp b/include/SFML/System/Win32/Thread.hpp deleted file mode 100755 index f44dfe1..0000000 --- a/include/SFML/System/Win32/Thread.hpp +++ /dev/null @@ -1,123 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_THREADWIN32_HPP
-#define SFML_THREADWIN32_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/System/NonCopyable.hpp>
-#include <windows.h>
-
-
-namespace sf
-{
-////////////////////////////////////////////////////////////
-/// Thread defines an easy way to manipulate a thread.
-/// There are two ways to use Thread :
-/// - Inherit from it and override the Run() virtual function
-/// - Construct a Thread instance and pass it a function
-/// pointer to call
-////////////////////////////////////////////////////////////
-class SFML_API Thread : NonCopyable
-{
-public :
-
- typedef void (*FuncType)(void*);
-
- ////////////////////////////////////////////////////////////
- /// Construct the thread from a function pointer
- ///
- /// \param Function : Entry point of the thread
- /// \param UserData : Data to pass to the thread function (NULL by default)
- ///
- ////////////////////////////////////////////////////////////
- Thread(FuncType Function, void* UserData = NULL);
-
- ////////////////////////////////////////////////////////////
- /// Virtual destructor
- ///
- ////////////////////////////////////////////////////////////
- virtual ~Thread();
-
- ////////////////////////////////////////////////////////////
- /// Create and run the thread
- ///
- ////////////////////////////////////////////////////////////
- void Launch();
-
- ////////////////////////////////////////////////////////////
- /// Wait until the thread finishes
- ///
- ////////////////////////////////////////////////////////////
- void Wait();
-
- ////////////////////////////////////////////////////////////
- /// Terminate the thread
- /// Terminating a thread with this function is not safe,
- /// you should rather try to make the thread function
- /// terminate by itself
- ///
- ////////////////////////////////////////////////////////////
- void Terminate();
-
-protected :
-
- ////////////////////////////////////////////////////////////
- /// Default constructor
- ///
- ////////////////////////////////////////////////////////////
- Thread();
-
-private :
-
- ////////////////////////////////////////////////////////////
- /// Function called as the thread entry point
- ///
- ////////////////////////////////////////////////////////////
- virtual void Run();
-
- ////////////////////////////////////////////////////////////
- /// Actual thread entry point, dispatches to instances
- ///
- /// \param UserData : Data to pass to the thread function
- ///
- /// \return Error code
- ///
- ////////////////////////////////////////////////////////////
- static unsigned int __stdcall ThreadFunc(void* UserData);
-
- ////////////////////////////////////////////////////////////
- // Member data
- ////////////////////////////////////////////////////////////
- HANDLE myHandle; ///< Win32 thread handle
- FuncType myFunction; ///< Function to call as the thread entry point
- void* myUserData; ///< Data to pass to the thread function
-};
-
-} // namespace sf
-
-
-#endif // SFML_THREADWIN32_HPP
diff --git a/include/SFML/Window.hpp b/include/SFML/Window.hpp index 3a516a0..5d51134 100755..100644 --- a/include/SFML/Window.hpp +++ b/include/SFML/Window.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -31,13 +31,22 @@ #include <SFML/System.hpp>
#include <SFML/Window/Context.hpp>
+#include <SFML/Window/ContextSettings.hpp>
#include <SFML/Window/Event.hpp>
-#include <SFML/Window/Input.hpp>
+#include <SFML/Window/Joystick.hpp>
+#include <SFML/Window/Keyboard.hpp>
+#include <SFML/Window/Mouse.hpp>
#include <SFML/Window/VideoMode.hpp>
#include <SFML/Window/Window.hpp>
-#include <SFML/Window/WindowListener.hpp>
#include <SFML/Window/WindowStyle.hpp>
-#include <SFML/Window/OpenGL.hpp>
#endif // SFML_SFML_WINDOW_HPP
+
+////////////////////////////////////////////////////////////
+/// \defgroup window Window module
+///
+/// Provides OpenGL-based windows, and abstractions for
+/// events and input handling.
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Window/Context.hpp b/include/SFML/Window/Context.hpp index fede21c..5f67164 100755..100644 --- a/include/SFML/Window/Context.hpp +++ b/include/SFML/Window/Context.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,7 +28,9 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
+#include <SFML/Window/Export.hpp>
+#include <SFML/Window/GlResource.hpp>
+#include <SFML/Window/ContextSettings.hpp>
#include <SFML/System/NonCopyable.hpp>
@@ -36,65 +38,103 @@ namespace sf {
namespace priv
{
- class WindowImpl;
+ class GlContext;
}
////////////////////////////////////////////////////////////
-/// Class wrapping an OpenGL context.
-/// All SFML windows already have their own context, so
-/// this class is more a helper for specific issues involving
-/// OpenGL and multi-threading.
-/// It's meant to be used internally.
+/// \brief Class holding a valid drawing context
+///
////////////////////////////////////////////////////////////
-class SFML_API Context : NonCopyable
+class SFML_WINDOW_API Context : GlResource, NonCopyable
{
public :
////////////////////////////////////////////////////////////
- /// Default constructor, create the context
+ /// \brief Default constructor
+ ///
+ /// The constructor creates and activates the context
///
////////////////////////////////////////////////////////////
Context();
////////////////////////////////////////////////////////////
- /// Destructor, destroy the context
+ /// \brief Destructor
+ ///
+ /// The desctructor deactivates and destroys the context
///
////////////////////////////////////////////////////////////
~Context();
////////////////////////////////////////////////////////////
- /// Activate or deactivate the context
- ///
- /// \param Active : True to activate the context, false to deactivate it
+ /// \brief Activate or deactivate explicitely the context
///
- ////////////////////////////////////////////////////////////
- void SetActive(bool Active);
-
- ////////////////////////////////////////////////////////////
- /// Check if there's a context bound to the current thread
+ /// \param active True to activate, false to deactivate
///
- /// \return True if there's a context bound to the current thread
+ /// \return True on success, false on failure
///
////////////////////////////////////////////////////////////
- static bool IsContextActive();
+ bool setActive(bool active);
+
+public :
////////////////////////////////////////////////////////////
- /// Get the global context
+ /// \brief Construct a in-memory context
+ ///
+ /// This constructor is for internal use, you don't need
+ /// to bother with it.
///
- /// \return Reference to the global context
+ /// \param settings Creation parameters
+ /// \param width Back buffer width
+ /// \param height Back buffer height
///
////////////////////////////////////////////////////////////
- static Context& GetGlobal();
+ Context(const ContextSettings& settings, unsigned int width, unsigned int height);
private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- priv::WindowImpl* myDummyWindow; ///< Dummy window holding the context
+ priv::GlContext* m_context; ///< Internal OpenGL context
};
} // namespace sf
#endif // SFML_CONTEXT_HPP
+
+////////////////////////////////////////////////////////////
+/// \class sf::Context
+/// \ingroup window
+///
+/// If you need to make OpenGL calls without having an
+/// active window (like in a thread), you can use an
+/// instance of this class to get a valid context.
+///
+/// Having a valid context is necessary for *every* OpenGL call.
+///
+/// Note that a context is only active in its current thread,
+/// if you create a new thread it will have no valid context
+/// by default.
+///
+/// To use a sf::Context instance, just construct it and let it
+/// live as long as you need a valid context. No explicit activation
+/// is needed, all it has to do is to exist. Its destructor
+/// will take care of deactivating and freeing all the attached
+/// resources.
+///
+/// Usage example:
+/// \code
+/// void threadFunction(void*)
+/// {
+/// sf::Context context;
+/// // from now on, you have a valid context
+///
+/// // you can make OpenGL calls
+/// glClear(GL_DEPTH_BUFFER_BIT);
+/// }
+/// // the context is automatically deactivated and destroyed
+/// // by the sf::Context destructor
+/// \endcode
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Window/ContextSettings.hpp b/include/SFML/Window/ContextSettings.hpp new file mode 100644 index 0000000..1bd2b3e --- /dev/null +++ b/include/SFML/Window/ContextSettings.hpp @@ -0,0 +1,104 @@ +////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+// you must not claim that you wrote the original software.
+// If you use this software in a product, an acknowledgment
+// in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+// and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_CONTEXTSETTINGS_HPP
+#define SFML_CONTEXTSETTINGS_HPP
+
+
+namespace sf
+{
+////////////////////////////////////////////////////////////
+/// \brief Structure defining the settings of the OpenGL
+/// context attached to a window
+///
+////////////////////////////////////////////////////////////
+struct ContextSettings
+{
+ ////////////////////////////////////////////////////////////
+ /// \brief Default constructor
+ ///
+ /// \param depth Depth buffer bits
+ /// \param stencil Stencil buffer bits
+ /// \param antialiasing Antialiasing level
+ /// \param major Major number of the context version
+ /// \param minor Minor number of the context version
+ ///
+ ////////////////////////////////////////////////////////////
+ explicit ContextSettings(unsigned int depth = 0, unsigned int stencil = 0, unsigned int antialiasing = 0, unsigned int major = 2, unsigned int minor = 0) :
+ depthBits (depth),
+ stencilBits (stencil),
+ antialiasingLevel(antialiasing),
+ majorVersion (major),
+ minorVersion (minor)
+ {
+ }
+
+ ////////////////////////////////////////////////////////////
+ // Member data
+ ////////////////////////////////////////////////////////////
+ unsigned int depthBits; ///< Bits of the depth buffer
+ unsigned int stencilBits; ///< Bits of the stencil buffer
+ unsigned int antialiasingLevel; ///< Level of antialiasing
+ unsigned int majorVersion; ///< Major number of the context version to create
+ unsigned int minorVersion; ///< Minor number of the context version to create
+};
+
+} // namespace sf
+
+
+#endif // SFML_CONTEXTSETTINGS_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::ContextSettings
+/// \ingroup window
+///
+/// ContextSettings allows to define several advanced settings
+/// of the OpenGL context attached to a window. All these
+/// settings have no impact on the regular SFML rendering
+/// (graphics module) -- except the anti-aliasing level, so
+/// you may need to use this structure only if you're using
+/// SFML as a windowing system for custom OpenGL rendering.
+///
+/// The depthBits and stencilBits members define the number
+/// of bits per pixel requested for the (respectively) depth
+/// and stencil buffers.
+///
+/// antialiasingLevel represents the requested number of
+/// multisampling levels for anti-aliasing.
+///
+/// majorVersion and minorVersion define the version of the
+/// OpenGL context that you want. Only versions greater or
+/// equal to 3.0 are relevant; versions lesser than 3.0 are
+/// all handled the same way (i.e. you can use any version
+/// < 3.0 if you don't want an OpenGL 3 context).
+///
+/// Please note that these values are only a hint.
+/// No failure will be reported if one or more of these values
+/// are not supported by the system; instead, SFML will try to
+/// find the closest valid match. You can then retrieve the
+/// settings that the window actually used to create its context,
+/// with Window::getSettings().
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Window/Event.hpp b/include/SFML/Window/Event.hpp index 35ac575..e86c2bf 100755..100644 --- a/include/SFML/Window/Event.hpp +++ b/include/SFML/Window/Event.hpp @@ -1,321 +1,237 @@ -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -#ifndef SFML_EVENT_HPP -#define SFML_EVENT_HPP - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#include <SFML/Config.hpp> - - -namespace sf -{ -//////////////////////////////////////////////////////////// -/// Definition of key codes for keyboard events -//////////////////////////////////////////////////////////// -namespace Key -{ - enum Code - { - A = 'a', - B = 'b', - C = 'c', - D = 'd', - E = 'e', - F = 'f', - G = 'g', - H = 'h', - I = 'i', - J = 'j', - K = 'k', - L = 'l', - M = 'm', - N = 'n', - O = 'o', - P = 'p', - Q = 'q', - R = 'r', - S = 's', - T = 't', - U = 'u', - V = 'v', - W = 'w', - X = 'x', - Y = 'y', - Z = 'z', - Num0 = '0', - Num1 = '1', - Num2 = '2', - Num3 = '3', - Num4 = '4', - Num5 = '5', - Num6 = '6', - Num7 = '7', - Num8 = '8', - Num9 = '9', - Escape = 256, - LControl, - LShift, - LAlt, - LSystem, ///< OS specific key (left side) : windows (Win and Linux), apple (MacOS), ... - RControl, - RShift, - RAlt, - RSystem, ///< OS specific key (right side) : windows (Win and Linux), apple (MacOS), ... - Menu, - LBracket, ///< [ - RBracket, ///< ] - SemiColon, ///< ; - Comma, ///< , - Period, ///< . - Quote, ///< ' - Slash, ///< / - BackSlash, - Tilde, ///< ~ - Equal, ///< = - Dash, ///< - - Space, - Return, - Back, - Tab, - PageUp, - PageDown, - End, - Home, - Insert, - Delete, - Add, ///< + - Subtract, ///< - - Multiply, ///< * - Divide, ///< / - Left, ///< Left arrow - Right, ///< Right arrow - Up, ///< Up arrow - Down, ///< Down arrow - Numpad0, - Numpad1, - Numpad2, - Numpad3, - Numpad4, - Numpad5, - Numpad6, - Numpad7, - Numpad8, - Numpad9, - F1, - F2, - F3, - F4, - F5, - F6, - F7, - F8, - F9, - F10, - F11, - F12, - F13, - F14, - F15, - Pause, - - Count // Keep last -- total number of keyboard keys - }; -} - - -//////////////////////////////////////////////////////////// -/// Definition of button codes for mouse events -//////////////////////////////////////////////////////////// -namespace Mouse -{ - enum Button - { - Left, - Right, - Middle, - XButton1, - XButton2, - - ButtonCount // Keep last -- total number of mouse buttons - }; -} - - -//////////////////////////////////////////////////////////// -/// Definition of joystick axis for joystick events -//////////////////////////////////////////////////////////// -namespace Joy -{ - enum Axis - { - AxisX, - AxisY, - AxisZ, - AxisR, - AxisU, - AxisV, - AxisPOV, - - AxisCount // Keep last -- total number of joystick axis - }; - - enum - { - Count = 4, ///< Total number of supported joysticks - ButtonCount = 32 ///< Total number of supported joystick buttons - }; -} - - -//////////////////////////////////////////////////////////// -/// Event defines a system event and its parameters -//////////////////////////////////////////////////////////// -class Event -{ -public : - - //////////////////////////////////////////////////////////// - /// Keyboard event parameters - //////////////////////////////////////////////////////////// - struct KeyEvent - { - Key::Code Code; - bool Alt; - bool Control; - bool Shift; - }; - - //////////////////////////////////////////////////////////// - /// Text event parameters - //////////////////////////////////////////////////////////// - struct TextEvent - { - Uint32 Unicode; - }; - - //////////////////////////////////////////////////////////// - /// Mouse move event parameters - //////////////////////////////////////////////////////////// - struct MouseMoveEvent - { - int X; - int Y; - }; - - //////////////////////////////////////////////////////////// - /// Mouse buttons events parameters - //////////////////////////////////////////////////////////// - struct MouseButtonEvent - { - Mouse::Button Button; - int X; - int Y; - }; - - //////////////////////////////////////////////////////////// - /// Mouse wheel events parameters - //////////////////////////////////////////////////////////// - struct MouseWheelEvent - { - int Delta; - }; - - //////////////////////////////////////////////////////////// - /// Joystick axis move event parameters - //////////////////////////////////////////////////////////// - struct JoyMoveEvent - { - unsigned int JoystickId; - Joy::Axis Axis; - float Position; - }; - - //////////////////////////////////////////////////////////// - /// Joystick buttons events parameters - //////////////////////////////////////////////////////////// - struct JoyButtonEvent - { - unsigned int JoystickId; - unsigned int Button; - }; - - //////////////////////////////////////////////////////////// - /// Size events parameters - //////////////////////////////////////////////////////////// - struct SizeEvent - { - unsigned int Width; - unsigned int Height; - }; - - //////////////////////////////////////////////////////////// - /// Enumeration of the different types of events - //////////////////////////////////////////////////////////// - enum EventType - { - Closed, - Resized, - LostFocus, - GainedFocus, - TextEntered, - KeyPressed, - KeyReleased, - MouseWheelMoved, - MouseButtonPressed, - MouseButtonReleased, - MouseMoved, - MouseEntered, - MouseLeft, - JoyButtonPressed, - JoyButtonReleased, - JoyMoved, - - Count // Keep last -- total number of event types - }; - - //////////////////////////////////////////////////////////// - // Member data - //////////////////////////////////////////////////////////// - EventType Type; ///< Type of the event - - union - { - KeyEvent Key; - TextEvent Text; - MouseMoveEvent MouseMove; - MouseButtonEvent MouseButton; - MouseWheelEvent MouseWheel; - JoyMoveEvent JoyMove; - JoyButtonEvent JoyButton; - SizeEvent Size; - }; -}; - -} // namespace sf - - -#endif // SFML_EVENT_HPP +////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+// you must not claim that you wrote the original software.
+// If you use this software in a product, an acknowledgment
+// in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+// and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_EVENT_HPP
+#define SFML_EVENT_HPP
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Config.hpp>
+#include <SFML/Window/Joystick.hpp>
+#include <SFML/Window/Keyboard.hpp>
+#include <SFML/Window/Mouse.hpp>
+
+
+namespace sf
+{
+////////////////////////////////////////////////////////////
+/// \brief Defines a system event and its parameters
+///
+////////////////////////////////////////////////////////////
+class Event
+{
+public :
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Size events parameters (Resized)
+ ///
+ ////////////////////////////////////////////////////////////
+ struct SizeEvent
+ {
+ unsigned int width; ///< New width, in pixels
+ unsigned int height; ///< New height, in pixels
+ };
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Keyboard event parameters (KeyPressed, KeyReleased)
+ ///
+ ////////////////////////////////////////////////////////////
+ struct KeyEvent
+ {
+ Keyboard::Key code; ///< Code of the key that has been pressed
+ bool alt; ///< Is the Alt key pressed?
+ bool control; ///< Is the Control key pressed?
+ bool shift; ///< Is the Shift key pressed?
+ bool system; ///< Is the System key pressed?
+ };
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Text event parameters (TextEntered)
+ ///
+ ////////////////////////////////////////////////////////////
+ struct TextEvent
+ {
+ Uint32 unicode; ///< UTF-32 unicode value of the character
+ };
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Mouse move event parameters (MouseMoved)
+ ///
+ ////////////////////////////////////////////////////////////
+ struct MouseMoveEvent
+ {
+ int x; ///< X position of the mouse pointer, relative to the left of the owner window
+ int y; ///< Y position of the mouse pointer, relative to the top of the owner window
+ };
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Mouse buttons events parameters
+ /// (MouseButtonPressed, MouseButtonReleased)
+ ///
+ ////////////////////////////////////////////////////////////
+ struct MouseButtonEvent
+ {
+ Mouse::Button button; ///< Code of the button that has been pressed
+ int x; ///< X position of the mouse pointer, relative to the left of the owner window
+ int y; ///< Y position of the mouse pointer, relative to the top of the owner window
+ };
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Mouse wheel events parameters (MouseWheelMoved)
+ ///
+ ////////////////////////////////////////////////////////////
+ struct MouseWheelEvent
+ {
+ int delta; ///< Number of ticks the wheel has moved (positive is up, negative is down)
+ int x; ///< X position of the mouse pointer, relative to the left of the owner window
+ int y; ///< Y position of the mouse pointer, relative to the top of the owner window
+ };
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Joystick connection events parameters
+ /// (JoystickConnected, JoystickDisconnected)
+ ///
+ ////////////////////////////////////////////////////////////
+ struct JoystickConnectEvent
+ {
+ unsigned int joystickId; ///< Index of the joystick (in range [0 .. Joystick::Count - 1])
+ };
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Joystick axis move event parameters (JoystickMoved)
+ ///
+ ////////////////////////////////////////////////////////////
+ struct JoystickMoveEvent
+ {
+ unsigned int joystickId; ///< Index of the joystick (in range [0 .. Joystick::Count - 1])
+ Joystick::Axis axis; ///< Axis on which the joystick moved
+ float position; ///< New position on the axis (in range [-100 .. 100])
+ };
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Joystick buttons events parameters
+ /// (JoystickButtonPressed, JoystickButtonReleased)
+ ///
+ ////////////////////////////////////////////////////////////
+ struct JoystickButtonEvent
+ {
+ unsigned int joystickId; ///< Index of the joystick (in range [0 .. Joystick::Count - 1])
+ unsigned int button; ///< Index of the button that has been pressed (in range [0 .. Joystick::ButtonCount - 1])
+ };
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Enumeration of the different types of events
+ ///
+ ////////////////////////////////////////////////////////////
+ enum EventType
+ {
+ Closed, ///< The window requested to be closed (no data)
+ Resized, ///< The window was resized (data in event.size)
+ LostFocus, ///< The window lost the focus (no data)
+ GainedFocus, ///< The window gained the focus (no data)
+ TextEntered, ///< A character was entered (data in event.text)
+ KeyPressed, ///< A key was pressed (data in event.key)
+ KeyReleased, ///< A key was released (data in event.key)
+ MouseWheelMoved, ///< The mouse wheel was scrolled (data in event.mouseWheel)
+ MouseButtonPressed, ///< A mouse button was pressed (data in event.mouseButton)
+ MouseButtonReleased, ///< A mouse button was released (data in event.mouseButton)
+ MouseMoved, ///< The mouse cursor moved (data in event.mouseMove)
+ MouseEntered, ///< The mouse cursor entered the area of the window (no data)
+ MouseLeft, ///< The mouse cursor left the area of the window (no data)
+ JoystickButtonPressed, ///< A joystick button was pressed (data in event.joystickButton)
+ JoystickButtonReleased, ///< A joystick button was released (data in event.joystickButton)
+ JoystickMoved, ///< The joystick moved along an axis (data in event.joystickMove)
+ JoystickConnected, ///< A joystick was connected (data in event.joystickConnect)
+ JoystickDisconnected, ///< A joystick was disconnected (data in event.joystickConnect)
+
+ Count ///< Keep last -- the total number of event types
+ };
+
+ ////////////////////////////////////////////////////////////
+ // Member data
+ ////////////////////////////////////////////////////////////
+ EventType type; ///< Type of the event
+
+ union
+ {
+ SizeEvent size; ///< Size event parameters (Event::Resized)
+ KeyEvent key; ///< Key event parameters (Event::KeyPressed, Event::KeyReleased)
+ TextEvent text; ///< Text event parameters (Event::TextEntered)
+ MouseMoveEvent mouseMove; ///< Mouse move event parameters (Event::MouseMoved)
+ MouseButtonEvent mouseButton; ///< Mouse button event parameters (Event::MouseButtonPressed, Event::MouseButtonReleased)
+ MouseWheelEvent mouseWheel; ///< Mouse wheel event parameters (Event::MouseWheelMoved)
+ JoystickMoveEvent joystickMove; ///< Joystick move event parameters (Event::JoystickMoved)
+ JoystickButtonEvent joystickButton; ///< Joystick button event parameters (Event::JoystickButtonPressed, Event::JoystickButtonReleased)
+ JoystickConnectEvent joystickConnect; ///< Joystick (dis)connect event parameters (Event::JoystickConnected, Event::JoystickDisconnected)
+ };
+};
+
+} // namespace sf
+
+
+#endif // SFML_EVENT_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Event
+/// \ingroup window
+///
+/// sf::Event holds all the informations about a system event
+/// that just happened. Events are retrieved using the
+/// sf::Window::pollEvent and sf::Window::waitEvent functions.
+///
+/// A sf::Event instance contains the type of the event
+/// (mouse moved, key pressed, window closed, ...) as well
+/// as the details about this particular event. Please note that
+/// the event parameters are defined in a union, which means that
+/// only the member matching the type of the event will be properly
+/// filled; all other members will have undefined values and must not
+/// be read if the type of the event doesn't match. For example,
+/// if you received a KeyPressed event, then you must read the
+/// event.key member, all other members such as event.MouseMove
+/// or event.text will have undefined values.
+///
+/// Usage example:
+/// \code
+/// sf::Event event;
+/// while (window.pollEvent(event))
+/// {
+/// // Request for closing the window
+/// if (event.type == sf::Event::Closed)
+/// window.close();
+///
+/// // The escape key was pressed
+/// if ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Escape))
+/// window.close();
+///
+/// // The window was resized
+/// if (event.type == sf::Event::Resized)
+/// doSomethingWithTheNewSize(event.size.width, event.size.height);
+///
+/// // etc ...
+/// }
+/// \endcode
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Window/Export.hpp b/include/SFML/Window/Export.hpp new file mode 100644 index 0000000..ff06576 --- /dev/null +++ b/include/SFML/Window/Export.hpp @@ -0,0 +1,48 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_WINDOW_EXPORT_HPP +#define SFML_WINDOW_EXPORT_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Config.hpp> + + +//////////////////////////////////////////////////////////// +// Define portable import / export macros +//////////////////////////////////////////////////////////// +#if defined(SFML_WINDOW_EXPORTS) + + #define SFML_WINDOW_API SFML_API_EXPORT + +#else + + #define SFML_WINDOW_API SFML_API_IMPORT + +#endif + + +#endif // SFML_WINDOW_EXPORT_HPP diff --git a/include/SFML/Audio/AudioResource.hpp b/include/SFML/Window/GlResource.hpp index 410466d..560a637 100755..100644 --- a/include/SFML/Audio/AudioResource.hpp +++ b/include/SFML/Window/GlResource.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -22,46 +22,55 @@ //
////////////////////////////////////////////////////////////
-#ifndef SFML_AUDIORESOURCE_HPP
-#define SFML_AUDIORESOURCE_HPP
+#ifndef SFML_GLRESOURCE_HPP
+#define SFML_GLRESOURCE_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
+#include <SFML/Window/Export.hpp>
namespace sf
{
////////////////////////////////////////////////////////////
-/// Abstract base class for every class that owns a
-/// device-dependant resource -- allow them to initialize / shutdown
-/// even when the audio context is not created
+/// \brief Base class for classes that require an OpenGL context
+///
////////////////////////////////////////////////////////////
-class SFML_API AudioResource
+class SFML_WINDOW_API GlResource
{
protected :
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
///
////////////////////////////////////////////////////////////
- AudioResource();
+ GlResource();
////////////////////////////////////////////////////////////
- /// Copy constructor
+ /// \brief Destructor
///
////////////////////////////////////////////////////////////
- AudioResource(const AudioResource&);
+ ~GlResource();
////////////////////////////////////////////////////////////
- /// Destructor
+ /// \brief Make sure that a valid OpenGL context exists in the current thread
///
////////////////////////////////////////////////////////////
- virtual ~AudioResource();
+ static void ensureGlContext();
};
} // namespace sf
-#endif // SFML_AUDIORESOURCE_HPP
+#endif // SFML_GLRESOURCE_HPP
+
+////////////////////////////////////////////////////////////
+/// \class sf::GlResource
+/// \ingroup window
+///
+/// This class is for internal use only, it must be the base
+/// of every class that requires a valid OpenGL context in
+/// order to work.
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Window/Input.hpp b/include/SFML/Window/Input.hpp deleted file mode 100755 index e9e9c5e..0000000 --- a/include/SFML/Window/Input.hpp +++ /dev/null @@ -1,140 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_INPUT_HPP
-#define SFML_INPUT_HPP
-
-////////////////////////////////////////////////////////////
-// Headers
-////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
-#include <SFML/System/NonCopyable.hpp>
-#include <SFML/Window/Event.hpp>
-#include <SFML/Window/WindowListener.hpp>
-
-
-namespace sf
-{
-////////////////////////////////////////////////////////////
-/// Input handles real-time input from keyboard and mouse.
-/// Use it instead of events to handle continuous moves and more
-/// game-friendly inputs
-////////////////////////////////////////////////////////////
-class SFML_API Input : public WindowListener, NonCopyable
-{
-public :
-
- ////////////////////////////////////////////////////////////
- /// Default constructor
- ///
- ////////////////////////////////////////////////////////////
- Input();
-
- ////////////////////////////////////////////////////////////
- /// Get the state of a key
- ///
- /// \param KeyCode : Key to check
- ///
- /// \return True if key is down, false if key is up
- ///
- ////////////////////////////////////////////////////////////
- bool IsKeyDown(Key::Code KeyCode) const;
-
- ////////////////////////////////////////////////////////////
- /// Get the state of a mouse button
- ///
- /// \param Button : Button to check
- ///
- /// \return True if button is down, false if button is up
- ///
- ////////////////////////////////////////////////////////////
- bool IsMouseButtonDown(Mouse::Button Button) const;
-
- ////////////////////////////////////////////////////////////
- /// Get the state of a joystick button
- ///
- /// \param JoyId : Identifier of the joystick to check (0 or 1)
- /// \param Button : Button to check
- ///
- /// \return True if button is down, false if button is up
- ///
- ////////////////////////////////////////////////////////////
- bool IsJoystickButtonDown(unsigned int JoyId, unsigned int Button) const;
-
- ////////////////////////////////////////////////////////////
- /// Get the mouse X position
- ///
- /// \return Current mouse left position, relative to owner window
- ///
- ////////////////////////////////////////////////////////////
- int GetMouseX() const;
-
- ////////////////////////////////////////////////////////////
- /// Get the mouse Y position
- ///
- /// \return Current mouse top position, relative to owner window
- ///
- ////////////////////////////////////////////////////////////
- int GetMouseY() const;
-
- ////////////////////////////////////////////////////////////
- /// Get a joystick axis position
- ///
- /// \param JoyId : Identifier of the joystick to check (0 or 1)
- /// \param Axis : Axis to get
- ///
- /// \return Current axis position, in the range [-100, 100] (except for POV, which is [0, 360])
- ///
- ////////////////////////////////////////////////////////////
- float GetJoystickAxis(unsigned int JoyId, Joy::Axis Axis) const;
-
-private :
-
- ////////////////////////////////////////////////////////////
- /// /see WindowListener::OnEvent
- ///
- ////////////////////////////////////////////////////////////
- virtual void OnEvent(const Event& EventReceived);
-
- ////////////////////////////////////////////////////////////
- /// Reset all the states
- ///
- ////////////////////////////////////////////////////////////
- void ResetStates();
-
- ////////////////////////////////////////////////////////////
- // Member data
- ////////////////////////////////////////////////////////////
- bool myKeys[Key::Count]; ///< Array containing the state of all keyboard keys
- bool myMouseButtons[Mouse::ButtonCount]; ///< Array containing the state of all mouse buttons
- int myMouseX; ///< Mouse position on X
- int myMouseY; ///< Mouse position on Y
- bool myJoystickButtons[Joy::Count][Joy::ButtonCount]; ///< Array containing the state of all joysticks buttons
- float myJoystickAxis[Joy::Count][Joy::AxisCount]; ///< Joysticks position on each axis
-};
-
-} // namespace sf
-
-
-#endif // SFML_INPUT_HPP
diff --git a/include/SFML/Window/Joystick.hpp b/include/SFML/Window/Joystick.hpp new file mode 100644 index 0000000..8e65309 --- /dev/null +++ b/include/SFML/Window/Joystick.hpp @@ -0,0 +1,203 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_JOYSTICK_HPP +#define SFML_JOYSTICK_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Window/Export.hpp> + + +namespace sf +{ +//////////////////////////////////////////////////////////// +/// \brief Give access to the real-time state of the joysticks +/// +//////////////////////////////////////////////////////////// +class SFML_WINDOW_API Joystick +{ +public : + + //////////////////////////////////////////////////////////// + /// \brief Constants related to joysticks capabilities + /// + //////////////////////////////////////////////////////////// + enum + { + Count = 8, ///< Maximum number of supported joysticks + ButtonCount = 32, ///< Maximum number of supported buttons + AxisCount = 8 ///< Maximum number of supported axes + }; + + //////////////////////////////////////////////////////////// + /// \brief Axes supported by SFML joysticks + /// + //////////////////////////////////////////////////////////// + enum Axis + { + X, ///< The X axis + Y, ///< The Y axis + Z, ///< The Z axis + R, ///< The R axis + U, ///< The U axis + V, ///< The V axis + PovX, ///< The X axis of the point-of-view hat + PovY ///< The Y axis of the point-of-view hat + }; + + //////////////////////////////////////////////////////////// + /// \brief Check if a joystick is connected + /// + /// \param joystick Index of the joystick to check + /// + /// \return True if the joystick is connected, false otherwise + /// + //////////////////////////////////////////////////////////// + static bool isConnected(unsigned int joystick); + + //////////////////////////////////////////////////////////// + /// \brief Return the number of buttons supported by a joystick + /// + /// If the joystick is not connected, this function returns 0. + /// + /// \param joystick Index of the joystick + /// + /// \return Number of buttons supported by the joystick + /// + //////////////////////////////////////////////////////////// + static unsigned int getButtonCount(unsigned int joystick); + + //////////////////////////////////////////////////////////// + /// \brief Check if a joystick supports a given axis + /// + /// If the joystick is not connected, this function returns false. + /// + /// \param joystick Index of the joystick + /// \param axis Axis to check + /// + /// \return True if the joystick supports the axis, false otherwise + /// + //////////////////////////////////////////////////////////// + static bool hasAxis(unsigned int joystick, Axis axis); + + //////////////////////////////////////////////////////////// + /// \brief Check if a joystick button is pressed + /// + /// If the joystick is not connected, this function returns false. + /// + /// \param joystick Index of the joystick + /// \param button Button to check + /// + /// \return True if the button is pressed, false otherwise + /// + //////////////////////////////////////////////////////////// + static bool isButtonPressed(unsigned int joystick, unsigned int button); + + //////////////////////////////////////////////////////////// + /// \brief Get the current position of a joystick axis + /// + /// If the joystick is not connected, this function returns 0. + /// + /// \param joystick Index of the joystick + /// \param axis Axis to check + /// + /// \return Current position of the axis, in range [-100 .. 100] + /// + //////////////////////////////////////////////////////////// + static float getAxisPosition(unsigned int joystick, Axis axis); + + //////////////////////////////////////////////////////////// + /// \brief Update the states of all joysticks + /// + /// This function is used internally by SFML, so you normally + /// don't have to call it explicitely. However, you may need to + /// call it if you have no window yet (or no window at all): + /// in this case the joysticks states are not updated automatically. + /// + //////////////////////////////////////////////////////////// + static void update(); +}; + +} // namespace sf + + +#endif // SFML_JOYSTICK_HPP + + +//////////////////////////////////////////////////////////// +/// \class sf::Joystick +/// \ingroup window +/// +/// sf::Joystick provides an interface to the state of the +/// joysticks. It only contains static functions, so it's not +/// meant to be instanciated. Instead, each joystick is identified +/// by an index that is passed to the functions of this class. +/// +/// This class allows users to query the state of joysticks at any +/// time and directly, without having to deal with a window and +/// its events. Compared to the JoystickMoved, JoystickButtonPressed +/// and JoystickButtonReleased events, sf::Joystick can retrieve the +/// state of axes and buttons of joysticks at any time +/// (you don't need to store and update a boolean on your side +/// in order to know if a button is pressed or released), and you +/// always get the real state of joysticks, even if they are +/// moved, pressed or released when your window is out of focus +/// and no event is triggered. +/// +/// SFML supports: +/// \li 8 joysticks (sf::Joystick::Count) +/// \li 32 buttons per joystick (sf::Joystick::ButtonCount) +/// \li 8 axes per joystick (sf::Joystick::AxisCount) +/// +/// Unlike the keyboard or mouse, the state of joysticks is sometimes +/// not directly available (depending on the OS), therefore an update() +/// function must be called in order to update the current state of +/// joysticks. When you have a window with event handling, this is done +/// automatically, you don't need to call anything. But if you have no +/// window, or if you want to check joysticks state before creating one, +/// you must call sf::Joystick::update explicitely. +/// +/// Usage example: +/// \code +/// // Is joystick #0 connected? +/// bool connected = sf::Joystick::isConnected(0); +/// +/// // How many buttons does joystick #0 support? +/// unsigned int buttons = sf::Joystick::getButtonCount(0); +/// +/// // Does joystick #0 define a X axis? +/// bool hasX = sf::Joystick::hasAxis(0, sf::Joystick::X); +/// +/// // Is button #2 pressed on joystick #0? +/// bool pressed = sf::Joystick::isButtonPressed(0, 2); +/// +/// // What's the current position of the Y axis on joystick #0? +/// float position = sf::Joystick::getAxisPosition(0, sf::Joystick::Y); +/// \endcode +/// +/// \see sf::Keyboard, sf::Mouse +/// +//////////////////////////////////////////////////////////// diff --git a/include/SFML/Window/Keyboard.hpp b/include/SFML/Window/Keyboard.hpp new file mode 100644 index 0000000..f10dc7c --- /dev/null +++ b/include/SFML/Window/Keyboard.hpp @@ -0,0 +1,209 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_KEYBOARD_HPP +#define SFML_KEYBOARD_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Window/Export.hpp> + + +namespace sf +{ +//////////////////////////////////////////////////////////// +/// \brief Give access to the real-time state of the keyboard +/// +//////////////////////////////////////////////////////////// +class SFML_WINDOW_API Keyboard +{ +public : + + //////////////////////////////////////////////////////////// + /// \brief Key codes + /// + //////////////////////////////////////////////////////////// + enum Key + { + Unknown = -1, ///< Unhandled key + A = 0, ///< The A key + B, ///< The B key + C, ///< The C key + D, ///< The D key + E, ///< The E key + F, ///< The F key + G, ///< The G key + H, ///< The H key + I, ///< The I key + J, ///< The J key + K, ///< The K key + L, ///< The L key + M, ///< The M key + N, ///< The N key + O, ///< The O key + P, ///< The P key + Q, ///< The Q key + R, ///< The R key + S, ///< The S key + T, ///< The T key + U, ///< The U key + V, ///< The V key + W, ///< The W key + X, ///< The X key + Y, ///< The Y key + Z, ///< The Z key + Num0, ///< The 0 key + Num1, ///< The 1 key + Num2, ///< The 2 key + Num3, ///< The 3 key + Num4, ///< The 4 key + Num5, ///< The 5 key + Num6, ///< The 6 key + Num7, ///< The 7 key + Num8, ///< The 8 key + Num9, ///< The 9 key + Escape, ///< The Escape key + LControl, ///< The left Control key + LShift, ///< The left Shift key + LAlt, ///< The left Alt key + LSystem, ///< The left OS specific key: window (Windows and Linux), apple (MacOS X), ... + RControl, ///< The right Control key + RShift, ///< The right Shift key + RAlt, ///< The right Alt key + RSystem, ///< The right OS specific key: window (Windows and Linux), apple (MacOS X), ... + Menu, ///< The Menu key + LBracket, ///< The [ key + RBracket, ///< The ] key + SemiColon, ///< The ; key + Comma, ///< The , key + Period, ///< The . key + Quote, ///< The ' key + Slash, ///< The / key + BackSlash, ///< The \ key + Tilde, ///< The ~ key + Equal, ///< The = key + Dash, ///< The - key + Space, ///< The Space key + Return, ///< The Return key + BackSpace, ///< The Backspace key + Tab, ///< The Tabulation key + PageUp, ///< The Page up key + PageDown, ///< The Page down key + End, ///< The End key + Home, ///< The Home key + Insert, ///< The Insert key + Delete, ///< The Delete key + Add, ///< The + key + Subtract, ///< The - key + Multiply, ///< The * key + Divide, ///< The / key + Left, ///< Left arrow + Right, ///< Right arrow + Up, ///< Up arrow + Down, ///< Down arrow + Numpad0, ///< The numpad 0 key + Numpad1, ///< The numpad 1 key + Numpad2, ///< The numpad 2 key + Numpad3, ///< The numpad 3 key + Numpad4, ///< The numpad 4 key + Numpad5, ///< The numpad 5 key + Numpad6, ///< The numpad 6 key + Numpad7, ///< The numpad 7 key + Numpad8, ///< The numpad 8 key + Numpad9, ///< The numpad 9 key + F1, ///< The F1 key + F2, ///< The F2 key + F3, ///< The F3 key + F4, ///< The F4 key + F5, ///< The F5 key + F6, ///< The F6 key + F7, ///< The F7 key + F8, ///< The F8 key + F9, ///< The F9 key + F10, ///< The F10 key + F11, ///< The F11 key + F12, ///< The F12 key + F13, ///< The F13 key + F14, ///< The F14 key + F15, ///< The F15 key + Pause, ///< The Pause key + + KeyCount ///< Keep last -- the total number of keyboard keys + }; + + //////////////////////////////////////////////////////////// + /// \brief Check if a key is pressed + /// + /// \param key Key to check + /// + /// \return True if the key is pressed, false otherwise + /// + //////////////////////////////////////////////////////////// + static bool isKeyPressed(Key key); +}; + +} // namespace sf + + +#endif // SFML_KEYBOARD_HPP + + +//////////////////////////////////////////////////////////// +/// \class sf::Keyboard +/// \ingroup window +/// +/// sf::Keyboard provides an interface to the state of the +/// keyboard. It only contains static functions (a single +/// keyboard is assumed), so it's not meant to be instanciated. +/// +/// This class allows users to query the keyboard state at any +/// time and directly, without having to deal with a window and +/// its events. Compared to the KeyPressed and KeyReleased events, +/// sf::Keyboard can retrieve the state of a key at any time +/// (you don't need to store and update a boolean on your side +/// in order to know if a key is pressed or released), and you +/// always get the real state of the keyboard, even if keys are +/// pressed or released when your window is out of focus and no +/// event is triggered. +/// +/// Usage example: +/// \code +/// if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left)) +/// { +/// // move left... +/// } +/// else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right)) +/// { +/// // move right... +/// } +/// else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Escape)) +/// { +/// // quit... +/// } +/// \endcode +/// +/// \see sf::Joystick, sf::Mouse +/// +//////////////////////////////////////////////////////////// diff --git a/include/SFML/Window/Mouse.hpp b/include/SFML/Window/Mouse.hpp new file mode 100644 index 0000000..dd26d1a --- /dev/null +++ b/include/SFML/Window/Mouse.hpp @@ -0,0 +1,167 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_MOUSE_HPP +#define SFML_MOUSE_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Window/Export.hpp> +#include <SFML/System/Vector2.hpp> + + +namespace sf +{ +class Window; + +//////////////////////////////////////////////////////////// +/// \brief Give access to the real-time state of the mouse +/// +//////////////////////////////////////////////////////////// +class SFML_WINDOW_API Mouse +{ +public : + + //////////////////////////////////////////////////////////// + /// \brief Mouse buttons + /// + //////////////////////////////////////////////////////////// + enum Button + { + Left, ///< The left mouse button + Right, ///< The right mouse button + Middle, ///< The middle (wheel) mouse button + XButton1, ///< The first extra mouse button + XButton2, ///< The second extra mouse button + + ButtonCount ///< Keep last -- the total number of mouse buttons + }; + + //////////////////////////////////////////////////////////// + /// \brief Check if a mouse button is pressed + /// + /// \param button Button to check + /// + /// \return True if the button is pressed, false otherwise + /// + //////////////////////////////////////////////////////////// + static bool isButtonPressed(Button button); + + //////////////////////////////////////////////////////////// + /// \brief Get the current position of the mouse in desktop coordinates + /// + /// This function returns the global position of the mouse + /// cursor on the desktop. + /// + /// \return Current position of the mouse + /// + //////////////////////////////////////////////////////////// + static Vector2i getPosition(); + + //////////////////////////////////////////////////////////// + /// \brief Get the current position of the mouse in window coordinates + /// + /// This function returns the current position of the mouse + /// cursor, relative to the given window. + /// + /// \param relativeTo Reference window + /// + /// \return Current position of the mouse + /// + //////////////////////////////////////////////////////////// + static Vector2i getPosition(const Window& relativeTo); + + //////////////////////////////////////////////////////////// + /// \brief Set the current position of the mouse in desktop coordinates + /// + /// This function sets the global position of the mouse + /// cursor on the desktop. + /// + /// \param position New position of the mouse + /// + //////////////////////////////////////////////////////////// + static void setPosition(const Vector2i& position); + + //////////////////////////////////////////////////////////// + /// \brief Set the current position of the mouse in window coordinates + /// + /// This function sets the current position of the mouse + /// cursor, relative to the given window. + /// + /// \param position New position of the mouse + /// \param relativeTo Reference window + /// + //////////////////////////////////////////////////////////// + static void setPosition(const Vector2i& position, const Window& relativeTo); +}; + +} // namespace sf + + +#endif // SFML_MOUSE_HPP + + +//////////////////////////////////////////////////////////// +/// \class sf::Mouse +/// \ingroup window +/// +/// sf::Mouse provides an interface to the state of the +/// mouse. It only contains static functions (a single +/// mouse is assumed), so it's not meant to be instanciated. +/// +/// This class allows users to query the mouse state at any +/// time and directly, without having to deal with a window and +/// its events. Compared to the MouseMoved, MouseButtonPressed +/// and MouseButtonReleased events, sf::Mouse can retrieve the +/// state of the cursor and the buttons at any time +/// (you don't need to store and update a boolean on your side +/// in order to know if a button is pressed or released), and you +/// always get the real state of the mouse, even if it is +/// moved, pressed or released when your window is out of focus +/// and no event is triggered. +/// +/// The setPosition and getPosition functions can be used to change +/// or retrieve the current position of the mouse pointer. There are +/// two versions: one that operates in global coordinates (relative +/// to the desktop) and one that operates in window coordinates +/// (relative to a specific window). +/// +/// Usage example: +/// \code +/// if (sf::Mouse::isButtonPressed(sf::Mouse::Left)) +/// { +/// // left click... +/// } +/// +/// // get global mouse position +/// sf::Vector2i position = sf::Mouse::getPosition(); +/// +/// // set mouse position relative to a window +/// sf::Mouse::setPosition(sf::Vector2i(100, 200), window); +/// \endcode +/// +/// \see sf::Joystick, sf::Keyboard +/// +//////////////////////////////////////////////////////////// diff --git a/include/SFML/Window/VideoMode.hpp b/include/SFML/Window/VideoMode.hpp index b439e64..beec607 100755..100644 --- a/include/SFML/Window/VideoMode.hpp +++ b/include/SFML/Window/VideoMode.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,109 +28,201 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/Config.hpp>
-#include <cstdlib>
+#include <SFML/Window/Export.hpp>
+#include <vector>
namespace sf
{
////////////////////////////////////////////////////////////
-/// VideoMode defines a video mode (width, height, bpp, frequency)
-/// and provides static functions for getting modes supported
-/// by the display device
+/// \brief VideoMode defines a video mode (width, height, bpp)
+///
////////////////////////////////////////////////////////////
-class SFML_API VideoMode
+class SFML_WINDOW_API VideoMode
{
public :
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
+ ///
+ /// This constructors initializes all members to 0.
///
////////////////////////////////////////////////////////////
VideoMode();
////////////////////////////////////////////////////////////
- /// Construct the video mode with its attributes
+ /// \brief Construct the video mode with its attributes
///
- /// \param ModeWidth : Width in pixels
- /// \param ModeHeight : Height in pixels
- /// \param ModeBpp : Pixel depths in bits per pixel (32 by default)
+ /// \param modeWidth Width in pixels
+ /// \param modeHeight Height in pixels
+ /// \param modeBitsPerPixel Pixel depths in bits per pixel
///
////////////////////////////////////////////////////////////
- VideoMode(unsigned int ModeWidth, unsigned int ModeHeight, unsigned int ModeBpp = 32);
+ VideoMode(unsigned int modeWidth, unsigned int modeHeight, unsigned int modeBitsPerPixel = 32);
////////////////////////////////////////////////////////////
- /// Get the current desktop video mode
+ /// \brief Get the current desktop video mode
///
/// \return Current desktop video mode
///
////////////////////////////////////////////////////////////
- static VideoMode GetDesktopMode();
+ static VideoMode getDesktopMode();
////////////////////////////////////////////////////////////
- /// Get a valid video mode
- /// Index must be in range [0, GetModesCount()[
- /// Modes are sorted from best to worst
+ /// \brief Retrieve all the video modes supported in fullscreen mode
///
- /// \param Index : Index of video mode to get
+ /// When creating a fullscreen window, the video mode is restricted
+ /// to be compatible with what the graphics driver and monitor
+ /// support. This function returns the complete list of all video
+ /// modes that can be used in fullscreen mode.
+ /// The returned array is sorted from best to worst, so that
+ /// the first element will always give the best mode (higher
+ /// width, height and bits-per-pixel).
///
- /// \return Corresponding video mode (invalid mode if index is out of range)
+ /// \return Array containing all the supported fullscreen modes
///
////////////////////////////////////////////////////////////
- static VideoMode GetMode(std::size_t Index);
+ static const std::vector<VideoMode>& getFullscreenModes();
////////////////////////////////////////////////////////////
- /// Get valid video modes count
- ///
- /// \return Number of valid video modes available
+ /// \brief Tell whether or not the video mode is valid
///
- ////////////////////////////////////////////////////////////
- static std::size_t GetModesCount();
-
- ////////////////////////////////////////////////////////////
- /// Tell whether or not the video mode is supported
+ /// The validity of video modes is only relevant when using
+ /// fullscreen windows; otherwise any video mode can be used
+ /// with no restriction.
///
- /// \return True if video mode is supported, false otherwise
+ /// \return True if the video mode is valid for fullscreen mode
///
////////////////////////////////////////////////////////////
- bool IsValid() const;
+ bool isValid() const;
////////////////////////////////////////////////////////////
- /// Comparison operator overload -- tell if two video modes are equal
- ///
- /// \param Other : Video mode to compare
- ///
- /// \return True if modes are equal
- ///
+ // Member data
////////////////////////////////////////////////////////////
- bool operator ==(const VideoMode& Other) const;
+ unsigned int width; ///< Video mode width, in pixels
+ unsigned int height; ///< Video mode height, in pixels
+ unsigned int bitsPerPixel; ///< Video mode pixel depth, in bits per pixels
+};
- ////////////////////////////////////////////////////////////
- /// Comparison operator overload -- tell if two video modes are different
- ///
- /// \param Other : Video mode to compare
- ///
- /// \return True if modes are different
- ///
- ////////////////////////////////////////////////////////////
- bool operator !=(const VideoMode& Other) const;
+////////////////////////////////////////////////////////////
+/// \relates VideoMode
+/// \brief Overload of == operator to compare two video modes
+///
+/// \param left Left operand (a video mode)
+/// \param right Right operand (a video mode)
+///
+/// \return True if modes are equal
+///
+////////////////////////////////////////////////////////////
+SFML_WINDOW_API bool operator ==(const VideoMode& left, const VideoMode& right);
- ////////////////////////////////////////////////////////////
- // Member data
- ////////////////////////////////////////////////////////////
- unsigned int Width; ///< Video mode width, in pixels
- unsigned int Height; ///< Video mode height, in pixels
- unsigned int BitsPerPixel; ///< Video mode pixel depth, in bits per pixels
+////////////////////////////////////////////////////////////
+/// \relates VideoMode
+/// \brief Overload of != operator to compare two video modes
+///
+/// \param left Left operand (a video mode)
+/// \param right Right operand (a video mode)
+///
+/// \return True if modes are different
+///
+////////////////////////////////////////////////////////////
+SFML_WINDOW_API bool operator !=(const VideoMode& left, const VideoMode& right);
-private :
+////////////////////////////////////////////////////////////
+/// \relates VideoMode
+/// \brief Overload of < operator to compare video modes
+///
+/// \param left Left operand (a video mode)
+/// \param right Right operand (a video mode)
+///
+/// \return True if \a left is lesser than \a right
+///
+////////////////////////////////////////////////////////////
+SFML_WINDOW_API bool operator <(const VideoMode& left, const VideoMode& right);
- ////////////////////////////////////////////////////////////
- /// Get and sort valid video modes
- ////////////////////////////////////////////////////////////
- static void InitializeModes();
-};
+////////////////////////////////////////////////////////////
+/// \relates VideoMode
+/// \brief Overload of > operator to compare video modes
+///
+/// \param left Left operand (a video mode)
+/// \param right Right operand (a video mode)
+///
+/// \return True if \a left is greater than \a right
+///
+////////////////////////////////////////////////////////////
+SFML_WINDOW_API bool operator >(const VideoMode& left, const VideoMode& right);
+
+////////////////////////////////////////////////////////////
+/// \relates VideoMode
+/// \brief Overload of <= operator to compare video modes
+///
+/// \param left Left operand (a video mode)
+/// \param right Right operand (a video mode)
+///
+/// \return True if \a left is lesser or equal than \a right
+///
+////////////////////////////////////////////////////////////
+SFML_WINDOW_API bool operator <=(const VideoMode& left, const VideoMode& right);
+
+////////////////////////////////////////////////////////////
+/// \relates VideoMode
+/// \brief Overload of >= operator to compare video modes
+///
+/// \param left Left operand (a video mode)
+/// \param right Right operand (a video mode)
+///
+/// \return True if \a left is greater or equal than \a right
+///
+////////////////////////////////////////////////////////////
+SFML_WINDOW_API bool operator >=(const VideoMode& left, const VideoMode& right);
} // namespace sf
#endif // SFML_VIDEOMODE_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::VideoMode
+/// \ingroup window
+///
+/// A video mode is defined by a width and a height (in pixels)
+/// and a depth (in bits per pixel). Video modes are used to
+/// setup windows (sf::Window) at creation time.
+///
+/// The main usage of video modes is for fullscreen mode:
+/// indeed you must use one of the valid video modes
+/// allowed by the OS (which are defined by what the monitor
+/// and the graphics card support), otherwise your window
+/// creation will just fail.
+///
+/// sf::VideoMode provides a static function for retrieving
+/// the list of all the video modes supported by the system:
+/// getFullscreenModes().
+///
+/// A custom video mode can also be checked directly for
+/// fullscreen compatibility with its isValid() function.
+///
+/// Additionnally, sf::VideoMode provides a static function
+/// to get the mode currently used by the desktop: getDesktopMode().
+/// This allows to build windows with the same size or pixel
+/// depth as the current resolution.
+///
+/// Usage example:
+/// \code
+/// // Display the list of all the video modes available for fullscreen
+/// std::vector<sf::VideoMode> modes = sf::VideoMode::getFullscreenModes();
+/// for (std::size_t i = 0; i < modes.size(); ++i)
+/// {
+/// sf::VideoMode mode = modes[i];
+/// std::cout << "Mode #" << i << ": "
+/// << mode.width << "x" << mode.height << " - "
+/// << mode.bitsPerPixel << " bpp" << std::endl;
+/// }
+///
+/// // Create a window with the same pixel depth as the desktop
+/// sf::VideoMode desktop = sf::VideoMode::getDesktopMode();
+/// window.create(sf::VideoMode(1024, 768, desktop.bitsPerPixel), "SFML window");
+/// \endcode
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Window/Window.hpp b/include/SFML/Window/Window.hpp index 5199021..21bb2c5 100755..100644 --- a/include/SFML/Window/Window.hpp +++ b/include/SFML/Window/Window.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,299 +28,514 @@ ////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
-#include <SFML/Window/Event.hpp>
-#include <SFML/Window/Input.hpp>
+#include <SFML/Window/Export.hpp>
+#include <SFML/Window/ContextSettings.hpp>
#include <SFML/Window/VideoMode.hpp>
#include <SFML/Window/WindowHandle.hpp>
-#include <SFML/Window/WindowListener.hpp>
-#include <SFML/Window/WindowSettings.hpp>
#include <SFML/Window/WindowStyle.hpp>
+#include <SFML/Window/GlResource.hpp>
#include <SFML/System/Clock.hpp>
+#include <SFML/System/Vector2.hpp>
#include <SFML/System/NonCopyable.hpp>
-#include <queue>
-#include <string>
+#include <SFML/System/String.hpp>
namespace sf
{
namespace priv
{
+ class GlContext;
class WindowImpl;
}
+class Event;
+
////////////////////////////////////////////////////////////
-/// Window is a rendering window ; it can create a new window
-/// or connect to an existing one
+/// \brief Window that serves as a target for OpenGL rendering
+///
////////////////////////////////////////////////////////////
-class SFML_API Window : public WindowListener, NonCopyable
+class SFML_WINDOW_API Window : GlResource, NonCopyable
{
public :
////////////////////////////////////////////////////////////
- /// Default constructor
+ /// \brief Default constructor
+ ///
+ /// This constructor doesn't actually create the window,
+ /// use the other constructors or call "create" to do so.
///
////////////////////////////////////////////////////////////
Window();
////////////////////////////////////////////////////////////
- /// Construct a new window
+ /// \brief Construct a new window
+ ///
+ /// This constructor creates the window with the size and pixel
+ /// depth defined in \a mode. An optional style can be passed to
+ /// customize the look and behaviour of the window (borders,
+ /// title bar, resizable, closable, ...). If \a style contains
+ /// Style::Fullscreen, then \a mode must be a valid video mode.
+ ///
+ /// The fourth parameter is an optional structure specifying
+ /// advanced OpenGL context settings such as antialiasing,
+ /// depth-buffer bits, etc.
///
- /// \param Mode : Video mode to use
- /// \param Title : Title of the window
- /// \param WindowStyle : Window style, see sf::Style (Resize | Close by default)
- /// \param Params : Creation parameters (see default constructor for default values)
+ /// \param mode Video mode to use (defines the width, height and depth of the rendering area of the window)
+ /// \param title Title of the window
+ /// \param style Window style
+ /// \param settings Additional settings for the underlying OpenGL context
///
////////////////////////////////////////////////////////////
- Window(VideoMode Mode, const std::string& Title, unsigned long WindowStyle = Style::Resize | Style::Close, const WindowSettings& Params = WindowSettings());
+ Window(VideoMode mode, const String& title, Uint32 style = Style::Default, const ContextSettings& settings = ContextSettings());
////////////////////////////////////////////////////////////
- /// Construct the window from an existing control
+ /// \brief Construct the window from an existing control
///
- /// \param Handle : Platform-specific handle of the control
- /// \param Params : Creation parameters (see default constructor for default values)
+ /// Use this constructor if you want to create an OpenGL
+ /// rendering area into an already existing control.
+ ///
+ /// The second parameter is an optional structure specifying
+ /// advanced OpenGL context settings such as antialiasing,
+ /// depth-buffer bits, etc.
+ ///
+ /// \param handle Platform-specific handle of the control
+ /// \param settings Additional settings for the underlying OpenGL context
///
////////////////////////////////////////////////////////////
- Window(WindowHandle Handle, const WindowSettings& Params = WindowSettings());
+ explicit Window(WindowHandle handle, const ContextSettings& settings = ContextSettings());
////////////////////////////////////////////////////////////
- /// Destructor
+ /// \brief Destructor
+ ///
+ /// Closes the window and free all the resources attached to it.
///
////////////////////////////////////////////////////////////
virtual ~Window();
////////////////////////////////////////////////////////////
- /// Create (or recreate) the window
+ /// \brief Create (or recreate) the window
///
- /// \param Mode : Video mode to use
- /// \param Title : Title of the window
- /// \param WindowStyle : Window style, see sf::Style (Resize | Close by default)
- /// \param Params : Creation parameters (see default constructor for default values)
+ /// If the window was already created, it closes it first.
+ /// If \a style contains Style::Fullscreen, then \a mode
+ /// must be a valid video mode.
+ ///
+ /// \param mode Video mode to use (defines the width, height and depth of the rendering area of the window)
+ /// \param title Title of the window
+ /// \param style Window style
+ /// \param settings Additional settings for the underlying OpenGL context
///
////////////////////////////////////////////////////////////
- void Create(VideoMode Mode, const std::string& Title, unsigned long WindowStyle = Style::Resize | Style::Close, const WindowSettings& Params = WindowSettings());
+ void create(VideoMode mode, const String& title, Uint32 style = Style::Default, const ContextSettings& settings = ContextSettings());
////////////////////////////////////////////////////////////
- /// Create (or recreate) the window from an existing control
+ /// \brief Create (or recreate) the window from an existing control
+ ///
+ /// Use this function if you want to create an OpenGL
+ /// rendering area into an already existing control.
+ /// If the window was already created, it closes it first.
///
- /// \param Handle : Platform-specific handle of the control
- /// \param Params : Creation parameters (see default constructor for default values)
+ /// \param handle Platform-specific handle of the control
+ /// \param settings Additional settings for the underlying OpenGL context
///
////////////////////////////////////////////////////////////
- void Create(WindowHandle Handle, const WindowSettings& Params = WindowSettings());
+ void create(WindowHandle handle, const ContextSettings& settings = ContextSettings());
////////////////////////////////////////////////////////////
- /// Close (destroy) the window.
- /// The sf::Window instance remains valid and you can call
- /// Create to recreate the window
+ /// \brief Close the window and destroy all the attached resources
+ ///
+ /// After calling this function, the sf::Window instance remains
+ /// valid and you can call create() to recreate the window.
+ /// All other functions such as pollEvent() or display() will
+ /// still work (i.e. you don't have to test isOpen() every time),
+ /// and will have no effect on closed windows.
///
////////////////////////////////////////////////////////////
- void Close();
+ void close();
////////////////////////////////////////////////////////////
- /// Tell whether or not the window is opened (ie. has been created).
- /// Note that a hidden window (Show(false))
- /// will still return true
+ /// \brief Tell whether or not the window is open
///
- /// \return True if the window is opened
+ /// This function returns whether or not the window exists.
+ /// Note that a hidden window (setVisible(false)) is open
+ /// (therefore this function would return true).
+ ///
+ /// \return True if the window is open, false if it has been closed
///
////////////////////////////////////////////////////////////
- bool IsOpened() const;
+ bool isOpen() const;
////////////////////////////////////////////////////////////
- /// Get the width of the rendering region of the window
+ /// \brief Get the settings of the OpenGL context of the window
+ ///
+ /// Note that these settings may be different from what was
+ /// passed to the constructor or the create() function,
+ /// if one or more settings were not supported. In this case,
+ /// SFML chose the closest match.
///
- /// \return Width in pixels
+ /// \return Structure containing the OpenGL context settings
///
////////////////////////////////////////////////////////////
- unsigned int GetWidth() const;
+ const ContextSettings& getSettings() const;
////////////////////////////////////////////////////////////
- /// Get the height of the rendering region of the window
+ /// \brief Pop the event on top of the event queue, if any, and return it
+ ///
+ /// This function is not blocking: if there's no pending event then
+ /// it will return false and leave \a event unmodified.
+ /// Note that more than one event may be present in the event queue,
+ /// thus you should always call this function in a loop
+ /// to make sure that you process every pending event.
+ /// \code
+ /// sf::Event event;
+ /// while (window.pollEvent(event))
+ /// {
+ /// // process event...
+ /// }
+ /// \endcode
///
- /// \return Height in pixels
+ /// \param event Event to be returned
+ ///
+ /// \return True if an event was returned, or false if the event queue was empty
+ ///
+ /// \see waitEvent
///
////////////////////////////////////////////////////////////
- unsigned int GetHeight() const;
+ bool pollEvent(Event& event);
////////////////////////////////////////////////////////////
- /// Get the creation settings of the window
+ /// \brief Wait for an event and return it
+ ///
+ /// This function is blocking: if there's no pending event then
+ /// it will wait until an event is received.
+ /// After this function returns (and no error occured),
+ /// the \a event object is always valid and filled properly.
+ /// This function is typically used when you have a thread that
+ /// is dedicated to events handling: you want to make this thread
+ /// sleep as long as no new event is received.
+ /// \code
+ /// sf::Event event;
+ /// if (window.waitEvent(event))
+ /// {
+ /// // process event...
+ /// }
+ /// \endcode
+ ///
+ /// \param event Event to be returned
///
- /// \return Structure containing the creation settings
+ /// \return False if any error occured
+ ///
+ /// \see pollEvent
///
////////////////////////////////////////////////////////////
- const WindowSettings& GetSettings() const;
+ bool waitEvent(Event& event);
////////////////////////////////////////////////////////////
- /// Get the event on top of events stack, if any, and pop it
+ /// \brief Get the position of the window
///
- /// \param EventReceived : Event to fill, if any
+ /// \return Position of the window, in pixels
///
- /// \return True if an event was returned, false if events stack was empty
+ /// \see setPosition
///
////////////////////////////////////////////////////////////
- bool GetEvent(Event& EventReceived);
+ Vector2i getPosition() const;
////////////////////////////////////////////////////////////
- /// Enable / disable vertical synchronization
+ /// \brief Change the position of the window on screen
+ ///
+ /// This function only works for top-level windows
+ /// (i.e. it will be ignored for windows created from
+ /// the handle of a child window/control).
+ ///
+ /// \param position New position, in pixels
///
- /// \param Enabled : True to enable v-sync, false to deactivate
+ /// \see getPosition
///
////////////////////////////////////////////////////////////
- void UseVerticalSync(bool Enabled);
+ void setPosition(const Vector2i& position);
////////////////////////////////////////////////////////////
- /// Show or hide the mouse cursor
+ /// \brief Get the size of the rendering region of the window
///
- /// \param Show : True to show, false to hide
+ /// The size doesn't include the titlebar and borders
+ /// of the window.
+ ///
+ /// \return Size in pixels
+ ///
+ /// \see setSize
///
////////////////////////////////////////////////////////////
- void ShowMouseCursor(bool Show);
+ Vector2u getSize() const;
////////////////////////////////////////////////////////////
- /// Change the position of the mouse cursor
+ /// \brief Change the size of the rendering region of the window
+ ///
+ /// \param size New size, in pixels
///
- /// \param Left : Left coordinate of the cursor, relative to the window
- /// \param Top : Top coordinate of the cursor, relative to the window
+ /// \see getSize
///
////////////////////////////////////////////////////////////
- void SetCursorPosition(unsigned int Left, unsigned int Top);
+ void setSize(const Vector2u size);
////////////////////////////////////////////////////////////
- /// Change the position of the window on screen.
- /// Only works for top-level windows
+ /// \brief Change the title of the window
///
- /// \param Left : Left position
- /// \param Top : Top position
+ /// \param title New title
+ ///
+ /// \see setIcon
///
////////////////////////////////////////////////////////////
- void SetPosition(int Left, int Top);
+ void setTitle(const String& title);
////////////////////////////////////////////////////////////
- /// Change the size of the rendering region of the window
+ /// \brief Change the window's icon
+ ///
+ /// \a pixels must be an array of \a width x \a height pixels
+ /// in 32-bits RGBA format.
+ ///
+ /// The OS default icon is used by default.
///
- /// \param Width : New width
- /// \param Height : New height
+ /// \param width Icon's width, in pixels
+ /// \param height Icon's height, in pixels
+ /// \param pixels Pointer to the array of pixels in memory
+ ///
+ /// \see setTitle
///
////////////////////////////////////////////////////////////
- void SetSize(unsigned int Width, unsigned int Height);
+ void setIcon(unsigned int width, unsigned int height, const Uint8* pixels);
////////////////////////////////////////////////////////////
- /// Show or hide the window
+ /// \brief Show or hide the window
+ ///
+ /// The window is shown by default.
///
- /// \param State : True to show, false to hide
+ /// \param visible True to show the window, false to hide it
///
////////////////////////////////////////////////////////////
- void Show(bool State);
+ void setVisible(bool visible);
////////////////////////////////////////////////////////////
- /// Enable or disable automatic key-repeat.
- /// Automatic key-repeat is enabled by default
+ /// \brief Enable or disable vertical synchronization
+ ///
+ /// Activating vertical synchronization will limit the number
+ /// of frames displayed to the refresh rate of the monitor.
+ /// This can avoid some visual artifacts, and limit the framerate
+ /// to a good value (but not constant across different computers).
+ ///
+ /// Vertical synchronization is disabled by default.
///
- /// \param Enabled : True to enable, false to disable
+ /// \param enabled True to enable v-sync, false to deactivate it
///
////////////////////////////////////////////////////////////
- void EnableKeyRepeat(bool Enabled);
+ void setVerticalSyncEnabled(bool enabled);
////////////////////////////////////////////////////////////
- /// Change the window's icon
+ /// \brief Show or hide the mouse cursor
///
- /// \param Width : Icon's width, in pixels
- /// \param Height : Icon's height, in pixels
- /// \param Pixels : Pointer to the pixels in memory, format must be RGBA 32 bits
+ /// The mouse cursor is visible by default.
+ ///
+ /// \param visible True to show the mouse cursor, false to hide it
///
////////////////////////////////////////////////////////////
- void SetIcon(unsigned int Width, unsigned int Height, const Uint8* Pixels);
+ void setMouseCursorVisible(bool visible);
////////////////////////////////////////////////////////////
- /// Activate of deactivate the window as the current target
- /// for rendering
+ /// \brief Enable or disable automatic key-repeat
///
- /// \param Active : True to activate, false to deactivate (true by default)
+ /// If key repeat is enabled, you will receive repeated
+ /// KeyPressed events while keeping a key pressed. If it is disabled,
+ /// you will only get a single event when the key is pressed.
///
- /// \return True if operation was successful, false otherwise
+ /// Key repeat is enabled by default.
+ ///
+ /// \param enabled True to enable, false to disable
///
////////////////////////////////////////////////////////////
- bool SetActive(bool Active = true) const;
+ void setKeyRepeatEnabled(bool enabled);
////////////////////////////////////////////////////////////
- /// Display the window on screen
+ /// \brief Limit the framerate to a maximum fixed frequency
+ ///
+ /// If a limit is set, the window will use a small delay after
+ /// each call to display() to ensure that the current frame
+ /// lasted long enough to match the framerate limit.
+ /// SFML will try to match the given limit as much as it can,
+ /// but since it internally uses sf::sleep, whose precision
+ /// depends on the underlying OS, the results may be a little
+ /// unprecise as well (for example, you can get 65 FPS when
+ /// requesting 60).
+ ///
+ /// \param limit Framerate limit, in frames per seconds (use 0 to disable limit)
///
////////////////////////////////////////////////////////////
- void Display();
+ void setFramerateLimit(unsigned int limit);
////////////////////////////////////////////////////////////
- /// Get the input manager of the window
+ /// \brief Change the joystick threshold
+ ///
+ /// The joystick threshold is the value below which
+ /// no JoystickMoved event will be generated.
///
- /// \return Reference to the input
+ /// The threshold value is 0.1 by default.
+ ///
+ /// \param threshold New threshold, in the range [0, 100]
///
////////////////////////////////////////////////////////////
- const Input& GetInput() const;
+ void setJoystickThreshold(float threshold);
////////////////////////////////////////////////////////////
- /// Limit the framerate to a maximum fixed frequency
+ /// \brief Activate or deactivate the window as the current target
+ /// for OpenGL rendering
+ ///
+ /// A window is active only on the current thread, if you want to
+ /// make it active on another thread you have to deactivate it
+ /// on the previous thread first if it was active.
+ /// Only one window can be active on a thread at a time, thus
+ /// the window previously active (if any) automatically gets deactivated.
+ ///
+ /// \param active True to activate, false to deactivate
///
- /// \param Limit : Framerate limit, in frames per seconds (use 0 to disable limit)
+ /// \return True if operation was successful, false otherwise
///
////////////////////////////////////////////////////////////
- void SetFramerateLimit(unsigned int Limit);
+ bool setActive(bool active = true) const;
////////////////////////////////////////////////////////////
- /// Get time elapsed since last frame
+ /// \brief Display on screen what has been rendered to the window so far
///
- /// \return Time elapsed, in seconds
+ /// This function is typically called after all OpenGL rendering
+ /// has been done for the current frame, in order to show
+ /// it on screen.
///
////////////////////////////////////////////////////////////
- float GetFrameTime() const;
+ void display();
////////////////////////////////////////////////////////////
- /// Change the joystick threshold, ie. the value below which
- /// no move event will be generated
+ /// \brief Get the OS-specific handle of the window
+ ///
+ /// The type of the returned handle is sf::WindowHandle,
+ /// which is a typedef to the handle type defined by the OS.
+ /// You shouldn't need to use this function, unless you have
+ /// very specific stuff to implement that SFML doesn't support,
+ /// or implement a temporary workaround until a bug is fixed.
///
- /// \param Threshold : New threshold, in range [0, 100]
+ /// \return System handle of the window
///
////////////////////////////////////////////////////////////
- void SetJoystickThreshold(float Threshold);
+ WindowHandle getSystemHandle() const;
-private :
+protected :
////////////////////////////////////////////////////////////
- /// Called after the window has been created
+ /// \brief Function called after the window has been created
+ ///
+ /// This function is called so that derived classes can
+ /// perform their own specific initialization as soon as
+ /// the window is created.
///
////////////////////////////////////////////////////////////
- virtual void OnCreate();
+ virtual void onCreate();
////////////////////////////////////////////////////////////
- /// /see WindowListener::OnEvent
+ /// \brief Function called after the window has been resized
///
- /// \param EventReceived : Event received
+ /// This function is called so that derived classes can
+ /// perform custom actions when the size of the window changes.
///
////////////////////////////////////////////////////////////
- virtual void OnEvent(const Event& EventReceived);
+ virtual void onResize();
+
+private:
////////////////////////////////////////////////////////////
- /// Initialize internal window
+ /// \brief Processes an event before it is sent to the user
///
- /// \param Impl : New internal window implementation
+ /// This function is called every time an event is received
+ /// from the internal window (through pollEvent or waitEvent).
+ /// It filters out unwanted events, and performs whatever internal
+ /// stuff the window needs before the event is returned to the
+ /// user.
+ ///
+ /// \param event Event to filter
///
////////////////////////////////////////////////////////////
- void Initialize(priv::WindowImpl* Impl);
+ bool filterEvent(const Event& event);
+
+ ////////////////////////////////////////////////////////////
+ /// \brief Perform some common internal initializations
+ ///
+ ////////////////////////////////////////////////////////////
+ void initialize();
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
- priv::WindowImpl* myWindow; ///< Platform-specific implementation of window
- std::queue<Event> myEvents; ///< Queue of received events
- Input myInput; ///< Input manager connected to window
- Clock myClock; ///< Clock for measuring the elapsed time between frames
- WindowSettings mySettings; ///< Creation settings of the window
- float myLastFrameTime; ///< Time elapsed since last frame
- bool myIsExternal; ///< Tell whether the window is internal or external (created by SFML or not)
- unsigned int myFramerateLimit; ///< Current framerate limit
- int mySetCursorPosX; ///< X coordinate passed to the last call to SetCursorPosition
- int mySetCursorPosY; ///< Y coordinate passed to the last call to SetCursorPosition
+ priv::WindowImpl* m_impl; ///< Platform-specific implementation of the window
+ priv::GlContext* m_context; ///< Platform-specific implementation of the OpenGL context
+ Clock m_clock; ///< Clock for measuring the elapsed time between frames
+ Time m_frameTimeLimit; ///< Current framerate limit
+ Vector2u m_size; ///< Current size of the window
};
} // namespace sf
#endif // SFML_WINDOW_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::Window
+/// \ingroup window
+///
+/// sf::Window is the main class of the Window module. It defines
+/// an OS window that is able to receive an OpenGL rendering.
+///
+/// A sf::Window can create its own new window, or be embedded into
+/// an already existing control using the create(handle) function.
+/// This can be useful for embedding an OpenGL rendering area into
+/// a view which is part of a bigger GUI with existing windows,
+/// controls, etc. It can also serve as embedding an OpenGL rendering
+/// area into a window created by another (probably richer) GUI library
+/// like Qt or wxWidgets.
+///
+/// The sf::Window class provides a simple interface for manipulating
+/// the window: move, resize, show/hide, control mouse cursor, etc.
+/// It also provides event handling through its pollEvent() and waitEvent()
+/// functions.
+///
+/// Note that OpenGL experts can pass their own parameters (antialiasing
+/// level, bits for the depth and stencil buffers, etc.) to the
+/// OpenGL context attached to the window, with the sf::ContextSettings
+/// structure which is passed as an optional argument when creating the
+/// window.
+///
+/// Usage example:
+/// \code
+/// // Declare and create a new window
+/// sf::Window window(sf::VideoMode(800, 600), "SFML window");
+///
+/// // Limit the framerate to 60 frames per second (this step is optional)
+/// window.setFramerateLimit(60);
+///
+/// // The main loop - ends as soon as the window is closed
+/// while (window.isOpen())
+/// {
+/// // Event processing
+/// sf::Event event;
+/// while (window.pollEvent(event))
+/// {
+/// // Request for closing the window
+/// if (event.type == sf::Event::Closed)
+/// window.close();
+/// }
+///
+/// // Activate the window for OpenGL rendering
+/// window.setActive();
+///
+/// // OpenGL drawing commands go here...
+///
+/// // End the current frame and display its contents on screen
+/// window.display();
+/// }
+/// \endcode
+///
+////////////////////////////////////////////////////////////
diff --git a/include/SFML/Window/WindowHandle.hpp b/include/SFML/Window/WindowHandle.hpp index 852036c..7fb2bb8 100755..100644 --- a/include/SFML/Window/WindowHandle.hpp +++ b/include/SFML/Window/WindowHandle.hpp @@ -1,7 +1,7 @@ //////////////////////////////////////////////////////////// // // SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com) +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) // // This software is provided 'as-is', without any express or implied warranty. // In no event will the authors be held liable for any damages arising from the use of this software. @@ -30,6 +30,10 @@ //////////////////////////////////////////////////////////// #include <SFML/Config.hpp> +// Windows' HWND is a typedef on struct HWND__* +#if defined(SFML_SYSTEM_WINDOWS) + struct HWND__; +#endif namespace sf { @@ -39,18 +43,18 @@ namespace sf //////////////////////////////////////////////////////////// #if defined(SFML_SYSTEM_WINDOWS) - // Windows defines a void* handle (HWND) - typedef void* WindowHandle; + // Window handle is HWND (HWND__*) on Windows + typedef HWND__* WindowHandle; #elif defined(SFML_SYSTEM_LINUX) || defined(SFML_SYSTEM_FREEBSD) - // Unix - X11 defines an unsigned integer handle (Window) + // Window handle is Window (unsigned long) on Unix - X11 typedef unsigned long WindowHandle; #elif defined(SFML_SYSTEM_MACOS) - // Mac OS X defines a void* handle (NSWindow) - typedef void* WindowHandle; + // Window handle is NSWindow (void*) on Mac OS X - Cocoa + typedef void* WindowHandle; #endif diff --git a/include/SFML/Window/WindowSettings.hpp b/include/SFML/Window/WindowSettings.hpp deleted file mode 100755 index 78f9ecd..0000000 --- a/include/SFML/Window/WindowSettings.hpp +++ /dev/null @@ -1,62 +0,0 @@ -////////////////////////////////////////////////////////////
-//
-// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
-//
-// This software is provided 'as-is', without any express or implied warranty.
-// In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it freely,
-// subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented;
-// you must not claim that you wrote the original software.
-// If you use this software in a product, an acknowledgment
-// in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such,
-// and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-//
-////////////////////////////////////////////////////////////
-
-#ifndef SFML_WINDOWSETTINGS_HPP
-#define SFML_WINDOWSETTINGS_HPP
-
-
-namespace sf
-{
-////////////////////////////////////////////////////////////
-/// Structure defining the creation settings of windows
-////////////////////////////////////////////////////////////
-struct WindowSettings
-{
- ////////////////////////////////////////////////////////////
- /// Default constructor
- ///
- /// \param Depth : Depth buffer bits (24 by default)
- /// \param Stencil : Stencil buffer bits (8 by default)
- /// \param Antialiasing : Antialiasing level (0 by default)
- ///
- ////////////////////////////////////////////////////////////
- explicit WindowSettings(unsigned int Depth = 24, unsigned int Stencil = 8, unsigned int Antialiasing = 0) :
- DepthBits (Depth),
- StencilBits (Stencil),
- AntialiasingLevel(Antialiasing)
- {
- }
-
- ////////////////////////////////////////////////////////////
- // Member data
- ////////////////////////////////////////////////////////////
- unsigned int DepthBits; ///< Bits of the depth buffer
- unsigned int StencilBits; ///< Bits of the stencil buffer
- unsigned int AntialiasingLevel; ///< Level of antialiasing
-};
-
-} // namespace sf
-
-
-#endif // SFML_WINDOWSETTINGS_HPP
diff --git a/include/SFML/Window/WindowStyle.hpp b/include/SFML/Window/WindowStyle.hpp index 9fcc2e7..fa69d32 100755..100644 --- a/include/SFML/Window/WindowStyle.hpp +++ b/include/SFML/Window/WindowStyle.hpp @@ -1,7 +1,7 @@ ////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
-// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
+// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
@@ -28,23 +28,25 @@ namespace sf
{
-
-////////////////////////////////////////////////////////////
-/// Enumeration of window creation styles
-////////////////////////////////////////////////////////////
namespace Style
{
+ ////////////////////////////////////////////////////////////
+ /// \ingroup window
+ /// \brief Enumeration of the window styles
+ ///
+ ////////////////////////////////////////////////////////////
enum
{
None = 0, ///< No border / title bar (this flag and all others are mutually exclusive)
Titlebar = 1 << 0, ///< Title bar + fixed border
Resize = 1 << 1, ///< Titlebar + resizable border + maximize button
Close = 1 << 2, ///< Titlebar + close button
- Fullscreen = 1 << 3 ///< Fullscreen mode (this flag and all others are mutually exclusive)
+ Fullscreen = 1 << 3, ///< Fullscreen mode (this flag and all others are mutually exclusive)
+
+ Default = Titlebar | Resize | Close ///< Default window style
};
}
-
} // namespace sf
|