From ff5b69d312271829004dc82c26833ec692742f5c Mon Sep 17 00:00:00 2001 From: Laurent Gomila Date: Fri, 9 Mar 2012 01:22:47 +0100 Subject: [PATCH] Changed the naming convention for member variables (prefix changed from "my" to "m_") --- examples/shader/Effect.hpp | 16 +- examples/shader/Shader.cpp | 124 +++++----- examples/voip/Client.cpp | 20 +- examples/voip/Server.cpp | 54 ++--- include/SFML/Audio/Music.hpp | 8 +- include/SFML/Audio/Sound.hpp | 2 +- include/SFML/Audio/SoundBuffer.hpp | 8 +- include/SFML/Audio/SoundBufferRecorder.hpp | 4 +- include/SFML/Audio/SoundRecorder.hpp | 8 +- include/SFML/Audio/SoundSource.hpp | 2 +- include/SFML/Audio/SoundStream.hpp | 18 +- include/SFML/Graphics/CircleShape.hpp | 4 +- include/SFML/Graphics/ConvexShape.hpp | 2 +- include/SFML/Graphics/Drawable.hpp | 12 +- include/SFML/Graphics/Font.hpp | 12 +- include/SFML/Graphics/Image.hpp | 6 +- include/SFML/Graphics/RectangleShape.hpp | 2 +- include/SFML/Graphics/RenderTarget.hpp | 6 +- include/SFML/Graphics/RenderTexture.hpp | 4 +- include/SFML/Graphics/Shader.hpp | 6 +- include/SFML/Graphics/Shape.hpp | 18 +- include/SFML/Graphics/Sprite.hpp | 6 +- include/SFML/Graphics/Text.hpp | 14 +- include/SFML/Graphics/Texture.hpp | 18 +- include/SFML/Graphics/Transform.hpp | 2 +- include/SFML/Graphics/Transformable.hpp | 16 +- include/SFML/Graphics/VertexArray.hpp | 4 +- include/SFML/Graphics/View.hpp | 16 +- include/SFML/Network/Ftp.hpp | 10 +- include/SFML/Network/Http.hpp | 30 +-- include/SFML/Network/IpAddress.hpp | 2 +- include/SFML/Network/Packet.hpp | 6 +- include/SFML/Network/Socket.hpp | 6 +- include/SFML/Network/SocketSelector.hpp | 2 +- include/SFML/Network/TcpSocket.hpp | 2 +- include/SFML/Network/UdpSocket.hpp | 2 +- include/SFML/System/Clock.hpp | 2 +- include/SFML/System/Lock.hpp | 2 +- include/SFML/System/Mutex.hpp | 2 +- include/SFML/System/String.hpp | 2 +- include/SFML/System/Thread.hpp | 4 +- include/SFML/System/Thread.inl | 34 +-- include/SFML/System/ThreadLocal.hpp | 2 +- include/SFML/System/Time.hpp | 2 +- include/SFML/Window/Context.hpp | 2 +- include/SFML/Window/Window.hpp | 8 +- src/SFML/Audio/Music.cpp | 32 +-- src/SFML/Audio/Sound.cpp | 54 ++--- src/SFML/Audio/SoundBuffer.cpp | 60 ++--- src/SFML/Audio/SoundBufferRecorder.cpp | 12 +- src/SFML/Audio/SoundFile.cpp | 102 ++++----- src/SFML/Audio/SoundFile.hpp | 10 +- src/SFML/Audio/SoundRecorder.cpp | 30 +-- src/SFML/Audio/SoundSource.cpp | 38 +-- src/SFML/Audio/SoundStream.cpp | 112 ++++----- src/SFML/Graphics/CircleShape.cpp | 20 +- src/SFML/Graphics/ConvexShape.cpp | 8 +- src/SFML/Graphics/Font.cpp | 116 +++++----- src/SFML/Graphics/Image.cpp | 100 ++++---- src/SFML/Graphics/RectangleShape.cpp | 10 +- src/SFML/Graphics/RenderTarget.cpp | 48 ++-- src/SFML/Graphics/RenderTexture.cpp | 28 +-- .../Graphics/RenderTextureImplDefault.cpp | 18 +- .../Graphics/RenderTextureImplDefault.hpp | 6 +- src/SFML/Graphics/RenderTextureImplFBO.cpp | 32 +-- src/SFML/Graphics/RenderTextureImplFBO.hpp | 6 +- src/SFML/Graphics/Shader.cpp | 96 ++++---- src/SFML/Graphics/Shape.cpp | 108 ++++----- src/SFML/Graphics/Sprite.cpp | 72 +++--- src/SFML/Graphics/Text.cpp | 144 ++++++------ src/SFML/Graphics/Texture.cpp | 186 +++++++-------- src/SFML/Graphics/TextureSaver.cpp | 4 +- src/SFML/Graphics/TextureSaver.hpp | 2 +- src/SFML/Graphics/Transform.cpp | 50 ++-- src/SFML/Graphics/Transformable.cpp | 94 ++++---- src/SFML/Graphics/VertexArray.cpp | 42 ++-- src/SFML/Graphics/View.cpp | 124 +++++----- src/SFML/Network/Ftp.cpp | 46 ++-- src/SFML/Network/Http.cpp | 100 ++++---- src/SFML/Network/IpAddress.cpp | 14 +- src/SFML/Network/Packet.cpp | 68 +++--- src/SFML/Network/Socket.cpp | 38 +-- src/SFML/Network/SocketSelector.cpp | 30 +-- src/SFML/Network/TcpSocket.cpp | 30 +-- src/SFML/Network/UdpSocket.cpp | 6 +- src/SFML/System/Clock.cpp | 8 +- src/SFML/System/Lock.cpp | 6 +- src/SFML/System/Mutex.cpp | 8 +- src/SFML/System/String.cpp | 70 +++--- src/SFML/System/Thread.cpp | 22 +- src/SFML/System/ThreadLocal.cpp | 8 +- src/SFML/System/Time.cpp | 10 +- src/SFML/System/Unix/MutexImpl.cpp | 8 +- src/SFML/System/Unix/MutexImpl.hpp | 2 +- src/SFML/System/Unix/ThreadImpl.cpp | 16 +- src/SFML/System/Unix/ThreadImpl.hpp | 4 +- src/SFML/System/Unix/ThreadLocalImpl.cpp | 8 +- src/SFML/System/Unix/ThreadLocalImpl.hpp | 2 +- src/SFML/System/Win32/MutexImpl.cpp | 8 +- src/SFML/System/Win32/MutexImpl.hpp | 2 +- src/SFML/System/Win32/ThreadImpl.cpp | 18 +- src/SFML/System/Win32/ThreadImpl.hpp | 4 +- src/SFML/System/Win32/ThreadLocalImpl.cpp | 8 +- src/SFML/System/Win32/ThreadLocalImpl.hpp | 2 +- src/SFML/Window/Context.cpp | 8 +- src/SFML/Window/GlContext.cpp | 12 +- src/SFML/Window/GlContext.hpp | 2 +- src/SFML/Window/JoystickManager.cpp | 10 +- src/SFML/Window/JoystickManager.hpp | 2 +- src/SFML/Window/Linux/GlxContext.cpp | 154 ++++++------- src/SFML/Window/Linux/GlxContext.hpp | 8 +- src/SFML/Window/Linux/JoystickImpl.cpp | 44 ++-- src/SFML/Window/Linux/JoystickImpl.hpp | 6 +- src/SFML/Window/Linux/WindowImplX11.cpp | 216 +++++++++--------- src/SFML/Window/Linux/WindowImplX11.hpp | 22 +- src/SFML/Window/Win32/JoystickImpl.cpp | 34 +-- src/SFML/Window/Win32/JoystickImpl.hpp | 4 +- src/SFML/Window/Win32/WglContext.cpp | 136 +++++------ src/SFML/Window/Win32/WglContext.hpp | 8 +- src/SFML/Window/Win32/WindowImplWin32.cpp | 118 +++++----- src/SFML/Window/Win32/WindowImplWin32.hpp | 12 +- src/SFML/Window/Window.cpp | 104 ++++----- src/SFML/Window/WindowImpl.cpp | 30 +-- src/SFML/Window/WindowImpl.hpp | 6 +- 124 files changed, 1889 insertions(+), 1889 deletions(-) diff --git a/examples/shader/Effect.hpp b/examples/shader/Effect.hpp index cb5b3668..f979115f 100644 --- a/examples/shader/Effect.hpp +++ b/examples/shader/Effect.hpp @@ -21,23 +21,23 @@ public : const std::string& GetName() const { - return myName; + return m_name; } void Load() { - myIsLoaded = sf::Shader::IsAvailable() && OnLoad(); + m_isLoaded = sf::Shader::IsAvailable() && OnLoad(); } void Update(float time, float x, float y) { - if (myIsLoaded) + if (m_isLoaded) OnUpdate(time, x, y); } void Draw(sf::RenderTarget& target, sf::RenderStates states) const { - if (myIsLoaded) + if (m_isLoaded) { OnDraw(target, states); } @@ -53,8 +53,8 @@ public : protected : Effect(const std::string& name) : - myName(name), - myIsLoaded(false) + m_name(name), + m_isLoaded(false) { } @@ -67,8 +67,8 @@ private : private : - std::string myName; - bool myIsLoaded; + std::string m_name; + bool m_isLoaded; }; #endif // EFFECT_HPP diff --git a/examples/shader/Shader.cpp b/examples/shader/Shader.cpp index 23694d37..8478b825 100644 --- a/examples/shader/Shader.cpp +++ b/examples/shader/Shader.cpp @@ -23,34 +23,34 @@ public : bool OnLoad() { // Load the texture and initialize the sprite - if (!myTexture.LoadFromFile("resources/background.jpg")) + if (!m_texture.LoadFromFile("resources/background.jpg")) return false; - mySprite.SetTexture(myTexture); + m_sprite.SetTexture(m_texture); // Load the shader - if (!myShader.LoadFromFile("resources/pixelate.frag", sf::Shader::Fragment)) + if (!m_shader.LoadFromFile("resources/pixelate.frag", sf::Shader::Fragment)) return false; - myShader.SetParameter("texture", sf::Shader::CurrentTexture); + m_shader.SetParameter("texture", sf::Shader::CurrentTexture); return true; } void OnUpdate(float, float x, float y) { - myShader.SetParameter("pixel_threshold", (x + y) / 30); + m_shader.SetParameter("pixel_threshold", (x + y) / 30); } void OnDraw(sf::RenderTarget& target, sf::RenderStates states) const { - states.Shader = &myShader; - target.Draw(mySprite, states); + states.Shader = &m_shader; + target.Draw(m_sprite, states); } private: - sf::Texture myTexture; - sf::Sprite mySprite; - sf::Shader myShader; + sf::Texture m_texture; + sf::Sprite m_sprite; + sf::Shader m_shader; }; @@ -69,7 +69,7 @@ public : bool OnLoad() { // Create the text - myText.SetString("Praesent suscipit augue in velit pulvinar hendrerit varius purus aliquam.\n" + m_text.SetString("Praesent suscipit augue in velit pulvinar hendrerit varius purus aliquam.\n" "Mauris mi odio, bibendum quis fringilla a, laoreet vel orci. Proin vitae vulputate tortor.\n" "Praesent cursus ultrices justo, ut feugiat ante vehicula quis.\n" "Donec fringilla scelerisque mauris et viverra.\n" @@ -87,11 +87,11 @@ public : "Mauris ultricies dolor sed massa convallis sed aliquet augue fringilla.\n" "Duis erat eros, porta in accumsan in, blandit quis sem.\n" "In hac habitasse platea dictumst. Etiam fringilla est id odio dapibus sit amet semper dui laoreet.\n"); - myText.SetCharacterSize(22); - myText.SetPosition(30, 20); + m_text.SetCharacterSize(22); + m_text.SetPosition(30, 20); // Load the shader - if (!myShader.LoadFromFile("resources/wave.vert", "resources/blur.frag")) + if (!m_shader.LoadFromFile("resources/wave.vert", "resources/blur.frag")) return false; return true; @@ -99,21 +99,21 @@ public : void OnUpdate(float time, float x, float y) { - myShader.SetParameter("wave_phase", time); - myShader.SetParameter("wave_amplitude", x * 40, y * 40); - myShader.SetParameter("blur_radius", (x + y) * 0.008f); + m_shader.SetParameter("wave_phase", time); + m_shader.SetParameter("wave_amplitude", x * 40, y * 40); + m_shader.SetParameter("blur_radius", (x + y) * 0.008f); } void OnDraw(sf::RenderTarget& target, sf::RenderStates states) const { - states.Shader = &myShader; - target.Draw(myText, states); + states.Shader = &m_shader; + target.Draw(m_text, states); } private: - sf::Text myText; - sf::Shader myShader; + sf::Text m_text; + sf::Shader m_shader; }; @@ -132,7 +132,7 @@ public : bool OnLoad() { // Create the points - myPoints.SetPrimitiveType(sf::Points); + m_points.SetPrimitiveType(sf::Points); for (int i = 0; i < 40000; ++i) { float x = static_cast(std::rand() % 800); @@ -140,11 +140,11 @@ public : sf::Uint8 r = std::rand() % 255; sf::Uint8 g = std::rand() % 255; sf::Uint8 b = std::rand() % 255; - myPoints.Append(sf::Vertex(sf::Vector2f(x, y), sf::Color(r, g, b))); + m_points.Append(sf::Vertex(sf::Vector2f(x, y), sf::Color(r, g, b))); } // Load the shader - if (!myShader.LoadFromFile("resources/storm.vert", "resources/blink.frag")) + if (!m_shader.LoadFromFile("resources/storm.vert", "resources/blink.frag")) return false; return true; @@ -153,22 +153,22 @@ public : void OnUpdate(float time, float x, float y) { float radius = 200 + std::cos(time) * 150; - myShader.SetParameter("storm_position", x * 800, y * 600); - myShader.SetParameter("storm_inner_radius", radius / 3); - myShader.SetParameter("storm_total_radius", radius); - myShader.SetParameter("blink_alpha", 0.5f + std::cos(time * 3) * 0.25f); + m_shader.SetParameter("storm_position", x * 800, y * 600); + m_shader.SetParameter("storm_inner_radius", radius / 3); + m_shader.SetParameter("storm_total_radius", radius); + m_shader.SetParameter("blink_alpha", 0.5f + std::cos(time * 3) * 0.25f); } void OnDraw(sf::RenderTarget& target, sf::RenderStates states) const { - states.Shader = &myShader; - target.Draw(myPoints, states); + states.Shader = &m_shader; + target.Draw(m_points, states); } private: - sf::VertexArray myPoints; - sf::Shader myShader; + sf::VertexArray m_points; + sf::Shader m_shader; }; @@ -187,71 +187,71 @@ public : bool OnLoad() { // Create the off-screen surface - if (!mySurface.Create(800, 600)) + if (!m_surface.Create(800, 600)) return false; - mySurface.SetSmooth(true); + m_surface.SetSmooth(true); // Load the textures - if (!myBackgroundTexture.LoadFromFile("resources/sfml.png")) + if (!m_backgroundTexture.LoadFromFile("resources/sfml.png")) return false; - myBackgroundTexture.SetSmooth(true); - if (!myEntityTexture.LoadFromFile("resources/devices.png")) + m_backgroundTexture.SetSmooth(true); + if (!m_entityTexture.LoadFromFile("resources/devices.png")) return false; - myEntityTexture.SetSmooth(true); + m_entityTexture.SetSmooth(true); // Initialize the background sprite - myBackgroundSprite.SetTexture(myBackgroundTexture); - myBackgroundSprite.SetPosition(135, 100); + m_backgroundSprite.SetTexture(m_backgroundTexture); + m_backgroundSprite.SetPosition(135, 100); // Load the moving entities for (int i = 0; i < 6; ++i) { - sf::Sprite entity(myEntityTexture, sf::IntRect(96 * i, 0, 96, 96)); - myEntities.push_back(entity); + sf::Sprite entity(m_entityTexture, sf::IntRect(96 * i, 0, 96, 96)); + m_entities.push_back(entity); } // Load the shader - if (!myShader.LoadFromFile("resources/edge.frag", sf::Shader::Fragment)) + if (!m_shader.LoadFromFile("resources/edge.frag", sf::Shader::Fragment)) return false; - myShader.SetParameter("texture", sf::Shader::CurrentTexture); + m_shader.SetParameter("texture", sf::Shader::CurrentTexture); return true; } void OnUpdate(float time, float x, float y) { - myShader.SetParameter("edge_threshold", 1 - (x + y) / 2); + m_shader.SetParameter("edge_threshold", 1 - (x + y) / 2); // Update the position of the moving entities - for (std::size_t i = 0; i < myEntities.size(); ++i) + for (std::size_t i = 0; i < m_entities.size(); ++i) { - float x = std::cos(0.25f * (time * i + (myEntities.size() - i))) * 300 + 350; - float y = std::sin(0.25f * (time * (myEntities.size() - i) + i)) * 200 + 250; - myEntities[i].SetPosition(x, y); + float x = std::cos(0.25f * (time * i + (m_entities.size() - i))) * 300 + 350; + float y = std::sin(0.25f * (time * (m_entities.size() - i) + i)) * 200 + 250; + m_entities[i].SetPosition(x, y); } // Render the updated scene to the off-screen surface - mySurface.Clear(sf::Color::White); - mySurface.Draw(myBackgroundSprite); - for (std::size_t i = 0; i < myEntities.size(); ++i) - mySurface.Draw(myEntities[i]); - mySurface.Display(); + m_surface.Clear(sf::Color::White); + m_surface.Draw(m_backgroundSprite); + for (std::size_t i = 0; i < m_entities.size(); ++i) + m_surface.Draw(m_entities[i]); + m_surface.Display(); } void OnDraw(sf::RenderTarget& target, sf::RenderStates states) const { - states.Shader = &myShader; - target.Draw(sf::Sprite(mySurface.GetTexture()), states); + states.Shader = &m_shader; + target.Draw(sf::Sprite(m_surface.GetTexture()), states); } private: - sf::RenderTexture mySurface; - sf::Texture myBackgroundTexture; - sf::Texture myEntityTexture; - sf::Sprite myBackgroundSprite; - std::vector myEntities; - sf::Shader myShader; + sf::RenderTexture m_surface; + sf::Texture m_backgroundTexture; + sf::Texture m_entityTexture; + sf::Sprite m_backgroundSprite; + std::vector m_entities; + sf::Shader m_shader; }; diff --git a/examples/voip/Client.cpp b/examples/voip/Client.cpp index 8c2a42a0..d597ab17 100644 --- a/examples/voip/Client.cpp +++ b/examples/voip/Client.cpp @@ -27,8 +27,8 @@ public : /// //////////////////////////////////////////////////////////// NetworkRecorder(const sf::IpAddress& host, unsigned short port) : - myHost(host), - myPort(port) + m_host(host), + m_port(port) { } @@ -40,9 +40,9 @@ private : //////////////////////////////////////////////////////////// virtual bool OnStart() { - if (mySocket.Connect(myHost, myPort) == sf::Socket::Done) + if (m_socket.Connect(m_host, m_port) == sf::Socket::Done) { - std::cout << "Connected to server " << myHost << std::endl; + std::cout << "Connected to server " << m_host << std::endl; return true; } else @@ -63,7 +63,7 @@ private : packet.Append(samples, sampleCount * sizeof(sf::Int16)); // Send the audio packet to the server - return mySocket.Send(packet) == sf::Socket::Done; + return m_socket.Send(packet) == sf::Socket::Done; } //////////////////////////////////////////////////////////// @@ -75,18 +75,18 @@ private : // Send a "end-of-stream" packet sf::Packet packet; packet << endOfStream; - mySocket.Send(packet); + m_socket.Send(packet); // Close the socket - mySocket.Disconnect(); + m_socket.Disconnect(); } //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - sf::IpAddress myHost; ///< Address of the remote host - unsigned short myPort; ///< Remote port - sf::TcpSocket mySocket; ///< Socket used to communicate with the server + sf::IpAddress m_host; ///< Address of the remote host + unsigned short m_port; ///< Remote port + sf::TcpSocket m_socket; ///< Socket used to communicate with the server }; diff --git a/examples/voip/Server.cpp b/examples/voip/Server.cpp index b43f0949..06027ba3 100644 --- a/examples/voip/Server.cpp +++ b/examples/voip/Server.cpp @@ -26,8 +26,8 @@ public : /// //////////////////////////////////////////////////////////// NetworkAudioStream() : - myOffset (0), - myHasFinished(false) + m_offset (0), + m_hasFinished(false) { // Set the sound parameters Initialize(1, 44100); @@ -39,17 +39,17 @@ public : //////////////////////////////////////////////////////////// void Start(unsigned short port) { - if (!myHasFinished) + if (!m_hasFinished) { // Listen to the given port for incoming connections - if (myListener.Listen(port) != sf::Socket::Done) + if (m_listener.Listen(port) != sf::Socket::Done) return; std::cout << "Server is listening to port " << port << ", waiting for connections... " << std::endl; // Wait for a connection - if (myListener.Accept(myClient) != sf::Socket::Done) + if (m_listener.Accept(m_client) != sf::Socket::Done) return; - std::cout << "Client connected: " << myClient.GetRemoteAddress() << std::endl; + std::cout << "Client connected: " << m_client.GetRemoteAddress() << std::endl; // Start playback Play(); @@ -73,26 +73,26 @@ private : virtual bool OnGetData(sf::SoundStream::Chunk& data) { // We have reached the end of the buffer and all audio data have been played : we can stop playback - if ((myOffset >= mySamples.size()) && myHasFinished) + if ((m_offset >= m_samples.size()) && m_hasFinished) return false; // No new data has arrived since last update : wait until we get some - while ((myOffset >= mySamples.size()) && !myHasFinished) + while ((m_offset >= m_samples.size()) && !m_hasFinished) sf::Sleep(sf::Milliseconds(10)); // Copy samples into a local buffer to avoid synchronization problems // (don't forget that we run in two separate threads) { - sf::Lock lock(myMutex); - myTempBuffer.assign(mySamples.begin() + myOffset, mySamples.end()); + sf::Lock lock(m_mutex); + m_tempBuffer.assign(m_samples.begin() + m_offset, m_samples.end()); } // Fill audio data to pass to the stream - data.Samples = &myTempBuffer[0]; - data.SampleCount = myTempBuffer.size(); + data.Samples = &m_tempBuffer[0]; + data.SampleCount = m_tempBuffer.size(); // Update the playing offset - myOffset += myTempBuffer.size(); + m_offset += m_tempBuffer.size(); return true; } @@ -103,7 +103,7 @@ private : //////////////////////////////////////////////////////////// virtual void OnSeek(sf::Time timeOffset) { - myOffset = timeOffset.AsMilliseconds() * GetSampleRate() * GetChannelCount() / 1000; + m_offset = timeOffset.AsMilliseconds() * GetSampleRate() * GetChannelCount() / 1000; } //////////////////////////////////////////////////////////// @@ -112,11 +112,11 @@ private : //////////////////////////////////////////////////////////// void ReceiveLoop() { - while (!myHasFinished) + while (!m_hasFinished) { // Get waiting audio data from the network sf::Packet packet; - if (myClient.Receive(packet) != sf::Socket::Done) + if (m_client.Receive(packet) != sf::Socket::Done) break; // Extract the message ID @@ -132,21 +132,21 @@ private : // Don't forget that the other thread can access the sample array at any time // (so we protect any operation on it with the mutex) { - sf::Lock lock(myMutex); - std::copy(samples, samples + sampleCount, std::back_inserter(mySamples)); + sf::Lock lock(m_mutex); + std::copy(samples, samples + sampleCount, std::back_inserter(m_samples)); } } else if (id == endOfStream) { // End of stream reached : we stop receiving audio data std::cout << "Audio data has been 100% received!" << std::endl; - myHasFinished = true; + m_hasFinished = true; } else { // Something's wrong... std::cout << "Invalid packet received..." << std::endl; - myHasFinished = true; + m_hasFinished = true; } } } @@ -154,13 +154,13 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - sf::TcpListener myListener; - sf::TcpSocket myClient; - sf::Mutex myMutex; - std::vector mySamples; - std::vector myTempBuffer; - std::size_t myOffset; - bool myHasFinished; + sf::TcpListener m_listener; + sf::TcpSocket m_client; + sf::Mutex m_mutex; + std::vector m_samples; + std::vector m_tempBuffer; + std::size_t m_offset; + bool m_hasFinished; }; diff --git a/include/SFML/Audio/Music.hpp b/include/SFML/Audio/Music.hpp index 6100b2e0..6c2db145 100644 --- a/include/SFML/Audio/Music.hpp +++ b/include/SFML/Audio/Music.hpp @@ -162,10 +162,10 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - priv::SoundFile* myFile; ///< Sound file - Time myDuration; ///< Music duration - std::vector mySamples; ///< Temporary buffer of samples - Mutex myMutex; ///< Mutex protecting the data + priv::SoundFile* m_file; ///< Sound file + Time m_duration; ///< Music duration + std::vector m_samples; ///< Temporary buffer of samples + Mutex m_mutex; ///< Mutex protecting the data }; } // namespace sf diff --git a/include/SFML/Audio/Sound.hpp b/include/SFML/Audio/Sound.hpp index 9d2fa623..6830462f 100644 --- a/include/SFML/Audio/Sound.hpp +++ b/include/SFML/Audio/Sound.hpp @@ -215,7 +215,7 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - const SoundBuffer* myBuffer; ///< Sound buffer bound to the source + const SoundBuffer* m_buffer; ///< Sound buffer bound to the source }; } // namespace sf diff --git a/include/SFML/Audio/SoundBuffer.hpp b/include/SFML/Audio/SoundBuffer.hpp index 60d850b5..90f63778 100644 --- a/include/SFML/Audio/SoundBuffer.hpp +++ b/include/SFML/Audio/SoundBuffer.hpp @@ -279,10 +279,10 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - unsigned int myBuffer; ///< OpenAL buffer identifier - std::vector mySamples; ///< Samples buffer - Time myDuration; ///< Sound duration - mutable SoundList mySounds; ///< List of sounds that are using this buffer + unsigned int m_buffer; ///< OpenAL buffer identifier + std::vector m_samples; ///< Samples buffer + Time m_duration; ///< Sound duration + mutable SoundList m_sounds; ///< List of sounds that are using this buffer }; } // namespace sf diff --git a/include/SFML/Audio/SoundBufferRecorder.hpp b/include/SFML/Audio/SoundBufferRecorder.hpp index ec3603c3..35175911 100644 --- a/include/SFML/Audio/SoundBufferRecorder.hpp +++ b/include/SFML/Audio/SoundBufferRecorder.hpp @@ -88,8 +88,8 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - std::vector mySamples; ///< Temporary sample buffer to hold the recorded data - SoundBuffer myBuffer; ///< Sound buffer that will contain the recorded data + std::vector m_samples; ///< Temporary sample buffer to hold the recorded data + SoundBuffer m_buffer; ///< Sound buffer that will contain the recorded data }; } // namespace sf diff --git a/include/SFML/Audio/SoundRecorder.hpp b/include/SFML/Audio/SoundRecorder.hpp index 13b056ce..ecfd6210 100644 --- a/include/SFML/Audio/SoundRecorder.hpp +++ b/include/SFML/Audio/SoundRecorder.hpp @@ -181,10 +181,10 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - Thread myThread; ///< Thread running the background recording task - std::vector 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 m_samples; ///< Buffer to store captured samples + unsigned int m_sampleRate; ///< Sample rate + bool m_isCapturing; ///< Capturing state }; } // namespace sf diff --git a/include/SFML/Audio/SoundSource.hpp b/include/SFML/Audio/SoundSource.hpp index c1352e93..2bdd2b1f 100644 --- a/include/SFML/Audio/SoundSource.hpp +++ b/include/SFML/Audio/SoundSource.hpp @@ -260,7 +260,7 @@ protected : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - unsigned int mySource; ///< OpenAL source identifier + unsigned int m_source; ///< OpenAL source identifier }; } // namespace sf diff --git a/include/SFML/Audio/SoundStream.hpp b/include/SFML/Audio/SoundStream.hpp index 315dd731..9ad6c777 100644 --- a/include/SFML/Audio/SoundStream.hpp +++ b/include/SFML/Audio/SoundStream.hpp @@ -281,15 +281,15 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - Thread myThread; ///< Thread running the background tasks - bool myIsStreaming; ///< Streaming state (true = playing, false = stopped) - unsigned int myBuffers[BufferCount]; ///< Sound buffers used to store temporary audio data - unsigned int myChannelCount; ///< Number of channels (1 = mono, 2 = stereo, ...) - unsigned int mySampleRate; ///< Frequency (samples / second) - Uint32 myFormat; ///< Format of the internal sound buffers - bool myLoop; ///< Loop flag (true to loop, false to play once) - Uint64 mySamplesProcessed; ///< Number of buffers processed since beginning of the stream - bool myEndBuffers[BufferCount]; ///< Each buffer is marked as "end buffer" or not, for proper duration calculation + 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 diff --git a/include/SFML/Graphics/CircleShape.hpp b/include/SFML/Graphics/CircleShape.hpp index 84963c76..9477b953 100644 --- a/include/SFML/Graphics/CircleShape.hpp +++ b/include/SFML/Graphics/CircleShape.hpp @@ -108,8 +108,8 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - float myRadius; ///< Radius of the circle - unsigned int myPointCount; ///< Number of points composing the circle + float m_radius; ///< Radius of the circle + unsigned int m_pointCount; ///< Number of points composing the circle }; } // namespace sf diff --git a/include/SFML/Graphics/ConvexShape.hpp b/include/SFML/Graphics/ConvexShape.hpp index a1441659..a3bb4e34 100644 --- a/include/SFML/Graphics/ConvexShape.hpp +++ b/include/SFML/Graphics/ConvexShape.hpp @@ -109,7 +109,7 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - std::vector myPoints; ///< Points composing the convex polygon + std::vector m_points; ///< Points composing the convex polygon }; } // namespace sf diff --git a/include/SFML/Graphics/Drawable.hpp b/include/SFML/Graphics/Drawable.hpp index 130ef361..0fe51a1c 100644 --- a/include/SFML/Graphics/Drawable.hpp +++ b/include/SFML/Graphics/Drawable.hpp @@ -103,11 +103,11 @@ private : /// virtual void Draw(sf::RenderTarget& target, RenderStates states) const /// { /// // You can draw other high-level objects -/// target.Draw(mySprite, states); +/// target.Draw(m_sprite, states); /// /// // ... or use the low-level API -/// states.Texture = &myTexture; -/// target.Draw(myVertices, states); +/// states.Texture = &m_texture; +/// target.Draw(m_vertices, states); /// /// // ... or draw with OpenGL directly /// glBegin(GL_QUADS); @@ -115,9 +115,9 @@ private : /// glEnd(); /// } /// -/// sf::Sprite mySprite; -/// sf::Texture myTexture; -/// sf::VertexArray myVertices; +/// sf::Sprite m_sprite; +/// sf::Texture m_texture; +/// sf::VertexArray m_vertices; /// }; /// \endcode /// diff --git a/include/SFML/Graphics/Font.hpp b/include/SFML/Graphics/Font.hpp index a02771e3..2bfa4862 100644 --- a/include/SFML/Graphics/Font.hpp +++ b/include/SFML/Graphics/Font.hpp @@ -293,12 +293,12 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - void* myLibrary; ///< Pointer to the internal library interface (it is typeless to avoid exposing implementation details) - void* myFace; ///< Pointer to the internal font face (it is typeless to avoid exposing implementation details) - void* myStreamRec; ///< Pointer to the stream rec instance (it is typeless to avoid exposing implementation details) - int* myRefCount; ///< Reference counter used by implicit sharing - mutable PageTable myPages; ///< Table containing the glyphs pages by character size - mutable std::vector myPixelBuffer; ///< Pixel buffer holding a glyph's pixels before being written to the texture + 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 m_pixelBuffer; ///< Pixel buffer holding a glyph's pixels before being written to the texture }; } // namespace sf diff --git a/include/SFML/Graphics/Image.hpp b/include/SFML/Graphics/Image.hpp index a43cece2..32031866 100644 --- a/include/SFML/Graphics/Image.hpp +++ b/include/SFML/Graphics/Image.hpp @@ -267,9 +267,9 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - unsigned int myWidth; ///< Image width - unsigned int myHeight; ///< Image Height - std::vector myPixels; ///< Pixels of the image + unsigned int m_width; ///< Image width + unsigned int m_height; ///< Image Height + std::vector m_pixels; ///< Pixels of the image }; } // namespace sf diff --git a/include/SFML/Graphics/RectangleShape.hpp b/include/SFML/Graphics/RectangleShape.hpp index 426c169e..188834e4 100644 --- a/include/SFML/Graphics/RectangleShape.hpp +++ b/include/SFML/Graphics/RectangleShape.hpp @@ -95,7 +95,7 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - Vector2f mySize; ///< Size of the rectangle + Vector2f m_size; ///< Size of the rectangle }; } // namespace sf diff --git a/include/SFML/Graphics/RenderTarget.hpp b/include/SFML/Graphics/RenderTarget.hpp index 1dc06617..cc942b6d 100644 --- a/include/SFML/Graphics/RenderTarget.hpp +++ b/include/SFML/Graphics/RenderTarget.hpp @@ -366,9 +366,9 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - View myDefaultView; ///< Default view - View myView; ///< Current view - StatesCache myCache; ///< Render states cache + View m_defaultView; ///< Default view + View m_view; ///< Current view + StatesCache m_cache; ///< Render states cache }; } // namespace sf diff --git a/include/SFML/Graphics/RenderTexture.hpp b/include/SFML/Graphics/RenderTexture.hpp index 8398250c..132d5961 100644 --- a/include/SFML/Graphics/RenderTexture.hpp +++ b/include/SFML/Graphics/RenderTexture.hpp @@ -181,8 +181,8 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - priv::RenderTextureImpl* myImpl; ///< Platform/hardware specific implementation - Texture myTexture; ///< Target texture to draw on + priv::RenderTextureImpl* m_impl; ///< Platform/hardware specific implementation + Texture m_texture; ///< Target texture to draw on }; } // namespace sf diff --git a/include/SFML/Graphics/Shader.hpp b/include/SFML/Graphics/Shader.hpp index fcc10837..4e19bd04 100644 --- a/include/SFML/Graphics/Shader.hpp +++ b/include/SFML/Graphics/Shader.hpp @@ -522,9 +522,9 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - unsigned int myShaderProgram; ///< OpenGL identifier for the program - int myCurrentTexture; ///< Location of the current texture in the shader - TextureTable myTextures; ///< Texture variables in the shader, mapped to their location + 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 }; } // namespace sf diff --git a/include/SFML/Graphics/Shape.hpp b/include/SFML/Graphics/Shape.hpp index 61c123a2..21a4f38c 100644 --- a/include/SFML/Graphics/Shape.hpp +++ b/include/SFML/Graphics/Shape.hpp @@ -291,15 +291,15 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - const Texture* myTexture; ///< Texture of the shape - IntRect myTextureRect; ///< Rectangle defining the area of the source texture to display - Color myFillColor; ///< Fill color - Color myOutlineColor; ///< Outline color - float myOutlineThickness; ///< Thickness of the shape's outline - VertexArray myVertices; ///< Vertex array containing the fill geometry - VertexArray myOutlineVertices; ///< Vertex array containing the outline geometry - FloatRect myInsideBounds; ///< Bounding rectangle of the inside (fill) - FloatRect myBounds; ///< Bounding rectangle of the whole shape (outline + fill) + 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 diff --git a/include/SFML/Graphics/Sprite.hpp b/include/SFML/Graphics/Sprite.hpp index 330e87b3..d4ba318c 100644 --- a/include/SFML/Graphics/Sprite.hpp +++ b/include/SFML/Graphics/Sprite.hpp @@ -215,9 +215,9 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - Vertex myVertices[4]; ///< Vertices defining the sprite's geometry - const Texture* myTexture; ///< Texture of the sprite - IntRect myTextureRect; ///< Rectangle defining the area of the source texture to display + 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 diff --git a/include/SFML/Graphics/Text.hpp b/include/SFML/Graphics/Text.hpp index 5a024b99..542f8b1f 100644 --- a/include/SFML/Graphics/Text.hpp +++ b/include/SFML/Graphics/Text.hpp @@ -284,13 +284,13 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - String myString; ///< String to display - const Font* myFont; ///< Font used to display the string - unsigned int myCharacterSize; ///< Base size of characters, in pixels - Uint32 myStyle; ///< Text style (see Style enum) - Color myColor; ///< Text color - VertexArray myVertices; ///< Vertex array containing the text's geometry - FloatRect myBounds; ///< Bounding rectangle of the text (in local coordinates) + 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 diff --git a/include/SFML/Graphics/Texture.hpp b/include/SFML/Graphics/Texture.hpp index fd40b599..b6b26c7d 100644 --- a/include/SFML/Graphics/Texture.hpp +++ b/include/SFML/Graphics/Texture.hpp @@ -489,15 +489,15 @@ 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 - bool myIsRepeated; ///< Is the texture in repeat mode? - mutable bool myPixelsFlipped; ///< To work around the inconsistency in Y orientation - Uint64 myCacheId; ///< Unique number that identifies the texture to the render target's cache + unsigned int m_width; ///< Image width + unsigned int m_height; ///< Image Height + unsigned int m_textureWidth; ///< Actual texture width (can be greater than image width because of padding) + unsigned int m_textureHeight; ///< Actual texture height (can be greater than image height 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 diff --git a/include/SFML/Graphics/Transform.hpp b/include/SFML/Graphics/Transform.hpp index 334e45f4..a4ef7f8f 100644 --- a/include/SFML/Graphics/Transform.hpp +++ b/include/SFML/Graphics/Transform.hpp @@ -358,7 +358,7 @@ private: //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - float myMatrix[16]; ///< 4x4 matrix defining the transformation + float m_matrix[16]; ///< 4x4 matrix defining the transformation }; //////////////////////////////////////////////////////////// diff --git a/include/SFML/Graphics/Transformable.hpp b/include/SFML/Graphics/Transformable.hpp index c4bb5276..eeade01d 100644 --- a/include/SFML/Graphics/Transformable.hpp +++ b/include/SFML/Graphics/Transformable.hpp @@ -316,14 +316,14 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - Vector2f myOrigin; ///< Origin of translation/rotation/scaling of the object - Vector2f myPosition; ///< Position of the object in the 2D world - float myRotation; ///< Orientation of the object, in degrees - Vector2f myScale; ///< Scale of the object - mutable Transform myTransform; ///< Combined transformation of the object - mutable bool myTransformNeedUpdate; ///< Does the transform need to be recomputed? - mutable Transform myInverseTransform; ///< Combined transformation of the object - mutable bool myInverseTransformNeedUpdate; ///< Does the transform need to be recomputed? + 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 diff --git a/include/SFML/Graphics/VertexArray.hpp b/include/SFML/Graphics/VertexArray.hpp index 8f07f51c..db6116a5 100644 --- a/include/SFML/Graphics/VertexArray.hpp +++ b/include/SFML/Graphics/VertexArray.hpp @@ -187,8 +187,8 @@ private: //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - std::vector myVertices; ///< Vertices contained in the array - PrimitiveType myPrimitiveType; ///< Type of primitives to draw + std::vector m_vertices; ///< Vertices contained in the array + PrimitiveType m_primitiveType; ///< Type of primitives to draw }; } // namespace sf diff --git a/include/SFML/Graphics/View.hpp b/include/SFML/Graphics/View.hpp index f280c77c..03da78d5 100644 --- a/include/SFML/Graphics/View.hpp +++ b/include/SFML/Graphics/View.hpp @@ -269,14 +269,14 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - Vector2f myCenter; ///< Center of the view, in scene coordinates - Vector2f mySize; ///< Size of the view, in scene coordinates - float myRotation; ///< Angle of rotation of the view rectangle, in degrees - FloatRect myViewport; ///< Viewport rectangle, expressed as a factor of the render-target's size - mutable Transform myTransform; ///< Precomputed projection transform corresponding to the view - mutable Transform myInverseTransform; ///< Precomputed inverse projection transform corresponding to the view - mutable bool myTransformUpdated; ///< Internal state telling if the transform needs to be updated - mutable bool myInvTransformUpdated; ///< Internal state telling if the inverse transform 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 diff --git a/include/SFML/Network/Ftp.hpp b/include/SFML/Network/Ftp.hpp index afed5b98..db98c014 100644 --- a/include/SFML/Network/Ftp.hpp +++ b/include/SFML/Network/Ftp.hpp @@ -177,8 +177,8 @@ public : //////////////////////////////////////////////////////////// // 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 }; //////////////////////////////////////////////////////////// @@ -210,7 +210,7 @@ public : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - std::string myDirectory; ///< Directory extracted from the response message + std::string m_directory; ///< Directory extracted from the response message }; @@ -244,7 +244,7 @@ public : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - std::vector myFilenames; ///< Filenames extracted from the data + std::vector m_filenames; ///< Filenames extracted from the data }; @@ -517,7 +517,7 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - TcpSocket myCommandSocket; ///< Socket holding the control connection with the server + TcpSocket m_commandSocket; ///< Socket holding the control connection with the server }; } // namespace sf diff --git a/include/SFML/Network/Http.hpp b/include/SFML/Network/Http.hpp index d1e14526..c386d64b 100644 --- a/include/SFML/Network/Http.hpp +++ b/include/SFML/Network/Http.hpp @@ -176,12 +176,12 @@ public : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - FieldTable myFields; ///< Fields of the header associated to their value - 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 }; //////////////////////////////////////////////////////////// @@ -324,11 +324,11 @@ 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 }; //////////////////////////////////////////////////////////// @@ -395,10 +395,10 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - TcpSocket 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 diff --git a/include/SFML/Network/IpAddress.hpp b/include/SFML/Network/IpAddress.hpp index 1d8fc14b..71b372e6 100644 --- a/include/SFML/Network/IpAddress.hpp +++ b/include/SFML/Network/IpAddress.hpp @@ -190,7 +190,7 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - Uint32 myAddress; ///< Address stored as an unsigned 32 bits integer + Uint32 m_address; ///< Address stored as an unsigned 32 bits integer }; //////////////////////////////////////////////////////////// diff --git a/include/SFML/Network/Packet.hpp b/include/SFML/Network/Packet.hpp index 562b9f36..34a1aa5f 100644 --- a/include/SFML/Network/Packet.hpp +++ b/include/SFML/Network/Packet.hpp @@ -272,9 +272,9 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - std::vector 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 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 diff --git a/include/SFML/Network/Socket.hpp b/include/SFML/Network/Socket.hpp index ae6c77f5..19f8afec 100644 --- a/include/SFML/Network/Socket.hpp +++ b/include/SFML/Network/Socket.hpp @@ -172,9 +172,9 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - Type myType; ///< Type of the socket (TCP or UDP) - SocketHandle mySocket; ///< Socket descriptor - bool myIsBlocking; ///< Current blocking mode of the socket + 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 diff --git a/include/SFML/Network/SocketSelector.hpp b/include/SFML/Network/SocketSelector.hpp index a6cfdc71..85bc6207 100644 --- a/include/SFML/Network/SocketSelector.hpp +++ b/include/SFML/Network/SocketSelector.hpp @@ -157,7 +157,7 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - SocketSelectorImpl* myImpl; ///< Opaque pointer to the implementation (which requires OS-specific types) + SocketSelectorImpl* m_impl; ///< Opaque pointer to the implementation (which requires OS-specific types) }; } // namespace sf diff --git a/include/SFML/Network/TcpSocket.hpp b/include/SFML/Network/TcpSocket.hpp index 674ca113..c981f8c3 100644 --- a/include/SFML/Network/TcpSocket.hpp +++ b/include/SFML/Network/TcpSocket.hpp @@ -204,7 +204,7 @@ private: //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - PendingPacket myPendingPacket; ///< Temporary data of the packet currently being received + PendingPacket m_pendingPacket; ///< Temporary data of the packet currently being received }; } // namespace sf diff --git a/include/SFML/Network/UdpSocket.hpp b/include/SFML/Network/UdpSocket.hpp index b85eecaa..aeefedf2 100644 --- a/include/SFML/Network/UdpSocket.hpp +++ b/include/SFML/Network/UdpSocket.hpp @@ -187,7 +187,7 @@ private: //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - std::vector myBuffer; ///< Temporary buffer holding the received data in Receive(Packet) + std::vector m_buffer; ///< Temporary buffer holding the received data in Receive(Packet) }; } // namespace sf diff --git a/include/SFML/System/Clock.hpp b/include/SFML/System/Clock.hpp index c4bff833..43ab9936 100644 --- a/include/SFML/System/Clock.hpp +++ b/include/SFML/System/Clock.hpp @@ -78,7 +78,7 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - Time myStartTime; ///< Time of last reset, in microseconds + Time m_startTime; ///< Time of last reset, in microseconds }; } // namespace sf diff --git a/include/SFML/System/Lock.hpp b/include/SFML/System/Lock.hpp index 775efde1..e92b68eb 100644 --- a/include/SFML/System/Lock.hpp +++ b/include/SFML/System/Lock.hpp @@ -67,7 +67,7 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - Mutex& myMutex; ///< Mutex to lock / unlock + Mutex& m_mutex; ///< Mutex to lock / unlock }; } // namespace sf diff --git a/include/SFML/System/Mutex.hpp b/include/SFML/System/Mutex.hpp index 30d2930d..a3978bbb 100644 --- a/include/SFML/System/Mutex.hpp +++ b/include/SFML/System/Mutex.hpp @@ -85,7 +85,7 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - priv::MutexImpl* myMutexImpl; ///< OS-specific implementation + priv::MutexImpl* m_mutexImpl; ///< OS-specific implementation }; } // namespace sf diff --git a/include/SFML/System/String.hpp b/include/SFML/System/String.hpp index 45ef43ce..d8ab09a3 100644 --- a/include/SFML/System/String.hpp +++ b/include/SFML/System/String.hpp @@ -400,7 +400,7 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - std::basic_string myString; ///< Internal string of UTF-32 characters + std::basic_string m_string; ///< Internal string of UTF-32 characters }; //////////////////////////////////////////////////////////// diff --git a/include/SFML/System/Thread.hpp b/include/SFML/System/Thread.hpp index 852eb48a..19c86dc1 100644 --- a/include/SFML/System/Thread.hpp +++ b/include/SFML/System/Thread.hpp @@ -186,8 +186,8 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - priv::ThreadImpl* myImpl; ///< OS-specific implementation of the thread - priv::ThreadFunc* myEntryPoint; ///< Abstraction of the function to run + priv::ThreadImpl* m_impl; ///< OS-specific implementation of the thread + priv::ThreadFunc* m_entryPoint; ///< Abstraction of the function to run }; #include diff --git a/include/SFML/System/Thread.inl b/include/SFML/System/Thread.inl index 2cd1c4d9..4f84ed18 100644 --- a/include/SFML/System/Thread.inl +++ b/include/SFML/System/Thread.inl @@ -35,29 +35,29 @@ struct ThreadFunc template struct ThreadFunctor : ThreadFunc { - ThreadFunctor(T functor) : myFunctor(functor) {} - virtual void Run() {myFunctor();} - T myFunctor; + 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 struct ThreadFunctorWithArg : ThreadFunc { - ThreadFunctorWithArg(F function, A arg) : myFunction(function), myArg(arg) {} - virtual void Run() {myFunction(myArg);} - F myFunction; - A myArg; + 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 struct ThreadMemberFunc : ThreadFunc { - ThreadMemberFunc(void(C::*function)(), C* object) : myFunction(function), myObject(object) {} - virtual void Run() {(myObject->*myFunction)();} - void(C::*myFunction)(); - C* myObject; + 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 @@ -66,8 +66,8 @@ struct ThreadMemberFunc : ThreadFunc //////////////////////////////////////////////////////////// template Thread::Thread(F functor) : -myImpl (NULL), -myEntryPoint(new priv::ThreadFunctor(functor)) +m_impl (NULL), +m_entryPoint(new priv::ThreadFunctor(functor)) { } @@ -75,8 +75,8 @@ myEntryPoint(new priv::ThreadFunctor(functor)) //////////////////////////////////////////////////////////// template Thread::Thread(F function, A argument) : -myImpl (NULL), -myEntryPoint(new priv::ThreadFunctorWithArg(function, argument)) +m_impl (NULL), +m_entryPoint(new priv::ThreadFunctorWithArg(function, argument)) { } @@ -84,7 +84,7 @@ myEntryPoint(new priv::ThreadFunctorWithArg(function, argument)) //////////////////////////////////////////////////////////// template Thread::Thread(void(C::*function)(), C* object) : -myImpl (NULL), -myEntryPoint(new priv::ThreadMemberFunc(function, object)) +m_impl (NULL), +m_entryPoint(new priv::ThreadMemberFunc(function, object)) { } diff --git a/include/SFML/System/ThreadLocal.hpp b/include/SFML/System/ThreadLocal.hpp index 94d80309..ec7d5225 100644 --- a/include/SFML/System/ThreadLocal.hpp +++ b/include/SFML/System/ThreadLocal.hpp @@ -83,7 +83,7 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - priv::ThreadLocalImpl* myImpl; ///< Pointer to the OS specific implementation + priv::ThreadLocalImpl* m_impl; ///< Pointer to the OS specific implementation }; } // namespace sf diff --git a/include/SFML/System/Time.hpp b/include/SFML/System/Time.hpp index b42173b3..c18fbc9a 100644 --- a/include/SFML/System/Time.hpp +++ b/include/SFML/System/Time.hpp @@ -106,7 +106,7 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - Int64 myMicroseconds; ///< Time value stored as microseconds + Int64 m_microseconds; ///< Time value stored as microseconds }; //////////////////////////////////////////////////////////// diff --git a/include/SFML/Window/Context.hpp b/include/SFML/Window/Context.hpp index 1a3b408f..ed70642a 100644 --- a/include/SFML/Window/Context.hpp +++ b/include/SFML/Window/Context.hpp @@ -95,7 +95,7 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - priv::GlContext* myContext; ///< Internal OpenGL context + priv::GlContext* m_context; ///< Internal OpenGL context }; } // namespace sf diff --git a/include/SFML/Window/Window.hpp b/include/SFML/Window/Window.hpp index c73bf2eb..4a3d677a 100644 --- a/include/SFML/Window/Window.hpp +++ b/include/SFML/Window/Window.hpp @@ -467,10 +467,10 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - priv::WindowImpl* myImpl; ///< Platform-specific implementation of the window - priv::GlContext* myContext; ///< Platform-specific implementation of the OpenGL context - Clock myClock; ///< Clock for measuring the elapsed time between frames - Time myFrameTimeLimit; ///< Current framerate limit + 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 }; } // namespace sf diff --git a/src/SFML/Audio/Music.cpp b/src/SFML/Audio/Music.cpp index 5926c6be..bbb9463b 100644 --- a/src/SFML/Audio/Music.cpp +++ b/src/SFML/Audio/Music.cpp @@ -37,8 +37,8 @@ namespace sf { //////////////////////////////////////////////////////////// Music::Music() : -myFile (new priv::SoundFile), -myDuration() +m_file (new priv::SoundFile), +m_duration() { } @@ -50,7 +50,7 @@ Music::~Music() // We must stop before destroying the file :) Stop(); - delete myFile; + delete m_file; } @@ -61,7 +61,7 @@ bool Music::OpenFromFile(const std::string& filename) Stop(); // Open the underlying sound file - if (!myFile->OpenRead(filename)) + if (!m_file->OpenRead(filename)) return false; // Perform common initializations @@ -78,7 +78,7 @@ bool Music::OpenFromMemory(const void* data, std::size_t sizeInBytes) Stop(); // Open the underlying sound file - if (!myFile->OpenRead(data, sizeInBytes)) + if (!m_file->OpenRead(data, sizeInBytes)) return false; // Perform common initializations @@ -95,7 +95,7 @@ bool Music::OpenFromStream(InputStream& stream) Stop(); // Open the underlying sound file - if (!myFile->OpenRead(stream)) + if (!m_file->OpenRead(stream)) return false; // Perform common initializations @@ -108,30 +108,30 @@ bool Music::OpenFromStream(InputStream& stream) //////////////////////////////////////////////////////////// Time Music::GetDuration() const { - return myDuration; + return m_duration; } //////////////////////////////////////////////////////////// bool Music::OnGetData(SoundStream::Chunk& data) { - Lock lock(myMutex); + Lock lock(m_mutex); // Fill the chunk parameters - data.Samples = &mySamples[0]; - data.SampleCount = myFile->Read(&mySamples[0], mySamples.size()); + data.Samples = &m_samples[0]; + data.SampleCount = m_file->Read(&m_samples[0], m_samples.size()); // Check if we have reached the end of the audio file - return data.SampleCount == mySamples.size(); + return data.SampleCount == m_samples.size(); } //////////////////////////////////////////////////////////// void Music::OnSeek(Time timeOffset) { - Lock lock(myMutex); + Lock lock(m_mutex); - myFile->Seek(timeOffset); + m_file->Seek(timeOffset); } @@ -139,13 +139,13 @@ void Music::OnSeek(Time timeOffset) void Music::Initialize() { // Compute the music duration - myDuration = Seconds(static_cast(myFile->GetSampleCount()) / myFile->GetSampleRate() / myFile->GetChannelCount()); + m_duration = Seconds(static_cast(m_file->GetSampleCount()) / m_file->GetSampleRate() / m_file->GetChannelCount()); // Resize the internal buffer so that it can contain 1 second of audio samples - mySamples.resize(myFile->GetSampleRate() * myFile->GetChannelCount()); + m_samples.resize(m_file->GetSampleRate() * m_file->GetChannelCount()); // Initialize the stream - SoundStream::Initialize(myFile->GetChannelCount(), myFile->GetSampleRate()); + SoundStream::Initialize(m_file->GetChannelCount(), m_file->GetSampleRate()); } } // namespace sf diff --git a/src/SFML/Audio/Sound.cpp b/src/SFML/Audio/Sound.cpp index 025979c8..9695cd06 100644 --- a/src/SFML/Audio/Sound.cpp +++ b/src/SFML/Audio/Sound.cpp @@ -34,14 +34,14 @@ namespace sf { //////////////////////////////////////////////////////////// Sound::Sound() : -myBuffer(NULL) +m_buffer(NULL) { } //////////////////////////////////////////////////////////// Sound::Sound(const SoundBuffer& buffer) : -myBuffer(NULL) +m_buffer(NULL) { SetBuffer(buffer); } @@ -50,10 +50,10 @@ myBuffer(NULL) //////////////////////////////////////////////////////////// Sound::Sound(const Sound& copy) : SoundSource(copy), -myBuffer (NULL) +m_buffer (NULL) { - if (copy.myBuffer) - SetBuffer(*copy.myBuffer); + if (copy.m_buffer) + SetBuffer(*copy.m_buffer); SetLoop(copy.GetLoop()); } @@ -62,29 +62,29 @@ myBuffer (NULL) Sound::~Sound() { Stop(); - if (myBuffer) - myBuffer->DetachSound(this); + if (m_buffer) + m_buffer->DetachSound(this); } //////////////////////////////////////////////////////////// void Sound::Play() { - ALCheck(alSourcePlay(mySource)); + ALCheck(alSourcePlay(m_source)); } //////////////////////////////////////////////////////////// void Sound::Pause() { - ALCheck(alSourcePause(mySource)); + ALCheck(alSourcePause(m_source)); } //////////////////////////////////////////////////////////// void Sound::Stop() { - ALCheck(alSourceStop(mySource)); + ALCheck(alSourceStop(m_source)); } @@ -92,37 +92,37 @@ void Sound::Stop() void Sound::SetBuffer(const SoundBuffer& buffer) { // First detach from the previous buffer - if (myBuffer) + if (m_buffer) { Stop(); - myBuffer->DetachSound(this); + m_buffer->DetachSound(this); } // Assign and use the new buffer - myBuffer = &buffer; - myBuffer->AttachSound(this); - ALCheck(alSourcei(mySource, AL_BUFFER, myBuffer->myBuffer)); + m_buffer = &buffer; + m_buffer->AttachSound(this); + ALCheck(alSourcei(m_source, AL_BUFFER, m_buffer->m_buffer)); } //////////////////////////////////////////////////////////// void Sound::SetLoop(bool Loop) { - ALCheck(alSourcei(mySource, AL_LOOPING, Loop)); + ALCheck(alSourcei(m_source, AL_LOOPING, Loop)); } //////////////////////////////////////////////////////////// void Sound::SetPlayingOffset(Time timeOffset) { - ALCheck(alSourcef(mySource, AL_SEC_OFFSET, timeOffset.AsSeconds())); + ALCheck(alSourcef(m_source, AL_SEC_OFFSET, timeOffset.AsSeconds())); } //////////////////////////////////////////////////////////// const SoundBuffer* Sound::GetBuffer() const { - return myBuffer; + return m_buffer; } @@ -130,7 +130,7 @@ const SoundBuffer* Sound::GetBuffer() const bool Sound::GetLoop() const { ALint loop; - ALCheck(alGetSourcei(mySource, AL_LOOPING, &loop)); + ALCheck(alGetSourcei(m_source, AL_LOOPING, &loop)); return loop != 0; } @@ -140,7 +140,7 @@ bool Sound::GetLoop() const Time Sound::GetPlayingOffset() const { ALfloat seconds = 0.f; - ALCheck(alGetSourcef(mySource, AL_SEC_OFFSET, &seconds)); + ALCheck(alGetSourcef(m_source, AL_SEC_OFFSET, &seconds)); return Seconds(seconds); } @@ -160,16 +160,16 @@ Sound& Sound::operator =(const Sound& right) // the list of sound instances contained in the buffers // Detach the sound instance from the previous buffer (if any) - if (myBuffer) + if (m_buffer) { Stop(); - myBuffer->DetachSound(this); - myBuffer = NULL; + m_buffer->DetachSound(this); + m_buffer = NULL; } // Copy the sound attributes - if (right.myBuffer) - SetBuffer(*right.myBuffer); + if (right.m_buffer) + SetBuffer(*right.m_buffer); SetLoop(right.GetLoop()); SetPitch(right.GetPitch()); SetVolume(right.GetVolume()); @@ -189,8 +189,8 @@ void Sound::ResetBuffer() Stop(); // Detach the buffer - ALCheck(alSourcei(mySource, AL_BUFFER, 0)); - myBuffer = NULL; + ALCheck(alSourcei(m_source, AL_BUFFER, 0)); + m_buffer = NULL; } } // namespace sf diff --git a/src/SFML/Audio/SoundBuffer.cpp b/src/SFML/Audio/SoundBuffer.cpp index daa6a2f7..e6ba9b80 100644 --- a/src/SFML/Audio/SoundBuffer.cpp +++ b/src/SFML/Audio/SoundBuffer.cpp @@ -38,25 +38,25 @@ namespace sf { //////////////////////////////////////////////////////////// SoundBuffer::SoundBuffer() : -myBuffer (0), -myDuration() +m_buffer (0), +m_duration() { priv::EnsureALInit(); // Create the buffer - ALCheck(alGenBuffers(1, &myBuffer)); + ALCheck(alGenBuffers(1, &m_buffer)); } //////////////////////////////////////////////////////////// SoundBuffer::SoundBuffer(const SoundBuffer& copy) : -myBuffer (0), -mySamples (copy.mySamples), -myDuration(copy.myDuration), -mySounds () // don't copy the attached sounds +m_buffer (0), +m_samples (copy.m_samples), +m_duration(copy.m_duration), +m_sounds () // don't copy the attached sounds { // Create the buffer - ALCheck(alGenBuffers(1, &myBuffer)); + ALCheck(alGenBuffers(1, &m_buffer)); // Update the internal buffer with the new samples Update(copy.GetChannelCount(), copy.GetSampleRate()); @@ -67,12 +67,12 @@ mySounds () // don't copy the attached sounds SoundBuffer::~SoundBuffer() { // First detach the buffer from the sounds that use it (to avoid OpenAL errors) - for (SoundList::const_iterator it = mySounds.begin(); it != mySounds.end(); ++it) + for (SoundList::const_iterator it = m_sounds.begin(); it != m_sounds.end(); ++it) (*it)->ResetBuffer(); // Destroy the buffer - if (myBuffer) - ALCheck(alDeleteBuffers(1, &myBuffer)); + if (m_buffer) + ALCheck(alDeleteBuffers(1, &m_buffer)); } @@ -115,7 +115,7 @@ bool SoundBuffer::LoadFromSamples(const Int16* samples, std::size_t sampleCount, if (samples && sampleCount && channelCount && sampleRate) { // Copy the new audio samples - mySamples.assign(samples, samples + sampleCount); + m_samples.assign(samples, samples + sampleCount); // Update the internal buffer with the new samples return Update(channelCount, sampleRate); @@ -143,7 +143,7 @@ bool SoundBuffer::SaveToFile(const std::string& filename) const if (file.OpenWrite(filename, GetChannelCount(), GetSampleRate())) { // Write the samples to the opened file - file.Write(&mySamples[0], mySamples.size()); + file.Write(&m_samples[0], m_samples.size()); return true; } @@ -157,14 +157,14 @@ bool SoundBuffer::SaveToFile(const std::string& filename) const //////////////////////////////////////////////////////////// const Int16* SoundBuffer::GetSamples() const { - return mySamples.empty() ? NULL : &mySamples[0]; + return m_samples.empty() ? NULL : &m_samples[0]; } //////////////////////////////////////////////////////////// std::size_t SoundBuffer::GetSampleCount() const { - return mySamples.size(); + return m_samples.size(); } @@ -172,7 +172,7 @@ std::size_t SoundBuffer::GetSampleCount() const unsigned int SoundBuffer::GetSampleRate() const { ALint sampleRate; - ALCheck(alGetBufferi(myBuffer, AL_FREQUENCY, &sampleRate)); + ALCheck(alGetBufferi(m_buffer, AL_FREQUENCY, &sampleRate)); return sampleRate; } @@ -182,7 +182,7 @@ unsigned int SoundBuffer::GetSampleRate() const unsigned int SoundBuffer::GetChannelCount() const { ALint channelCount; - ALCheck(alGetBufferi(myBuffer, AL_CHANNELS, &channelCount)); + ALCheck(alGetBufferi(m_buffer, AL_CHANNELS, &channelCount)); return channelCount; } @@ -191,7 +191,7 @@ unsigned int SoundBuffer::GetChannelCount() const //////////////////////////////////////////////////////////// Time SoundBuffer::GetDuration() const { - return myDuration; + return m_duration; } @@ -200,10 +200,10 @@ SoundBuffer& SoundBuffer::operator =(const SoundBuffer& right) { SoundBuffer temp(right); - std::swap(mySamples, temp.mySamples); - std::swap(myBuffer, temp.myBuffer); - std::swap(myDuration, temp.myDuration); - std::swap(mySounds, temp.mySounds); // swap sounds too, so that they are detached when temp is destroyed + std::swap(m_samples, temp.m_samples); + std::swap(m_buffer, temp.m_buffer); + std::swap(m_duration, temp.m_duration); + std::swap(m_sounds, temp.m_sounds); // swap sounds too, so that they are detached when temp is destroyed return *this; } @@ -218,8 +218,8 @@ bool SoundBuffer::Initialize(priv::SoundFile& file) unsigned int sampleRate = file.GetSampleRate(); // Read the samples from the provided file - mySamples.resize(sampleCount); - if (file.Read(&mySamples[0], sampleCount) == sampleCount) + m_samples.resize(sampleCount); + if (file.Read(&m_samples[0], sampleCount) == sampleCount) { // Update the internal buffer with the new samples return Update(channelCount, sampleRate); @@ -235,7 +235,7 @@ bool SoundBuffer::Initialize(priv::SoundFile& file) bool SoundBuffer::Update(unsigned int channelCount, unsigned int sampleRate) { // Check parameters - if (!channelCount || !sampleRate || mySamples.empty()) + if (!channelCount || !sampleRate || m_samples.empty()) return false; // Find the good format according to the number of channels @@ -249,11 +249,11 @@ bool SoundBuffer::Update(unsigned int channelCount, unsigned int sampleRate) } // Fill the buffer - ALsizei size = static_cast(mySamples.size()) * sizeof(Int16); - ALCheck(alBufferData(myBuffer, format, &mySamples[0], size, sampleRate)); + ALsizei size = static_cast(m_samples.size()) * sizeof(Int16); + ALCheck(alBufferData(m_buffer, format, &m_samples[0], size, sampleRate)); // Compute the duration - myDuration = Milliseconds(1000 * mySamples.size() / sampleRate / channelCount); + m_duration = Milliseconds(1000 * m_samples.size() / sampleRate / channelCount); return true; } @@ -262,14 +262,14 @@ bool SoundBuffer::Update(unsigned int channelCount, unsigned int sampleRate) //////////////////////////////////////////////////////////// void SoundBuffer::AttachSound(Sound* sound) const { - mySounds.insert(sound); + m_sounds.insert(sound); } //////////////////////////////////////////////////////////// void SoundBuffer::DetachSound(Sound* sound) const { - mySounds.erase(sound); + m_sounds.erase(sound); } } // namespace sf diff --git a/src/SFML/Audio/SoundBufferRecorder.cpp b/src/SFML/Audio/SoundBufferRecorder.cpp index 8e744ddc..b56df7c5 100644 --- a/src/SFML/Audio/SoundBufferRecorder.cpp +++ b/src/SFML/Audio/SoundBufferRecorder.cpp @@ -35,8 +35,8 @@ namespace sf //////////////////////////////////////////////////////////// bool SoundBufferRecorder::OnStart() { - mySamples.clear(); - myBuffer = SoundBuffer(); + m_samples.clear(); + m_buffer = SoundBuffer(); return true; } @@ -45,7 +45,7 @@ bool SoundBufferRecorder::OnStart() //////////////////////////////////////////////////////////// bool SoundBufferRecorder::OnProcessSamples(const Int16* samples, std::size_t sampleCount) { - std::copy(samples, samples + sampleCount, std::back_inserter(mySamples)); + std::copy(samples, samples + sampleCount, std::back_inserter(m_samples)); return true; } @@ -54,15 +54,15 @@ bool SoundBufferRecorder::OnProcessSamples(const Int16* samples, std::size_t sam //////////////////////////////////////////////////////////// void SoundBufferRecorder::OnStop() { - if (!mySamples.empty()) - myBuffer.LoadFromSamples(&mySamples[0], mySamples.size(), 1, GetSampleRate()); + if (!m_samples.empty()) + m_buffer.LoadFromSamples(&m_samples[0], m_samples.size(), 1, GetSampleRate()); } //////////////////////////////////////////////////////////// const SoundBuffer& SoundBufferRecorder::GetBuffer() const { - return myBuffer; + return m_buffer; } } // namespace sf diff --git a/src/SFML/Audio/SoundFile.cpp b/src/SFML/Audio/SoundFile.cpp index 16052e77..145e7e01 100644 --- a/src/SFML/Audio/SoundFile.cpp +++ b/src/SFML/Audio/SoundFile.cpp @@ -50,10 +50,10 @@ namespace priv { //////////////////////////////////////////////////////////// SoundFile::SoundFile() : -myFile (NULL), -mySampleCount (0), -myChannelCount(0), -mySampleRate (0) +m_file (NULL), +m_sampleCount (0), +m_channelCount(0), +m_sampleRate (0) { } @@ -62,29 +62,29 @@ mySampleRate (0) //////////////////////////////////////////////////////////// SoundFile::~SoundFile() { - if (myFile) - sf_close(myFile); + if (m_file) + sf_close(m_file); } //////////////////////////////////////////////////////////// std::size_t SoundFile::GetSampleCount() const { - return mySampleCount; + return m_sampleCount; } //////////////////////////////////////////////////////////// unsigned int SoundFile::GetChannelCount() const { - return myChannelCount; + return m_channelCount; } //////////////////////////////////////////////////////////// unsigned int SoundFile::GetSampleRate() const { - return mySampleRate; + return m_sampleRate; } @@ -92,22 +92,22 @@ unsigned int SoundFile::GetSampleRate() const bool SoundFile::OpenRead(const std::string& filename) { // If the file is already opened, first close it - if (myFile) - sf_close(myFile); + if (m_file) + sf_close(m_file); // Open the sound file SF_INFO fileInfos; - myFile = sf_open(filename.c_str(), SFM_READ, &fileInfos); - if (!myFile) + m_file = sf_open(filename.c_str(), SFM_READ, &fileInfos); + if (!m_file) { - Err() << "Failed to open sound file \"" << filename << "\" (" << sf_strerror(myFile) << ")" << std::endl; + Err() << "Failed to open sound file \"" << filename << "\" (" << sf_strerror(m_file) << ")" << std::endl; return false; } // Set the sound parameters - myChannelCount = fileInfos.channels; - mySampleRate = fileInfos.samplerate; - mySampleCount = static_cast(fileInfos.frames) * myChannelCount; + m_channelCount = fileInfos.channels; + m_sampleRate = fileInfos.samplerate; + m_sampleCount = static_cast(fileInfos.frames) * m_channelCount; return true; } @@ -117,8 +117,8 @@ bool SoundFile::OpenRead(const std::string& filename) bool SoundFile::OpenRead(const void* data, std::size_t sizeInBytes) { // If the file is already opened, first close it - if (myFile) - sf_close(myFile); + if (m_file) + sf_close(m_file); // Prepare the memory I/O structure SF_VIRTUAL_IO io; @@ -128,23 +128,23 @@ bool SoundFile::OpenRead(const void* data, std::size_t sizeInBytes) io.tell = &Memory::Tell; // Initialize the memory data - myMemory.DataStart = static_cast(data); - myMemory.DataPtr = myMemory.DataStart; - myMemory.TotalSize = sizeInBytes; + m_memory.DataStart = static_cast(data); + m_memory.DataPtr = m_memory.DataStart; + m_memory.TotalSize = sizeInBytes; // Open the sound file SF_INFO fileInfos; - myFile = sf_open_virtual(&io, SFM_READ, &fileInfos, &myMemory); - if (!myFile) + m_file = sf_open_virtual(&io, SFM_READ, &fileInfos, &m_memory); + if (!m_file) { - Err() << "Failed to open sound file from memory (" << sf_strerror(myFile) << ")" << std::endl; + Err() << "Failed to open sound file from memory (" << sf_strerror(m_file) << ")" << std::endl; return false; } // Set the sound parameters - myChannelCount = fileInfos.channels; - mySampleRate = fileInfos.samplerate; - mySampleCount = static_cast(fileInfos.frames) * myChannelCount; + m_channelCount = fileInfos.channels; + m_sampleRate = fileInfos.samplerate; + m_sampleCount = static_cast(fileInfos.frames) * m_channelCount; return true; } @@ -154,8 +154,8 @@ bool SoundFile::OpenRead(const void* data, std::size_t sizeInBytes) bool SoundFile::OpenRead(InputStream& stream) { // If the file is already opened, first close it - if (myFile) - sf_close(myFile); + if (m_file) + sf_close(m_file); // Prepare the memory I/O structure SF_VIRTUAL_IO io; @@ -166,17 +166,17 @@ bool SoundFile::OpenRead(InputStream& stream) // Open the sound file SF_INFO fileInfos; - myFile = sf_open_virtual(&io, SFM_READ, &fileInfos, &stream); - if (!myFile) + m_file = sf_open_virtual(&io, SFM_READ, &fileInfos, &stream); + if (!m_file) { - Err() << "Failed to open sound file from stream (" << sf_strerror(myFile) << ")" << std::endl; + Err() << "Failed to open sound file from stream (" << sf_strerror(m_file) << ")" << std::endl; return false; } // Set the sound parameters - myChannelCount = fileInfos.channels; - mySampleRate = fileInfos.samplerate; - mySampleCount = static_cast(fileInfos.frames) * myChannelCount; + m_channelCount = fileInfos.channels; + m_sampleRate = fileInfos.samplerate; + m_sampleCount = static_cast(fileInfos.frames) * m_channelCount; return true; } @@ -186,8 +186,8 @@ bool SoundFile::OpenRead(InputStream& stream) bool SoundFile::OpenWrite(const std::string& filename, unsigned int channelCount, unsigned int sampleRate) { // If the file is already opened, first close it - if (myFile) - sf_close(myFile); + if (m_file) + sf_close(m_file); // Find the right format according to the file extension int format = GetFormatFromFilename(filename); @@ -205,17 +205,17 @@ bool SoundFile::OpenWrite(const std::string& filename, unsigned int channelCount fileInfos.format = format | (format == SF_FORMAT_OGG ? SF_FORMAT_VORBIS : SF_FORMAT_PCM_16); // Open the sound file for writing - myFile = sf_open(filename.c_str(), SFM_WRITE, &fileInfos); - if (!myFile) + m_file = sf_open(filename.c_str(), SFM_WRITE, &fileInfos); + if (!m_file) { - Err() << "Failed to create sound file \"" << filename << "\" (" << sf_strerror(myFile) << ")" << std::endl; + Err() << "Failed to create sound file \"" << filename << "\" (" << sf_strerror(m_file) << ")" << std::endl; return false; } // Set the sound parameters - myChannelCount = channelCount; - mySampleRate = sampleRate; - mySampleCount = 0; + m_channelCount = channelCount; + m_sampleRate = sampleRate; + m_sampleCount = 0; return true; } @@ -224,8 +224,8 @@ bool SoundFile::OpenWrite(const std::string& filename, unsigned int channelCount //////////////////////////////////////////////////////////// std::size_t SoundFile::Read(Int16* data, std::size_t sampleCount) { - if (myFile && data && sampleCount) - return static_cast(sf_read_short(myFile, data, sampleCount)); + if (m_file && data && sampleCount) + return static_cast(sf_read_short(m_file, data, sampleCount)); else return 0; } @@ -234,14 +234,14 @@ std::size_t SoundFile::Read(Int16* data, std::size_t sampleCount) //////////////////////////////////////////////////////////// void SoundFile::Write(const Int16* data, std::size_t sampleCount) { - if (myFile && data && sampleCount) + if (m_file && data && sampleCount) { // Write small chunks instead of everything at once, // to avoid a stack overflow in libsndfile (happens only with OGG format) while (sampleCount > 0) { std::size_t count = sampleCount > 10000 ? 10000 : sampleCount; - sf_write_short(myFile, data, count); + sf_write_short(m_file, data, count); data += count; sampleCount -= count; } @@ -252,10 +252,10 @@ void SoundFile::Write(const Int16* data, std::size_t sampleCount) //////////////////////////////////////////////////////////// void SoundFile::Seek(Time timeOffset) { - if (myFile) + if (m_file) { - sf_count_t frameOffset = static_cast(timeOffset.AsSeconds() * mySampleRate); - sf_seek(myFile, frameOffset, SEEK_SET); + sf_count_t frameOffset = static_cast(timeOffset.AsSeconds() * m_sampleRate); + sf_seek(m_file, frameOffset, SEEK_SET); } } diff --git a/src/SFML/Audio/SoundFile.hpp b/src/SFML/Audio/SoundFile.hpp index 11375a23..3fbe4a12 100644 --- a/src/SFML/Audio/SoundFile.hpp +++ b/src/SFML/Audio/SoundFile.hpp @@ -199,11 +199,11 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - SNDFILE* myFile; ///< File descriptor - Memory myMemory; ///< Memory reading info - std::size_t mySampleCount; ///< Total number of samples in the file - unsigned int myChannelCount; ///< Number of channels used by the sound - unsigned int mySampleRate; ///< Number of samples per second + SNDFILE* m_file; ///< File descriptor + Memory m_memory; ///< Memory reading info + std::size_t m_sampleCount; ///< Total number of samples in the file + unsigned int m_channelCount; ///< Number of channels used by the sound + unsigned int m_sampleRate; ///< Number of samples per second }; } // namespace priv diff --git a/src/SFML/Audio/SoundRecorder.cpp b/src/SFML/Audio/SoundRecorder.cpp index b23d9bb7..7b935a4f 100644 --- a/src/SFML/Audio/SoundRecorder.cpp +++ b/src/SFML/Audio/SoundRecorder.cpp @@ -45,9 +45,9 @@ namespace sf { //////////////////////////////////////////////////////////// SoundRecorder::SoundRecorder() : -myThread (&SoundRecorder::Record, this), -mySampleRate (0), -myIsCapturing(false) +m_thread (&SoundRecorder::Record, this), +m_sampleRate (0), +m_isCapturing(false) { priv::EnsureALInit(); } @@ -86,10 +86,10 @@ void SoundRecorder::Start(unsigned int sampleRate) } // Clear the array of samples - mySamples.clear(); + m_samples.clear(); // Store the sample rate - mySampleRate = sampleRate; + m_sampleRate = sampleRate; // Notify derived class if (OnStart()) @@ -98,8 +98,8 @@ void SoundRecorder::Start(unsigned int sampleRate) alcCaptureStart(captureDevice); // Start the capture in a new thread, to avoid blocking the main thread - myIsCapturing = true; - myThread.Launch(); + m_isCapturing = true; + m_thread.Launch(); } } @@ -108,15 +108,15 @@ void SoundRecorder::Start(unsigned int sampleRate) void SoundRecorder::Stop() { // Stop the capturing thread - myIsCapturing = false; - myThread.Wait(); + m_isCapturing = false; + m_thread.Wait(); } //////////////////////////////////////////////////////////// unsigned int SoundRecorder::GetSampleRate() const { - return mySampleRate; + return m_sampleRate; } @@ -146,7 +146,7 @@ void SoundRecorder::OnStop() //////////////////////////////////////////////////////////// void SoundRecorder::Record() { - while (myIsCapturing) + while (m_isCapturing) { // Process available samples ProcessCapturedSamples(); @@ -173,14 +173,14 @@ void SoundRecorder::ProcessCapturedSamples() if (samplesAvailable > 0) { // Get the recorded samples - mySamples.resize(samplesAvailable); - alcCaptureSamples(captureDevice, &mySamples[0], samplesAvailable); + m_samples.resize(samplesAvailable); + alcCaptureSamples(captureDevice, &m_samples[0], samplesAvailable); // Forward them to the derived class - if (!OnProcessSamples(&mySamples[0], mySamples.size())) + if (!OnProcessSamples(&m_samples[0], m_samples.size())) { // The user wants to stop the capture - myIsCapturing = false; + m_isCapturing = false; } } } diff --git a/src/SFML/Audio/SoundSource.cpp b/src/SFML/Audio/SoundSource.cpp index cd52e87b..e8ca0996 100644 --- a/src/SFML/Audio/SoundSource.cpp +++ b/src/SFML/Audio/SoundSource.cpp @@ -36,8 +36,8 @@ SoundSource::SoundSource() { priv::EnsureALInit(); - ALCheck(alGenSources(1, &mySource)); - ALCheck(alSourcei(mySource, AL_BUFFER, 0)); + ALCheck(alGenSources(1, &m_source)); + ALCheck(alSourcei(m_source, AL_BUFFER, 0)); } @@ -46,8 +46,8 @@ SoundSource::SoundSource(const SoundSource& copy) { priv::EnsureALInit(); - ALCheck(alGenSources(1, &mySource)); - ALCheck(alSourcei(mySource, AL_BUFFER, 0)); + ALCheck(alGenSources(1, &m_source)); + ALCheck(alSourcei(m_source, AL_BUFFER, 0)); SetPitch(copy.GetPitch()); SetVolume(copy.GetVolume()); @@ -61,28 +61,28 @@ SoundSource::SoundSource(const SoundSource& copy) //////////////////////////////////////////////////////////// SoundSource::~SoundSource() { - ALCheck(alSourcei(mySource, AL_BUFFER, 0)); - ALCheck(alDeleteSources(1, &mySource)); + ALCheck(alSourcei(m_source, AL_BUFFER, 0)); + ALCheck(alDeleteSources(1, &m_source)); } //////////////////////////////////////////////////////////// void SoundSource::SetPitch(float pitch) { - ALCheck(alSourcef(mySource, AL_PITCH, pitch)); + ALCheck(alSourcef(m_source, AL_PITCH, pitch)); } //////////////////////////////////////////////////////////// void SoundSource::SetVolume(float volume) { - ALCheck(alSourcef(mySource, AL_GAIN, volume * 0.01f)); + ALCheck(alSourcef(m_source, AL_GAIN, volume * 0.01f)); } //////////////////////////////////////////////////////////// void SoundSource::SetPosition(float x, float y, float z) { - ALCheck(alSource3f(mySource, AL_POSITION, x, y, z)); + ALCheck(alSource3f(m_source, AL_POSITION, x, y, z)); } @@ -96,21 +96,21 @@ void SoundSource::SetPosition(const Vector3f& position) //////////////////////////////////////////////////////////// void SoundSource::SetRelativeToListener(bool relative) { - ALCheck(alSourcei(mySource, AL_SOURCE_RELATIVE, relative)); + ALCheck(alSourcei(m_source, AL_SOURCE_RELATIVE, relative)); } //////////////////////////////////////////////////////////// void SoundSource::SetMinDistance(float distance) { - ALCheck(alSourcef(mySource, AL_REFERENCE_DISTANCE, distance)); + ALCheck(alSourcef(m_source, AL_REFERENCE_DISTANCE, distance)); } //////////////////////////////////////////////////////////// void SoundSource::SetAttenuation(float attenuation) { - ALCheck(alSourcef(mySource, AL_ROLLOFF_FACTOR, attenuation)); + ALCheck(alSourcef(m_source, AL_ROLLOFF_FACTOR, attenuation)); } @@ -118,7 +118,7 @@ void SoundSource::SetAttenuation(float attenuation) float SoundSource::GetPitch() const { ALfloat pitch; - ALCheck(alGetSourcef(mySource, AL_PITCH, &pitch)); + ALCheck(alGetSourcef(m_source, AL_PITCH, &pitch)); return pitch; } @@ -128,7 +128,7 @@ float SoundSource::GetPitch() const float SoundSource::GetVolume() const { ALfloat gain; - ALCheck(alGetSourcef(mySource, AL_GAIN, &gain)); + ALCheck(alGetSourcef(m_source, AL_GAIN, &gain)); return gain * 100.f; } @@ -138,7 +138,7 @@ float SoundSource::GetVolume() const Vector3f SoundSource::GetPosition() const { Vector3f position; - ALCheck(alGetSource3f(mySource, AL_POSITION, &position.x, &position.y, &position.z)); + ALCheck(alGetSource3f(m_source, AL_POSITION, &position.x, &position.y, &position.z)); return position; } @@ -148,7 +148,7 @@ Vector3f SoundSource::GetPosition() const bool SoundSource::IsRelativeToListener() const { ALint relative; - ALCheck(alGetSourcei(mySource, AL_SOURCE_RELATIVE, &relative)); + ALCheck(alGetSourcei(m_source, AL_SOURCE_RELATIVE, &relative)); return relative != 0; } @@ -158,7 +158,7 @@ bool SoundSource::IsRelativeToListener() const float SoundSource::GetMinDistance() const { ALfloat distance; - ALCheck(alGetSourcef(mySource, AL_REFERENCE_DISTANCE, &distance)); + ALCheck(alGetSourcef(m_source, AL_REFERENCE_DISTANCE, &distance)); return distance; } @@ -168,7 +168,7 @@ float SoundSource::GetMinDistance() const float SoundSource::GetAttenuation() const { ALfloat attenuation; - ALCheck(alGetSourcef(mySource, AL_ROLLOFF_FACTOR, &attenuation)); + ALCheck(alGetSourcef(m_source, AL_ROLLOFF_FACTOR, &attenuation)); return attenuation; } @@ -178,7 +178,7 @@ float SoundSource::GetAttenuation() const SoundSource::Status SoundSource::GetStatus() const { ALint status; - ALCheck(alGetSourcei(mySource, AL_SOURCE_STATE, &status)); + ALCheck(alGetSourcei(m_source, AL_SOURCE_STATE, &status)); switch (status) { diff --git a/src/SFML/Audio/SoundStream.cpp b/src/SFML/Audio/SoundStream.cpp index 8f6cf3c3..469c0102 100644 --- a/src/SFML/Audio/SoundStream.cpp +++ b/src/SFML/Audio/SoundStream.cpp @@ -40,13 +40,13 @@ namespace sf { //////////////////////////////////////////////////////////// SoundStream::SoundStream() : -myThread (&SoundStream::Stream, this), -myIsStreaming (false), -myChannelCount (0), -mySampleRate (0), -myFormat (0), -myLoop (false), -mySamplesProcessed(0) +m_thread (&SoundStream::Stream, this), +m_isStreaming (false), +m_channelCount (0), +m_sampleRate (0), +m_format (0), +m_loop (false), +m_samplesProcessed(0) { } @@ -63,18 +63,18 @@ SoundStream::~SoundStream() //////////////////////////////////////////////////////////// void SoundStream::Initialize(unsigned int channelCount, unsigned int sampleRate) { - myChannelCount = channelCount; - mySampleRate = sampleRate; + m_channelCount = channelCount; + m_sampleRate = sampleRate; // Deduce the format from the number of channels - myFormat = priv::AudioDevice::GetFormatFromChannelCount(channelCount); + m_format = priv::AudioDevice::GetFormatFromChannelCount(channelCount); // Check if the format is valid - if (myFormat == 0) + if (m_format == 0) { - myChannelCount = 0; - mySampleRate = 0; - Err() << "Unsupported number of channels (" << myChannelCount << ")" << std::endl; + m_channelCount = 0; + m_sampleRate = 0; + Err() << "Unsupported number of channels (" << m_channelCount << ")" << std::endl; } } @@ -83,16 +83,16 @@ void SoundStream::Initialize(unsigned int channelCount, unsigned int sampleRate) void SoundStream::Play() { // Check if the sound parameters have been set - if (myFormat == 0) + if (m_format == 0) { Err() << "Failed to play audio stream: sound parameters have not been initialized (call Initialize first)" << std::endl; return; } // If the sound is already playing (probably paused), just resume it - if (myIsStreaming) + if (m_isStreaming) { - ALCheck(alSourcePlay(mySource)); + ALCheck(alSourcePlay(m_source)); return; } @@ -100,16 +100,16 @@ void SoundStream::Play() OnSeek(Time::Zero); // Start updating the stream in a separate thread to avoid blocking the application - mySamplesProcessed = 0; - myIsStreaming = true; - myThread.Launch(); + m_samplesProcessed = 0; + m_isStreaming = true; + m_thread.Launch(); } //////////////////////////////////////////////////////////// void SoundStream::Pause() { - ALCheck(alSourcePause(mySource)); + ALCheck(alSourcePause(m_source)); } @@ -117,22 +117,22 @@ void SoundStream::Pause() void SoundStream::Stop() { // Wait for the thread to terminate - myIsStreaming = false; - myThread.Wait(); + m_isStreaming = false; + m_thread.Wait(); } //////////////////////////////////////////////////////////// unsigned int SoundStream::GetChannelCount() const { - return myChannelCount; + return m_channelCount; } //////////////////////////////////////////////////////////// unsigned int SoundStream::GetSampleRate() const { - return mySampleRate; + return m_sampleRate; } @@ -142,7 +142,7 @@ SoundStream::Status SoundStream::GetStatus() const Status status = SoundSource::GetStatus(); // To compensate for the lag between Play() and alSourcePlay() - if ((status == Stopped) && myIsStreaming) + if ((status == Stopped) && m_isStreaming) status = Playing; return status; @@ -159,9 +159,9 @@ void SoundStream::SetPlayingOffset(Time timeOffset) OnSeek(timeOffset); // Restart streaming - mySamplesProcessed = static_cast(timeOffset.AsSeconds() * mySampleRate * myChannelCount); - myIsStreaming = true; - myThread.Launch(); + m_samplesProcessed = static_cast(timeOffset.AsSeconds() * m_sampleRate * m_channelCount); + m_isStreaming = true; + m_thread.Launch(); } @@ -169,23 +169,23 @@ void SoundStream::SetPlayingOffset(Time timeOffset) Time SoundStream::GetPlayingOffset() const { ALfloat seconds = 0.f; - ALCheck(alGetSourcef(mySource, AL_SEC_OFFSET, &seconds)); + ALCheck(alGetSourcef(m_source, AL_SEC_OFFSET, &seconds)); - return Seconds(seconds + static_cast(mySamplesProcessed) / mySampleRate / myChannelCount); + return Seconds(seconds + static_cast(m_samplesProcessed) / m_sampleRate / m_channelCount); } //////////////////////////////////////////////////////////// void SoundStream::SetLoop(bool loop) { - myLoop = loop; + m_loop = loop; } //////////////////////////////////////////////////////////// bool SoundStream::GetLoop() const { - return myLoop; + return m_loop; } @@ -193,17 +193,17 @@ bool SoundStream::GetLoop() const void SoundStream::Stream() { // Create the buffers - ALCheck(alGenBuffers(BufferCount, myBuffers)); + ALCheck(alGenBuffers(BufferCount, m_buffers)); for (int i = 0; i < BufferCount; ++i) - myEndBuffers[i] = false; + m_endBuffers[i] = false; // Fill the queue bool requestStop = FillQueue(); // Play the sound - ALCheck(alSourcePlay(mySource)); + ALCheck(alSourcePlay(m_source)); - while (myIsStreaming) + while (m_isStreaming) { // The stream has been interrupted! if (SoundSource::GetStatus() == Stopped) @@ -211,47 +211,47 @@ void SoundStream::Stream() if (!requestStop) { // Just continue - ALCheck(alSourcePlay(mySource)); + ALCheck(alSourcePlay(m_source)); } else { // End streaming - myIsStreaming = false; + m_isStreaming = false; } } // Get the number of buffers that have been processed (ie. ready for reuse) ALint nbProcessed = 0; - ALCheck(alGetSourcei(mySource, AL_BUFFERS_PROCESSED, &nbProcessed)); + ALCheck(alGetSourcei(m_source, AL_BUFFERS_PROCESSED, &nbProcessed)); while (nbProcessed--) { // Pop the first unused buffer from the queue ALuint buffer; - ALCheck(alSourceUnqueueBuffers(mySource, 1, &buffer)); + ALCheck(alSourceUnqueueBuffers(m_source, 1, &buffer)); // Find its number unsigned int bufferNum = 0; for (int i = 0; i < BufferCount; ++i) - if (myBuffers[i] == buffer) + if (m_buffers[i] == buffer) { bufferNum = i; break; } // Retrieve its size and add it to the samples count - if (myEndBuffers[bufferNum]) + if (m_endBuffers[bufferNum]) { // This was the last buffer: reset the sample count - mySamplesProcessed = 0; - myEndBuffers[bufferNum] = false; + m_samplesProcessed = 0; + m_endBuffers[bufferNum] = false; } else { ALint size, bits; ALCheck(alGetBufferi(buffer, AL_SIZE, &size)); ALCheck(alGetBufferi(buffer, AL_BITS, &bits)); - mySamplesProcessed += size / (bits / 8); + m_samplesProcessed += size / (bits / 8); } // Fill it and push it back into the playing queue @@ -268,14 +268,14 @@ void SoundStream::Stream() } // Stop the playback - ALCheck(alSourceStop(mySource)); + ALCheck(alSourceStop(m_source)); // Unqueue any buffer left in the queue ClearQueue(); // Delete the buffers - ALCheck(alSourcei(mySource, AL_BUFFER, 0)); - ALCheck(alDeleteBuffers(BufferCount, myBuffers)); + ALCheck(alSourcei(m_source, AL_BUFFER, 0)); + ALCheck(alDeleteBuffers(BufferCount, m_buffers)); } @@ -289,10 +289,10 @@ bool SoundStream::FillAndPushBuffer(unsigned int bufferNum) if (!OnGetData(data)) { // Mark the buffer as the last one (so that we know when to reset the playing position) - myEndBuffers[bufferNum] = true; + m_endBuffers[bufferNum] = true; // Check if the stream must loop or stop - if (myLoop) + if (m_loop) { // Return to the beginning of the stream source OnSeek(Time::Zero); @@ -313,14 +313,14 @@ bool SoundStream::FillAndPushBuffer(unsigned int bufferNum) // Fill the buffer if some data was returned if (data.Samples && data.SampleCount) { - unsigned int buffer = myBuffers[bufferNum]; + unsigned int buffer = m_buffers[bufferNum]; // Fill the buffer ALsizei size = static_cast(data.SampleCount) * sizeof(Int16); - ALCheck(alBufferData(buffer, myFormat, data.Samples, size, mySampleRate)); + ALCheck(alBufferData(buffer, m_format, data.Samples, size, m_sampleRate)); // Push it into the sound queue - ALCheck(alSourceQueueBuffers(mySource, 1, &buffer)); + ALCheck(alSourceQueueBuffers(m_source, 1, &buffer)); } return requestStop; @@ -347,12 +347,12 @@ void SoundStream::ClearQueue() { // Get the number of buffers still in the queue ALint nbQueued; - ALCheck(alGetSourcei(mySource, AL_BUFFERS_QUEUED, &nbQueued)); + ALCheck(alGetSourcei(m_source, AL_BUFFERS_QUEUED, &nbQueued)); // Unqueue them all ALuint buffer; for (ALint i = 0; i < nbQueued; ++i) - ALCheck(alSourceUnqueueBuffers(mySource, 1, &buffer)); + ALCheck(alSourceUnqueueBuffers(m_source, 1, &buffer)); } } // namespace sf diff --git a/src/SFML/Graphics/CircleShape.cpp b/src/SFML/Graphics/CircleShape.cpp index 7f4318bd..6967e8ae 100644 --- a/src/SFML/Graphics/CircleShape.cpp +++ b/src/SFML/Graphics/CircleShape.cpp @@ -33,8 +33,8 @@ namespace sf { //////////////////////////////////////////////////////////// CircleShape::CircleShape(float radius, unsigned int pointCount) : -myRadius (radius), -myPointCount(pointCount) +m_radius (radius), +m_pointCount(pointCount) { Update(); } @@ -43,7 +43,7 @@ myPointCount(pointCount) //////////////////////////////////////////////////////////// void CircleShape::SetRadius(float radius) { - myRadius = radius; + m_radius = radius; Update(); } @@ -51,21 +51,21 @@ void CircleShape::SetRadius(float radius) //////////////////////////////////////////////////////////// float CircleShape::GetRadius() const { - return myRadius; + return m_radius; } //////////////////////////////////////////////////////////// void CircleShape::SetPointCount(unsigned int count) { - myPointCount = count; + m_pointCount = count; Update(); } //////////////////////////////////////////////////////////// unsigned int CircleShape::GetPointCount() const { - return myPointCount; + return m_pointCount; } @@ -74,11 +74,11 @@ Vector2f CircleShape::GetPoint(unsigned int index) const { static const float pi = 3.141592654f; - float angle = index * 2 * pi / myPointCount - pi / 2; - float x = std::cos(angle) * myRadius; - float y = std::sin(angle) * myRadius; + float angle = index * 2 * pi / m_pointCount - pi / 2; + float x = std::cos(angle) * m_radius; + float y = std::sin(angle) * m_radius; - return Vector2f(myRadius + x, myRadius + y); + return Vector2f(m_radius + x, m_radius + y); } } // namespace sf diff --git a/src/SFML/Graphics/ConvexShape.cpp b/src/SFML/Graphics/ConvexShape.cpp index d3ef69b6..52d2f858 100644 --- a/src/SFML/Graphics/ConvexShape.cpp +++ b/src/SFML/Graphics/ConvexShape.cpp @@ -40,7 +40,7 @@ ConvexShape::ConvexShape(unsigned int pointCount) //////////////////////////////////////////////////////////// void ConvexShape::SetPointCount(unsigned int count) { - myPoints.resize(count); + m_points.resize(count); Update(); } @@ -48,14 +48,14 @@ void ConvexShape::SetPointCount(unsigned int count) //////////////////////////////////////////////////////////// unsigned int ConvexShape::GetPointCount() const { - return static_cast(myPoints.size()); + return static_cast(m_points.size()); } //////////////////////////////////////////////////////////// void ConvexShape::SetPoint(unsigned int index, const Vector2f& point) { - myPoints[index] = point; + m_points[index] = point; Update(); } @@ -63,7 +63,7 @@ void ConvexShape::SetPoint(unsigned int index, const Vector2f& point) //////////////////////////////////////////////////////////// Vector2f ConvexShape::GetPoint(unsigned int index) const { - return myPoints[index]; + return m_points[index]; } } // namespace sf diff --git a/src/SFML/Graphics/Font.cpp b/src/SFML/Graphics/Font.cpp index 091e10a0..a2ad4662 100644 --- a/src/SFML/Graphics/Font.cpp +++ b/src/SFML/Graphics/Font.cpp @@ -63,10 +63,10 @@ namespace sf { //////////////////////////////////////////////////////////// Font::Font() : -myLibrary (NULL), -myFace (NULL), -myStreamRec(NULL), -myRefCount (NULL) +m_library (NULL), +m_face (NULL), +m_streamRec(NULL), +m_refCount (NULL) { } @@ -74,18 +74,18 @@ myRefCount (NULL) //////////////////////////////////////////////////////////// Font::Font(const Font& copy) : -myLibrary (copy.myLibrary), -myFace (copy.myFace), -myStreamRec (copy.myStreamRec), -myRefCount (copy.myRefCount), -myPages (copy.myPages), -myPixelBuffer(copy.myPixelBuffer) +m_library (copy.m_library), +m_face (copy.m_face), +m_streamRec (copy.m_streamRec), +m_refCount (copy.m_refCount), +m_pages (copy.m_pages), +m_pixelBuffer(copy.m_pixelBuffer) { // Note: as FreeType doesn't provide functions for copying/cloning, // we must share all the FreeType pointers - if (myRefCount) - (*myRefCount)++; + if (m_refCount) + (*m_refCount)++; } @@ -101,7 +101,7 @@ bool Font::LoadFromFile(const std::string& filename) { // Cleanup the previous resources Cleanup(); - myRefCount = new int(1); + m_refCount = new int(1); // Initialize FreeType // Note: we initialize FreeType for every font instance in order to avoid having a single @@ -112,11 +112,11 @@ bool Font::LoadFromFile(const std::string& filename) Err() << "Failed to load font \"" << filename << "\" (failed to initialize FreeType)" << std::endl; return false; } - myLibrary = library; + m_library = library; // Load the new font face from the specified file FT_Face face; - if (FT_New_Face(static_cast(myLibrary), filename.c_str(), 0, &face) != 0) + if (FT_New_Face(static_cast(m_library), filename.c_str(), 0, &face) != 0) { Err() << "Failed to load font \"" << filename << "\" (failed to create the font face)" << std::endl; return false; @@ -130,7 +130,7 @@ bool Font::LoadFromFile(const std::string& filename) } // Store the loaded font in our ugly void* :) - myFace = face; + m_face = face; return true; } @@ -141,7 +141,7 @@ bool Font::LoadFromMemory(const void* data, std::size_t sizeInBytes) { // Cleanup the previous resources Cleanup(); - myRefCount = new int(1); + m_refCount = new int(1); // Initialize FreeType // Note: we initialize FreeType for every font instance in order to avoid having a single @@ -152,11 +152,11 @@ bool Font::LoadFromMemory(const void* data, std::size_t sizeInBytes) Err() << "Failed to load font from memory (failed to initialize FreeType)" << std::endl; return false; } - myLibrary = library; + m_library = library; // Load the new font face from the specified file FT_Face face; - if (FT_New_Memory_Face(static_cast(myLibrary), reinterpret_cast(data), static_cast(sizeInBytes), 0, &face) != 0) + if (FT_New_Memory_Face(static_cast(m_library), reinterpret_cast(data), static_cast(sizeInBytes), 0, &face) != 0) { Err() << "Failed to load font from memory (failed to create the font face)" << std::endl; return false; @@ -170,7 +170,7 @@ bool Font::LoadFromMemory(const void* data, std::size_t sizeInBytes) } // Store the loaded font in our ugly void* :) - myFace = face; + m_face = face; return true; } @@ -181,7 +181,7 @@ bool Font::LoadFromStream(InputStream& stream) { // Cleanup the previous resources Cleanup(); - myRefCount = new int(1); + m_refCount = new int(1); // Initialize FreeType // Note: we initialize FreeType for every font instance in order to avoid having a single @@ -192,7 +192,7 @@ bool Font::LoadFromStream(InputStream& stream) Err() << "Failed to load font from stream (failed to initialize FreeType)" << std::endl; return false; } - myLibrary = library; + m_library = library; // Prepare a wrapper for our stream, that we'll pass to FreeType callbacks FT_StreamRec* rec = new FT_StreamRec; @@ -212,7 +212,7 @@ bool Font::LoadFromStream(InputStream& stream) // Load the new font face from the specified stream FT_Face face; - if (FT_Open_Face(static_cast(myLibrary), &args, 0, &face) != 0) + if (FT_Open_Face(static_cast(m_library), &args, 0, &face) != 0) { Err() << "Failed to load font from stream (failed to create the font face)" << std::endl; return false; @@ -226,8 +226,8 @@ bool Font::LoadFromStream(InputStream& stream) } // Store the loaded font in our ugly void* :) - myFace = face; - myStreamRec = rec; + m_face = face; + m_streamRec = rec; return true; } @@ -237,7 +237,7 @@ bool Font::LoadFromStream(InputStream& stream) const Glyph& Font::GetGlyph(Uint32 codePoint, unsigned int characterSize, bool bold) const { // Get the page corresponding to the character size - GlyphTable& glyphs = myPages[characterSize].Glyphs; + GlyphTable& glyphs = m_pages[characterSize].Glyphs; // Build the key by combining the code point and the bold flag Uint32 key = ((bold ? 1 : 0) << 31) | codePoint; @@ -265,7 +265,7 @@ int Font::GetKerning(Uint32 first, Uint32 second, unsigned int characterSize) co if (first == 0 || second == 0) return 0; - FT_Face face = static_cast(myFace); + FT_Face face = static_cast(m_face); if (face && FT_HAS_KERNING(face) && SetCurrentSize(characterSize)) { @@ -291,7 +291,7 @@ int Font::GetKerning(Uint32 first, Uint32 second, unsigned int characterSize) co //////////////////////////////////////////////////////////// int Font::GetLineSpacing(unsigned int characterSize) const { - FT_Face face = static_cast(myFace); + FT_Face face = static_cast(m_face); if (face && SetCurrentSize(characterSize)) { @@ -307,7 +307,7 @@ int Font::GetLineSpacing(unsigned int characterSize) const //////////////////////////////////////////////////////////// const Texture& Font::GetTexture(unsigned int characterSize) const { - return myPages[characterSize].Texture; + return m_pages[characterSize].Texture; } @@ -316,11 +316,11 @@ Font& Font::operator =(const Font& right) { Font temp(right); - std::swap(myLibrary, temp.myLibrary); - std::swap(myFace, temp.myFace); - std::swap(myPages, temp.myPages); - std::swap(myPixelBuffer, temp.myPixelBuffer); - std::swap(myRefCount, temp.myRefCount); + std::swap(m_library, temp.m_library); + std::swap(m_face, temp.m_face); + std::swap(m_pages, temp.m_pages); + std::swap(m_pixelBuffer, temp.m_pixelBuffer); + std::swap(m_refCount, temp.m_refCount); return *this; } @@ -352,38 +352,38 @@ const Font& Font::GetDefaultFont() void Font::Cleanup() { // Check if we must destroy the FreeType pointers - if (myRefCount) + if (m_refCount) { // Decrease the reference counter - (*myRefCount)--; + (*m_refCount)--; // Free the resources only if we are the last owner - if (*myRefCount == 0) + if (*m_refCount == 0) { // Delete the reference counter - delete myRefCount; + delete m_refCount; // Destroy the font face - if (myFace) - FT_Done_Face(static_cast(myFace)); + if (m_face) + FT_Done_Face(static_cast(m_face)); // Destroy the stream rec instance, if any (must be done after FT_Done_Face!) - if (myStreamRec) - delete static_cast(myStreamRec); + if (m_streamRec) + delete static_cast(m_streamRec); // Close the library - if (myLibrary) - FT_Done_FreeType(static_cast(myLibrary)); + if (m_library) + FT_Done_FreeType(static_cast(m_library)); } } // Reset members - myLibrary = NULL; - myFace = NULL; - myStreamRec = NULL; - myRefCount = NULL; - myPages.clear(); - myPixelBuffer.clear(); + m_library = NULL; + m_face = NULL; + m_streamRec = NULL; + m_refCount = NULL; + m_pages.clear(); + m_pixelBuffer.clear(); } @@ -394,7 +394,7 @@ Glyph Font::LoadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold) c Glyph glyph; // First, transform our ugly void* to a FT_Face - FT_Face face = static_cast(myFace); + FT_Face face = static_cast(m_face); if (!face) return glyph; @@ -428,7 +428,7 @@ Glyph Font::LoadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold) c // Apply bold if necessary -- fallback technique using bitmap (lower quality) if (bold && !outline) { - FT_Bitmap_Embolden(static_cast(myLibrary), &bitmap, weight, weight); + FT_Bitmap_Embolden(static_cast(m_library), &bitmap, weight, weight); } // Compute the glyph's advance offset @@ -445,7 +445,7 @@ Glyph Font::LoadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold) c const unsigned int padding = 1; // Get the glyphs page corresponding to the character size - Page& page = myPages[characterSize]; + Page& page = m_pages[characterSize]; // Find a good position for the new glyph into the texture glyph.TextureRect = FindGlyphRect(page, width + 2 * padding, height + 2 * padding); @@ -457,7 +457,7 @@ Glyph Font::LoadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold) c glyph.Bounds.Height = height + 2 * padding; // Extract the glyph's pixels from the bitmap - myPixelBuffer.resize(width * height * 4, 255); + m_pixelBuffer.resize(width * height * 4, 255); const Uint8* pixels = bitmap.buffer; if (bitmap.pixel_mode == FT_PIXEL_MODE_MONO) { @@ -468,7 +468,7 @@ Glyph Font::LoadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold) c { // The color channels remain white, just fill the alpha channel std::size_t index = (x + y * width) * 4 + 3; - myPixelBuffer[index] = ((pixels[x / 8]) & (1 << (7 - (x % 8)))) ? 255 : 0; + m_pixelBuffer[index] = ((pixels[x / 8]) & (1 << (7 - (x % 8)))) ? 255 : 0; } pixels += bitmap.pitch; } @@ -482,7 +482,7 @@ Glyph Font::LoadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold) c { // The color channels remain white, just fill the alpha channel std::size_t index = (x + y * width) * 4 + 3; - myPixelBuffer[index] = pixels[x]; + m_pixelBuffer[index] = pixels[x]; } pixels += bitmap.pitch; } @@ -493,7 +493,7 @@ Glyph Font::LoadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold) c unsigned int y = glyph.TextureRect.Top + padding; unsigned int width = glyph.TextureRect.Width - 2 * padding; unsigned int height = glyph.TextureRect.Height - 2 * padding; - page.Texture.Update(&myPixelBuffer[0], width, height, x, y); + page.Texture.Update(&m_pixelBuffer[0], width, height, x, y); } // Delete the FT glyph @@ -577,7 +577,7 @@ bool Font::SetCurrentSize(unsigned int characterSize) const // FT_Set_Pixel_Sizes is an expensive function, so we must call it // only when necessary to avoid killing performances - FT_Face face = static_cast(myFace); + FT_Face face = static_cast(m_face); FT_UShort currentSize = face->size->metrics.x_ppem; if (currentSize != characterSize) diff --git a/src/SFML/Graphics/Image.cpp b/src/SFML/Graphics/Image.cpp index cba01247..02336195 100644 --- a/src/SFML/Graphics/Image.cpp +++ b/src/SFML/Graphics/Image.cpp @@ -36,8 +36,8 @@ namespace sf { //////////////////////////////////////////////////////////// Image::Image() : -myWidth (0), -myHeight(0) +m_width (0), +m_height(0) { } @@ -47,15 +47,15 @@ myHeight(0) void Image::Create(unsigned int width, unsigned int height, const Color& color) { // Assign the new size - myWidth = width; - myHeight = height; + m_width = width; + m_height = height; // Resize the pixel buffer - myPixels.resize(width * height * 4); + m_pixels.resize(width * height * 4); // Fill it with the specified color - Uint8* ptr = &myPixels[0]; - Uint8* end = ptr + myPixels.size(); + Uint8* ptr = &m_pixels[0]; + Uint8* end = ptr + m_pixels.size(); while (ptr < end) { *ptr++ = color.r; @@ -72,20 +72,20 @@ void Image::Create(unsigned int width, unsigned int height, const Uint8* pixels) if (pixels) { // Assign the new size - myWidth = width; - myHeight = height; + m_width = width; + m_height = height; // Copy the pixels std::size_t size = width * height * 4; - myPixels.resize(size); - std::memcpy(&myPixels[0], pixels, size); // faster than vector::assign + m_pixels.resize(size); + std::memcpy(&m_pixels[0], pixels, size); // faster than vector::assign } else { // Create an empty image - myWidth = 0; - myHeight = 0; - myPixels.clear(); + m_width = 0; + m_height = 0; + m_pixels.clear(); } } @@ -93,42 +93,42 @@ void Image::Create(unsigned int width, unsigned int height, const Uint8* pixels) //////////////////////////////////////////////////////////// bool Image::LoadFromFile(const std::string& filename) { - return priv::ImageLoader::GetInstance().LoadImageFromFile(filename, myPixels, myWidth, myHeight); + return priv::ImageLoader::GetInstance().LoadImageFromFile(filename, m_pixels, m_width, m_height); } //////////////////////////////////////////////////////////// bool Image::LoadFromMemory(const void* data, std::size_t size) { - return priv::ImageLoader::GetInstance().LoadImageFromMemory(data, size, myPixels, myWidth, myHeight); + return priv::ImageLoader::GetInstance().LoadImageFromMemory(data, size, m_pixels, m_width, m_height); } //////////////////////////////////////////////////////////// bool Image::LoadFromStream(InputStream& stream) { - return priv::ImageLoader::GetInstance().LoadImageFromStream(stream, myPixels, myWidth, myHeight); + return priv::ImageLoader::GetInstance().LoadImageFromStream(stream, m_pixels, m_width, m_height); } //////////////////////////////////////////////////////////// bool Image::SaveToFile(const std::string& filename) const { - return priv::ImageLoader::GetInstance().SaveImageToFile(filename, myPixels, myWidth, myHeight); + return priv::ImageLoader::GetInstance().SaveImageToFile(filename, m_pixels, m_width, m_height); } //////////////////////////////////////////////////////////// unsigned int Image::GetWidth() const { - return myWidth; + return m_width; } //////////////////////////////////////////////////////////// unsigned int Image::GetHeight() const { - return myHeight; + return m_height; } @@ -136,11 +136,11 @@ unsigned int Image::GetHeight() const void Image::CreateMaskFromColor(const Color& color, Uint8 alpha) { // Make sure that the image is not empty - if (!myPixels.empty()) + if (!m_pixels.empty()) { // Replace the alpha of the pixels that match the transparent color - Uint8* ptr = &myPixels[0]; - Uint8* end = ptr + myPixels.size(); + Uint8* ptr = &m_pixels[0]; + Uint8* end = ptr + m_pixels.size(); while (ptr < end) { if ((ptr[0] == color.r) && (ptr[1] == color.g) && (ptr[2] == color.b) && (ptr[3] == color.a)) @@ -155,7 +155,7 @@ void Image::CreateMaskFromColor(const Color& color, Uint8 alpha) void Image::Copy(const Image& source, unsigned int destX, unsigned int destY, const IntRect& sourceRect, bool applyAlpha) { // Make sure that both images are valid - if ((source.myWidth == 0) || (source.myHeight == 0) || (myWidth == 0) || (myHeight == 0)) + if ((source.m_width == 0) || (source.m_height == 0) || (m_width == 0) || (m_height == 0)) return; // Adjust the source rectangle @@ -164,22 +164,22 @@ void Image::Copy(const Image& source, unsigned int destX, unsigned int destY, co { srcRect.Left = 0; srcRect.Top = 0; - srcRect.Width = source.myWidth; - srcRect.Height = source.myHeight; + srcRect.Width = source.m_width; + srcRect.Height = source.m_height; } else { if (srcRect.Left < 0) srcRect.Left = 0; if (srcRect.Top < 0) srcRect.Top = 0; - if (srcRect.Width > static_cast(source.myWidth)) srcRect.Width = source.myWidth; - if (srcRect.Height > static_cast(source.myHeight)) srcRect.Height = source.myHeight; + if (srcRect.Width > static_cast(source.m_width)) srcRect.Width = source.m_width; + if (srcRect.Height > static_cast(source.m_height)) srcRect.Height = source.m_height; } // Then find the valid bounds of the destination rectangle int width = srcRect.Width; int height = srcRect.Height; - if (destX + width > myWidth) width = myWidth - destX; - if (destY + height > myHeight) height = myHeight - destY; + if (destX + width > m_width) width = m_width - destX; + if (destY + height > m_height) height = m_height - destY; // Make sure the destination area is valid if ((width <= 0) || (height <= 0)) @@ -188,10 +188,10 @@ void Image::Copy(const Image& source, unsigned int destX, unsigned int destY, co // Precompute as much as possible int pitch = width * 4; int rows = height; - int srcStride = source.myWidth * 4; - int dstStride = myWidth * 4; - const Uint8* srcPixels = &source.myPixels[0] + (srcRect.Left + srcRect.Top * source.myWidth) * 4; - Uint8* dstPixels = &myPixels[0] + (destX + destY * myWidth) * 4; + int srcStride = source.m_width * 4; + int dstStride = m_width * 4; + const Uint8* srcPixels = &source.m_pixels[0] + (srcRect.Left + srcRect.Top * source.m_width) * 4; + Uint8* dstPixels = &m_pixels[0] + (destX + destY * m_width) * 4; // Copy the pixels if (applyAlpha) @@ -233,7 +233,7 @@ void Image::Copy(const Image& source, unsigned int destX, unsigned int destY, co //////////////////////////////////////////////////////////// void Image::SetPixel(unsigned int x, unsigned int y, const Color& color) { - Uint8* pixel = &myPixels[(x + y * myWidth) * 4]; + Uint8* pixel = &m_pixels[(x + y * m_width) * 4]; *pixel++ = color.r; *pixel++ = color.g; *pixel++ = color.b; @@ -244,7 +244,7 @@ void Image::SetPixel(unsigned int x, unsigned int y, const Color& color) //////////////////////////////////////////////////////////// Color Image::GetPixel(unsigned int x, unsigned int y) const { - const Uint8* pixel = &myPixels[(x + y * myWidth) * 4]; + const Uint8* pixel = &m_pixels[(x + y * m_width) * 4]; return Color(pixel[0], pixel[1], pixel[2], pixel[3]); } @@ -252,9 +252,9 @@ Color Image::GetPixel(unsigned int x, unsigned int y) const //////////////////////////////////////////////////////////// const Uint8* Image::GetPixelsPtr() const { - if (!myPixels.empty()) + if (!m_pixels.empty()) { - return &myPixels[0]; + return &m_pixels[0]; } else { @@ -267,14 +267,14 @@ const Uint8* Image::GetPixelsPtr() const //////////////////////////////////////////////////////////// void Image::FlipHorizontally() { - if (!myPixels.empty()) + if (!m_pixels.empty()) { - std::vector before = myPixels; - for (unsigned int y = 0; y < myHeight; ++y) + std::vector before = m_pixels; + for (unsigned int y = 0; y < m_height; ++y) { - const Uint8* source = &before[y * myWidth * 4]; - Uint8* dest = &myPixels[(y + 1) * myWidth * 4 - 4]; - for (unsigned int x = 0; x < myWidth; ++x) + const Uint8* source = &before[y * m_width * 4]; + Uint8* dest = &m_pixels[(y + 1) * m_width * 4 - 4]; + for (unsigned int x = 0; x < m_width; ++x) { dest[0] = source[0]; dest[1] = source[1]; @@ -292,14 +292,14 @@ void Image::FlipHorizontally() //////////////////////////////////////////////////////////// void Image::FlipVertically() { - if (!myPixels.empty()) + if (!m_pixels.empty()) { - std::vector before = myPixels; - const Uint8* source = &before[myWidth * (myHeight - 1) * 4]; - Uint8* dest = &myPixels[0]; - std::size_t rowSize = myWidth * 4; + std::vector before = m_pixels; + const Uint8* source = &before[m_width * (m_height - 1) * 4]; + Uint8* dest = &m_pixels[0]; + std::size_t rowSize = m_width * 4; - for (unsigned int y = 0; y < myHeight; ++y) + for (unsigned int y = 0; y < m_height; ++y) { std::memcpy(dest, source, rowSize); source -= rowSize; diff --git a/src/SFML/Graphics/RectangleShape.cpp b/src/SFML/Graphics/RectangleShape.cpp index 342e30d2..fac62391 100644 --- a/src/SFML/Graphics/RectangleShape.cpp +++ b/src/SFML/Graphics/RectangleShape.cpp @@ -41,7 +41,7 @@ RectangleShape::RectangleShape(const Vector2f& size) //////////////////////////////////////////////////////////// void RectangleShape::SetSize(const Vector2f& size) { - mySize = size; + m_size = size; Update(); } @@ -49,7 +49,7 @@ void RectangleShape::SetSize(const Vector2f& size) //////////////////////////////////////////////////////////// const Vector2f& RectangleShape::GetSize() const { - return mySize; + return m_size; } @@ -67,9 +67,9 @@ Vector2f RectangleShape::GetPoint(unsigned int index) const { default: case 0: return Vector2f(0, 0); - case 1: return Vector2f(mySize.x, 0); - case 2: return Vector2f(mySize.x, mySize.y); - case 3: return Vector2f(0, mySize.y); + case 1: return Vector2f(m_size.x, 0); + case 2: return Vector2f(m_size.x, m_size.y); + case 3: return Vector2f(0, m_size.y); } } diff --git a/src/SFML/Graphics/RenderTarget.cpp b/src/SFML/Graphics/RenderTarget.cpp index 49b8c6ae..69e25640 100644 --- a/src/SFML/Graphics/RenderTarget.cpp +++ b/src/SFML/Graphics/RenderTarget.cpp @@ -38,9 +38,9 @@ namespace sf { //////////////////////////////////////////////////////////// RenderTarget::RenderTarget() : -myDefaultView(), -myView (), -myCache () +m_defaultView(), +m_view (), +m_cache () { } @@ -65,22 +65,22 @@ void RenderTarget::Clear(const Color& color) //////////////////////////////////////////////////////////// void RenderTarget::SetView(const View& view) { - myView = view; - myCache.ViewChanged = true; + m_view = view; + m_cache.ViewChanged = true; } //////////////////////////////////////////////////////////// const View& RenderTarget::GetView() const { - return myView; + return m_view; } //////////////////////////////////////////////////////////// const View& RenderTarget::GetDefaultView() const { - return myDefaultView; + return m_defaultView; } @@ -143,14 +143,14 @@ void RenderTarget::Draw(const Vertex* vertices, unsigned int vertexCount, // Pre-transform the vertices and store them into the vertex cache for (unsigned int i = 0; i < vertexCount; ++i) { - Vertex& vertex = myCache.VertexCache[i]; + Vertex& vertex = m_cache.VertexCache[i]; vertex.Position = states.Transform * vertices[i].Position; vertex.Color = vertices[i].Color; vertex.TexCoords = vertices[i].TexCoords; } // Since vertices are transformed, we must use an identity transform to render them - if (!myCache.UseVertexCache) + if (!m_cache.UseVertexCache) ApplyTransform(Transform::Identity); } else @@ -159,16 +159,16 @@ void RenderTarget::Draw(const Vertex* vertices, unsigned int vertexCount, } // Apply the view - if (myCache.ViewChanged) + if (m_cache.ViewChanged) ApplyCurrentView(); // Apply the blend mode - if (states.BlendMode != myCache.LastBlendMode) + if (states.BlendMode != m_cache.LastBlendMode) ApplyBlendMode(states.BlendMode); // Apply the texture - Uint64 textureId = states.Texture ? states.Texture->myCacheId : 0; - if (textureId != myCache.LastTextureId) + Uint64 textureId = states.Texture ? states.Texture->m_cacheId : 0; + if (textureId != m_cache.LastTextureId) ApplyTexture(states.Texture); // Apply the shader @@ -179,8 +179,8 @@ void RenderTarget::Draw(const Vertex* vertices, unsigned int vertexCount, if (useVertexCache) { // ... and if we already used it previously, we don't need to set the pointers again - if (!myCache.UseVertexCache) - vertices = myCache.VertexCache; + if (!m_cache.UseVertexCache) + vertices = m_cache.VertexCache; else vertices = NULL; } @@ -207,7 +207,7 @@ void RenderTarget::Draw(const Vertex* vertices, unsigned int vertexCount, ApplyShader(NULL); // Update the cache - myCache.UseVertexCache = useVertexCache; + m_cache.UseVertexCache = useVertexCache; } } @@ -272,7 +272,7 @@ void RenderTarget::ResetGLStates() ApplyTexture(NULL); if (Shader::IsAvailable()) ApplyShader(NULL); - myCache.UseVertexCache = false; + m_cache.UseVertexCache = false; // Set the default view SetView(GetView()); @@ -284,8 +284,8 @@ void RenderTarget::ResetGLStates() void RenderTarget::Initialize() { // Setup the default and current views - myDefaultView.Reset(FloatRect(0, 0, static_cast(GetSize().x), static_cast(GetSize().y))); - myView = myDefaultView; + m_defaultView.Reset(FloatRect(0, 0, static_cast(GetSize().x), static_cast(GetSize().y))); + m_view = m_defaultView; // Initialize the default OpenGL render-states ResetGLStates(); @@ -296,18 +296,18 @@ void RenderTarget::Initialize() void RenderTarget::ApplyCurrentView() { // Set the viewport - IntRect viewport = GetViewport(myView); + IntRect viewport = GetViewport(m_view); int top = GetSize().y - (viewport.Top + viewport.Height); GLCheck(glViewport(viewport.Left, top, viewport.Width, viewport.Height)); // Set the projection matrix GLCheck(glMatrixMode(GL_PROJECTION)); - GLCheck(glLoadMatrixf(myView.GetTransform().GetMatrix())); + GLCheck(glLoadMatrixf(m_view.GetTransform().GetMatrix())); // Go back to model-view mode GLCheck(glMatrixMode(GL_MODELVIEW)); - myCache.ViewChanged = false; + m_cache.ViewChanged = false; } @@ -343,7 +343,7 @@ void RenderTarget::ApplyBlendMode(BlendMode mode) break; } - myCache.LastBlendMode = mode; + m_cache.LastBlendMode = mode; } @@ -364,7 +364,7 @@ void RenderTarget::ApplyTexture(const Texture* texture) else GLCheck(glBindTexture(GL_TEXTURE_2D, 0)); - myCache.LastTextureId = texture ? texture->myCacheId : 0; + m_cache.LastTextureId = texture ? texture->m_cacheId : 0; } diff --git a/src/SFML/Graphics/RenderTexture.cpp b/src/SFML/Graphics/RenderTexture.cpp index 3e76afce..c079c6d5 100644 --- a/src/SFML/Graphics/RenderTexture.cpp +++ b/src/SFML/Graphics/RenderTexture.cpp @@ -35,7 +35,7 @@ namespace sf { //////////////////////////////////////////////////////////// RenderTexture::RenderTexture() : -myImpl(NULL) +m_impl(NULL) { } @@ -44,7 +44,7 @@ myImpl(NULL) //////////////////////////////////////////////////////////// RenderTexture::~RenderTexture() { - delete myImpl; + delete m_impl; } @@ -52,7 +52,7 @@ RenderTexture::~RenderTexture() bool RenderTexture::Create(unsigned int width, unsigned int height, bool depthBuffer) { // Create the texture - if (!myTexture.Create(width, height)) + if (!m_texture.Create(width, height)) { Err() << "Impossible to create render texture (failed to create the target texture)" << std::endl; return false; @@ -62,20 +62,20 @@ bool RenderTexture::Create(unsigned int width, unsigned int height, bool depthBu SetSmooth(false); // Create the implementation - delete myImpl; + delete m_impl; if (priv::RenderTextureImplFBO::IsAvailable()) { // Use frame-buffer object (FBO) - myImpl = new priv::RenderTextureImplFBO; + m_impl = new priv::RenderTextureImplFBO; } else { // Use default implementation - myImpl = new priv::RenderTextureImplDefault; + m_impl = new priv::RenderTextureImplDefault; } // Initialize the render texture - if (!myImpl->Create(width, height, myTexture.myTexture, depthBuffer)) + if (!m_impl->Create(width, height, m_texture.m_texture, depthBuffer)) return false; // We can now initialize the render target part @@ -88,21 +88,21 @@ bool RenderTexture::Create(unsigned int width, unsigned int height, bool depthBu //////////////////////////////////////////////////////////// void RenderTexture::SetSmooth(bool smooth) { - myTexture.SetSmooth(smooth); + m_texture.SetSmooth(smooth); } //////////////////////////////////////////////////////////// bool RenderTexture::IsSmooth() const { - return myTexture.IsSmooth(); + return m_texture.IsSmooth(); } //////////////////////////////////////////////////////////// bool RenderTexture::SetActive(bool active) { - return myImpl && myImpl->Activate(active); + return m_impl && m_impl->Activate(active); } @@ -112,8 +112,8 @@ void RenderTexture::Display() // Update the target texture if (SetActive(true)) { - myImpl->UpdateTexture(myTexture.myTexture); - myTexture.myPixelsFlipped = true; + m_impl->UpdateTexture(m_texture.m_texture); + m_texture.m_pixelsFlipped = true; } } @@ -121,14 +121,14 @@ void RenderTexture::Display() //////////////////////////////////////////////////////////// Vector2u RenderTexture::GetSize() const { - return Vector2u(myTexture.GetWidth(), myTexture.GetHeight()); + return Vector2u(m_texture.GetWidth(), m_texture.GetHeight()); } //////////////////////////////////////////////////////////// const Texture& RenderTexture::GetTexture() const { - return myTexture; + return m_texture; } diff --git a/src/SFML/Graphics/RenderTextureImplDefault.cpp b/src/SFML/Graphics/RenderTextureImplDefault.cpp index 481eed64..9fc0225c 100644 --- a/src/SFML/Graphics/RenderTextureImplDefault.cpp +++ b/src/SFML/Graphics/RenderTextureImplDefault.cpp @@ -38,9 +38,9 @@ namespace priv { //////////////////////////////////////////////////////////// RenderTextureImplDefault::RenderTextureImplDefault() : -myContext(0), -myWidth (0), -myHeight (0) +m_context(0), +m_width (0), +m_height (0) { } @@ -50,7 +50,7 @@ myHeight (0) RenderTextureImplDefault::~RenderTextureImplDefault() { // Destroy the context - delete myContext; + delete m_context; } @@ -58,11 +58,11 @@ RenderTextureImplDefault::~RenderTextureImplDefault() bool RenderTextureImplDefault::Create(unsigned int width, unsigned int height, unsigned int, bool depthBuffer) { // Store the dimensions - myWidth = width; - myHeight = height; + m_width = width; + m_height = height; // Create the in-memory OpenGL context - myContext = new Context(ContextSettings(depthBuffer ? 32 : 0), width, height); + m_context = new Context(ContextSettings(depthBuffer ? 32 : 0), width, height); return true; } @@ -71,7 +71,7 @@ bool RenderTextureImplDefault::Create(unsigned int width, unsigned int height, u //////////////////////////////////////////////////////////// bool RenderTextureImplDefault::Activate(bool active) { - return myContext->SetActive(active); + return m_context->SetActive(active); } @@ -83,7 +83,7 @@ void RenderTextureImplDefault::UpdateTexture(unsigned int textureId) // Copy the rendered pixels to the texture GLCheck(glBindTexture(GL_TEXTURE_2D, textureId)); - GLCheck(glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, myWidth, myHeight)); + GLCheck(glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, m_width, m_height)); } } // namespace priv diff --git a/src/SFML/Graphics/RenderTextureImplDefault.hpp b/src/SFML/Graphics/RenderTextureImplDefault.hpp index c66b922e..9552f991 100644 --- a/src/SFML/Graphics/RenderTextureImplDefault.hpp +++ b/src/SFML/Graphics/RenderTextureImplDefault.hpp @@ -94,9 +94,9 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - Context* myContext; ///< P-Buffer based context - unsigned int myWidth; ///< Width of the P-Buffer - unsigned int myHeight; ///< Height of the P-Buffer + Context* m_context; ///< P-Buffer based context + unsigned int m_width; ///< Width of the P-Buffer + unsigned int m_height; ///< Height of the P-Buffer }; } // namespace priv diff --git a/src/SFML/Graphics/RenderTextureImplFBO.cpp b/src/SFML/Graphics/RenderTextureImplFBO.cpp index d7ded0de..c615929e 100644 --- a/src/SFML/Graphics/RenderTextureImplFBO.cpp +++ b/src/SFML/Graphics/RenderTextureImplFBO.cpp @@ -37,8 +37,8 @@ namespace priv { //////////////////////////////////////////////////////////// RenderTextureImplFBO::RenderTextureImplFBO() : -myFrameBuffer(0), -myDepthBuffer(0) +m_frameBuffer(0), +m_depthBuffer(0) { } @@ -50,21 +50,21 @@ RenderTextureImplFBO::~RenderTextureImplFBO() EnsureGlContext(); // Destroy the depth buffer - if (myDepthBuffer) + if (m_depthBuffer) { - GLuint depthBuffer = static_cast(myDepthBuffer); + GLuint depthBuffer = static_cast(m_depthBuffer); GLCheck(glDeleteFramebuffersEXT(1, &depthBuffer)); } // Destroy the frame buffer - if (myFrameBuffer) + if (m_frameBuffer) { - GLuint frameBuffer = static_cast(myFrameBuffer); + GLuint frameBuffer = static_cast(m_frameBuffer); GLCheck(glDeleteFramebuffersEXT(1, &frameBuffer)); } // Delete the context - delete myContext; + delete m_context; } @@ -84,33 +84,33 @@ bool RenderTextureImplFBO::IsAvailable() bool RenderTextureImplFBO::Create(unsigned int width, unsigned int height, unsigned int textureId, bool depthBuffer) { // Create the context - myContext = new Context; + m_context = new Context; // Create the framebuffer object GLuint frameBuffer = 0; GLCheck(glGenFramebuffersEXT(1, &frameBuffer)); - myFrameBuffer = static_cast(frameBuffer); - if (!myFrameBuffer) + m_frameBuffer = static_cast(frameBuffer); + if (!m_frameBuffer) { Err() << "Impossible to create render texture (failed to create the frame buffer object)" << std::endl; return false; } - GLCheck(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, myFrameBuffer)); + GLCheck(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_frameBuffer)); // Create the depth buffer if requested if (depthBuffer) { GLuint depth = 0; GLCheck(glGenRenderbuffersEXT(1, &depth)); - myDepthBuffer = static_cast(depth); - if (!myDepthBuffer) + m_depthBuffer = static_cast(depth); + if (!m_depthBuffer) { Err() << "Impossible to create render texture (failed to create the attached depth buffer)" << std::endl; return false; } - GLCheck(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, myDepthBuffer)); + GLCheck(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_depthBuffer)); GLCheck(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, height)); - GLCheck(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, myDepthBuffer)); + GLCheck(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthBuffer)); } // Link the texture to the frame buffer @@ -131,7 +131,7 @@ bool RenderTextureImplFBO::Create(unsigned int width, unsigned int height, unsig //////////////////////////////////////////////////////////// bool RenderTextureImplFBO::Activate(bool active) { - return myContext->SetActive(active); + return m_context->SetActive(active); } //////////////////////////////////////////////////////////// diff --git a/src/SFML/Graphics/RenderTextureImplFBO.hpp b/src/SFML/Graphics/RenderTextureImplFBO.hpp index 489341dc..cabf45f5 100644 --- a/src/SFML/Graphics/RenderTextureImplFBO.hpp +++ b/src/SFML/Graphics/RenderTextureImplFBO.hpp @@ -102,9 +102,9 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - Context* myContext; ///< Needs a separate OpenGL context for not messing up the other ones - unsigned int myFrameBuffer; ///< OpenGL frame buffer object - unsigned int myDepthBuffer; ///< Optional depth buffer attached to the frame buffer + Context* m_context; ///< Needs a separate OpenGL context for not messing up the other ones + unsigned int m_frameBuffer; ///< OpenGL frame buffer object + unsigned int m_depthBuffer; ///< Optional depth buffer attached to the frame buffer }; } // namespace priv diff --git a/src/SFML/Graphics/Shader.cpp b/src/SFML/Graphics/Shader.cpp index dc4c434c..2ababcc9 100644 --- a/src/SFML/Graphics/Shader.cpp +++ b/src/SFML/Graphics/Shader.cpp @@ -85,8 +85,8 @@ Shader::CurrentTextureType Shader::CurrentTexture; //////////////////////////////////////////////////////////// Shader::Shader() : -myShaderProgram (0), -myCurrentTexture(-1) +m_shaderProgram (0), +m_currentTexture(-1) { } @@ -97,8 +97,8 @@ Shader::~Shader() EnsureGlContext(); // Destroy effect program - if (myShaderProgram) - GLCheck(glDeleteObjectARB(myShaderProgram)); + if (m_shaderProgram) + GLCheck(glDeleteObjectARB(m_shaderProgram)); } @@ -210,16 +210,16 @@ bool Shader::LoadFromStream(InputStream& vertexShaderStream, InputStream& fragme //////////////////////////////////////////////////////////// void Shader::SetParameter(const std::string& name, float x) { - if (myShaderProgram) + if (m_shaderProgram) { EnsureGlContext(); // Enable program GLhandleARB program = glGetHandleARB(GL_PROGRAM_OBJECT_ARB); - GLCheck(glUseProgramObjectARB(myShaderProgram)); + GLCheck(glUseProgramObjectARB(m_shaderProgram)); // Get parameter location and assign it new values - GLint location = glGetUniformLocationARB(myShaderProgram, name.c_str()); + GLint location = glGetUniformLocationARB(m_shaderProgram, name.c_str()); if (location != -1) GLCheck(glUniform1fARB(location, x)); else @@ -234,16 +234,16 @@ void Shader::SetParameter(const std::string& name, float x) //////////////////////////////////////////////////////////// void Shader::SetParameter(const std::string& name, float x, float y) { - if (myShaderProgram) + if (m_shaderProgram) { EnsureGlContext(); // Enable program GLhandleARB program = glGetHandleARB(GL_PROGRAM_OBJECT_ARB); - GLCheck(glUseProgramObjectARB(myShaderProgram)); + GLCheck(glUseProgramObjectARB(m_shaderProgram)); // Get parameter location and assign it new values - GLint location = glGetUniformLocationARB(myShaderProgram, name.c_str()); + GLint location = glGetUniformLocationARB(m_shaderProgram, name.c_str()); if (location != -1) GLCheck(glUniform2fARB(location, x, y)); else @@ -258,16 +258,16 @@ void Shader::SetParameter(const std::string& name, float x, float y) //////////////////////////////////////////////////////////// void Shader::SetParameter(const std::string& name, float x, float y, float z) { - if (myShaderProgram) + if (m_shaderProgram) { EnsureGlContext(); // Enable program GLhandleARB program = glGetHandleARB(GL_PROGRAM_OBJECT_ARB); - GLCheck(glUseProgramObjectARB(myShaderProgram)); + GLCheck(glUseProgramObjectARB(m_shaderProgram)); // Get parameter location and assign it new values - GLint location = glGetUniformLocationARB(myShaderProgram, name.c_str()); + GLint location = glGetUniformLocationARB(m_shaderProgram, name.c_str()); if (location != -1) GLCheck(glUniform3fARB(location, x, y, z)); else @@ -282,16 +282,16 @@ void Shader::SetParameter(const std::string& name, float x, float y, float z) //////////////////////////////////////////////////////////// void Shader::SetParameter(const std::string& name, float x, float y, float z, float w) { - if (myShaderProgram) + if (m_shaderProgram) { EnsureGlContext(); // Enable program GLhandleARB program = glGetHandleARB(GL_PROGRAM_OBJECT_ARB); - GLCheck(glUseProgramObjectARB(myShaderProgram)); + GLCheck(glUseProgramObjectARB(m_shaderProgram)); // Get parameter location and assign it new values - GLint location = glGetUniformLocationARB(myShaderProgram, name.c_str()); + GLint location = glGetUniformLocationARB(m_shaderProgram, name.c_str()); if (location != -1) GLCheck(glUniform4fARB(location, x, y, z, w)); else @@ -327,16 +327,16 @@ void Shader::SetParameter(const std::string& name, const Color& color) //////////////////////////////////////////////////////////// void Shader::SetParameter(const std::string& name, const sf::Transform& transform) { - if (myShaderProgram) + if (m_shaderProgram) { EnsureGlContext(); // Enable program GLhandleARB program = glGetHandleARB(GL_PROGRAM_OBJECT_ARB); - GLCheck(glUseProgramObjectARB(myShaderProgram)); + GLCheck(glUseProgramObjectARB(m_shaderProgram)); // Get parameter location and assign it new values - GLint location = glGetUniformLocationARB(myShaderProgram, name.c_str()); + GLint location = glGetUniformLocationARB(m_shaderProgram, name.c_str()); if (location != -1) GLCheck(glUniformMatrix4fvARB(location, 1, GL_FALSE, transform.GetMatrix())); else @@ -351,12 +351,12 @@ void Shader::SetParameter(const std::string& name, const sf::Transform& transfor //////////////////////////////////////////////////////////// void Shader::SetParameter(const std::string& name, const Texture& texture) { - if (myShaderProgram) + if (m_shaderProgram) { EnsureGlContext(); // Find the location of the variable in the shader - int location = glGetUniformLocationARB(myShaderProgram, name.c_str()); + int location = glGetUniformLocationARB(m_shaderProgram, name.c_str()); if (location == -1) { Err() << "Texture \"" << name << "\" not found in shader" << std::endl; @@ -364,18 +364,18 @@ void Shader::SetParameter(const std::string& name, const Texture& texture) } // Store the location -> texture mapping - TextureTable::iterator it = myTextures.find(location); - if (it == myTextures.end()) + TextureTable::iterator it = m_textures.find(location); + if (it == m_textures.end()) { // New entry, make sure there are enough texture units static const GLint maxUnits = GetMaxTextureUnits(); - if (myTextures.size() + 1 >= static_cast(maxUnits)) + if (m_textures.size() + 1 >= static_cast(maxUnits)) { Err() << "Impossible to use texture \"" << name << "\" for shader: all available texture units are used" << std::endl; return; } - myTextures[location] = &texture; + m_textures[location] = &texture; } else { @@ -389,13 +389,13 @@ void Shader::SetParameter(const std::string& name, const Texture& texture) //////////////////////////////////////////////////////////// void Shader::SetParameter(const std::string& name, CurrentTextureType) { - if (myShaderProgram) + if (m_shaderProgram) { EnsureGlContext(); // Find the location of the variable in the shader - myCurrentTexture = glGetUniformLocationARB(myShaderProgram, name.c_str()); - if (myCurrentTexture == -1) + m_currentTexture = glGetUniformLocationARB(m_shaderProgram, name.c_str()); + if (m_currentTexture == -1) Err() << "Texture \"" << name << "\" not found in shader" << std::endl; } } @@ -404,19 +404,19 @@ void Shader::SetParameter(const std::string& name, CurrentTextureType) //////////////////////////////////////////////////////////// void Shader::Bind() const { - if (myShaderProgram) + if (m_shaderProgram) { EnsureGlContext(); // Enable the program - GLCheck(glUseProgramObjectARB(myShaderProgram)); + GLCheck(glUseProgramObjectARB(m_shaderProgram)); // Bind the textures BindTextures(); // Bind the current texture - if (myCurrentTexture != -1) - GLCheck(glUniform1iARB(myCurrentTexture, 0)); + if (m_currentTexture != -1) + GLCheck(glUniform1iARB(m_currentTexture, 0)); } } @@ -459,11 +459,11 @@ bool Shader::Compile(const char* vertexShaderCode, const char* fragmentShaderCod } // Destroy the shader if it was already created - if (myShaderProgram) - GLCheck(glDeleteObjectARB(myShaderProgram)); + if (m_shaderProgram) + GLCheck(glDeleteObjectARB(m_shaderProgram)); // Create the program - myShaderProgram = glCreateProgramObjectARB(); + m_shaderProgram = glCreateProgramObjectARB(); // Create the vertex shader if needed if (vertexShaderCode) @@ -483,13 +483,13 @@ bool Shader::Compile(const char* vertexShaderCode, const char* fragmentShaderCod Err() << "Failed to compile vertex shader:" << std::endl << log << std::endl; GLCheck(glDeleteObjectARB(vertexShader)); - GLCheck(glDeleteObjectARB(myShaderProgram)); - myShaderProgram = 0; + GLCheck(glDeleteObjectARB(m_shaderProgram)); + m_shaderProgram = 0; return false; } // Attach the shader to the program, and delete it (not needed anymore) - GLCheck(glAttachObjectARB(myShaderProgram, vertexShader)); + GLCheck(glAttachObjectARB(m_shaderProgram, vertexShader)); GLCheck(glDeleteObjectARB(vertexShader)); } @@ -511,30 +511,30 @@ bool Shader::Compile(const char* vertexShaderCode, const char* fragmentShaderCod Err() << "Failed to compile fragment shader:" << std::endl << log << std::endl; GLCheck(glDeleteObjectARB(fragmentShader)); - GLCheck(glDeleteObjectARB(myShaderProgram)); - myShaderProgram = 0; + GLCheck(glDeleteObjectARB(m_shaderProgram)); + m_shaderProgram = 0; return false; } // Attach the shader to the program, and delete it (not needed anymore) - GLCheck(glAttachObjectARB(myShaderProgram, fragmentShader)); + GLCheck(glAttachObjectARB(m_shaderProgram, fragmentShader)); GLCheck(glDeleteObjectARB(fragmentShader)); } // Link the program - GLCheck(glLinkProgramARB(myShaderProgram)); + GLCheck(glLinkProgramARB(m_shaderProgram)); // Check the link log GLint success; - GLCheck(glGetObjectParameterivARB(myShaderProgram, GL_OBJECT_LINK_STATUS_ARB, &success)); + GLCheck(glGetObjectParameterivARB(m_shaderProgram, GL_OBJECT_LINK_STATUS_ARB, &success)); if (success == GL_FALSE) { char log[1024]; - GLCheck(glGetInfoLogARB(myShaderProgram, sizeof(log), 0, log)); + GLCheck(glGetInfoLogARB(m_shaderProgram, sizeof(log), 0, log)); Err() << "Failed to link shader:" << std::endl << log << std::endl; - GLCheck(glDeleteObjectARB(myShaderProgram)); - myShaderProgram = 0; + GLCheck(glDeleteObjectARB(m_shaderProgram)); + m_shaderProgram = 0; return false; } @@ -545,8 +545,8 @@ bool Shader::Compile(const char* vertexShaderCode, const char* fragmentShaderCod //////////////////////////////////////////////////////////// void Shader::BindTextures() const { - TextureTable::const_iterator it = myTextures.begin(); - for (std::size_t i = 0; i < myTextures.size(); ++i) + TextureTable::const_iterator it = m_textures.begin(); + for (std::size_t i = 0; i < m_textures.size(); ++i) { GLint index = static_cast(i + 1); GLCheck(glUniform1iARB(it->first, index)); diff --git a/src/SFML/Graphics/Shape.cpp b/src/SFML/Graphics/Shape.cpp index e70d5204..5988ed12 100644 --- a/src/SFML/Graphics/Shape.cpp +++ b/src/SFML/Graphics/Shape.cpp @@ -58,25 +58,25 @@ Shape::~Shape() void Shape::SetTexture(const Texture* texture, bool resetRect) { // Recompute the texture area if requested, or if there was no texture before - if (texture && (resetRect || !myTexture)) + if (texture && (resetRect || !m_texture)) SetTextureRect(IntRect(0, 0, texture->GetWidth(), texture->GetHeight())); // Assign the new texture - myTexture = texture; + m_texture = texture; } //////////////////////////////////////////////////////////// const Texture* Shape::GetTexture() const { - return myTexture; + return m_texture; } //////////////////////////////////////////////////////////// void Shape::SetTextureRect(const IntRect& rect) { - myTextureRect = rect; + m_textureRect = rect; UpdateTexCoords(); } @@ -84,14 +84,14 @@ void Shape::SetTextureRect(const IntRect& rect) //////////////////////////////////////////////////////////// const IntRect& Shape::GetTextureRect() const { - return myTextureRect; + return m_textureRect; } //////////////////////////////////////////////////////////// void Shape::SetFillColor(const Color& color) { - myFillColor = color; + m_fillColor = color; UpdateFillColors(); } @@ -99,14 +99,14 @@ void Shape::SetFillColor(const Color& color) //////////////////////////////////////////////////////////// const Color& Shape::GetFillColor() const { - return myFillColor; + return m_fillColor; } //////////////////////////////////////////////////////////// void Shape::SetOutlineColor(const Color& color) { - myOutlineColor = color; + m_outlineColor = color; UpdateOutlineColors(); } @@ -114,14 +114,14 @@ void Shape::SetOutlineColor(const Color& color) //////////////////////////////////////////////////////////// const Color& Shape::GetOutlineColor() const { - return myOutlineColor; + return m_outlineColor; } //////////////////////////////////////////////////////////// void Shape::SetOutlineThickness(float thickness) { - myOutlineThickness = thickness; + m_outlineThickness = thickness; Update(); // recompute everything because the whole shape must be offset } @@ -129,14 +129,14 @@ void Shape::SetOutlineThickness(float thickness) //////////////////////////////////////////////////////////// float Shape::GetOutlineThickness() const { - return myOutlineThickness; + return m_outlineThickness; } //////////////////////////////////////////////////////////// FloatRect Shape::GetLocalBounds() const { - return myBounds; + return m_bounds; } @@ -149,15 +149,15 @@ FloatRect Shape::GetGlobalBounds() const //////////////////////////////////////////////////////////// Shape::Shape() : -myTexture (NULL), -myTextureRect (), -myFillColor (255, 255, 255), -myOutlineColor (255, 255, 255), -myOutlineThickness(0), -myVertices (TrianglesFan), -myOutlineVertices (TrianglesStrip), -myInsideBounds (), -myBounds () +m_texture (NULL), +m_textureRect (), +m_fillColor (255, 255, 255), +m_outlineColor (255, 255, 255), +m_outlineThickness(0), +m_vertices (TrianglesFan), +m_outlineVertices (TrianglesStrip), +m_insideBounds (), +m_bounds () { } @@ -169,25 +169,25 @@ void Shape::Update() unsigned int count = GetPointCount(); if (count < 3) { - myVertices.Resize(0); - myOutlineVertices.Resize(0); + m_vertices.Resize(0); + m_outlineVertices.Resize(0); return; } - myVertices.Resize(count + 2); // + 2 for center and repeated first point + m_vertices.Resize(count + 2); // + 2 for center and repeated first point // Position for (unsigned int i = 0; i < count; ++i) - myVertices[i + 1].Position = GetPoint(i); - myVertices[count + 1].Position = myVertices[1].Position; + m_vertices[i + 1].Position = GetPoint(i); + m_vertices[count + 1].Position = m_vertices[1].Position; // Update the bounding rectangle - myVertices[0] = myVertices[1]; // so that the result of GetBounds() is correct - myInsideBounds = myVertices.GetBounds(); + m_vertices[0] = m_vertices[1]; // so that the result of GetBounds() is correct + m_insideBounds = m_vertices.GetBounds(); // Compute the center and make it the first vertex - myVertices[0].Position.x = myInsideBounds.Left + myInsideBounds.Width / 2; - myVertices[0].Position.y = myInsideBounds.Top + myInsideBounds.Height / 2; + m_vertices[0].Position.x = m_insideBounds.Left + m_insideBounds.Width / 2; + m_vertices[0].Position.y = m_insideBounds.Top + m_insideBounds.Height / 2; // Color UpdateFillColors(); @@ -206,17 +206,17 @@ void Shape::Draw(RenderTarget& target, RenderStates states) const states.Transform *= GetTransform(); // Render the inside - if (myFillColor.a > 0) + if (m_fillColor.a > 0) { - states.Texture = myTexture; - target.Draw(myVertices, states); + states.Texture = m_texture; + target.Draw(m_vertices, states); } // Render the outline - if ((myOutlineColor.a > 0) && (myOutlineThickness > 0)) + if ((m_outlineColor.a > 0) && (m_outlineThickness > 0)) { states.Texture = NULL; - target.Draw(myOutlineVertices, states); + target.Draw(m_outlineVertices, states); } } @@ -224,20 +224,20 @@ void Shape::Draw(RenderTarget& target, RenderStates states) const //////////////////////////////////////////////////////////// void Shape::UpdateFillColors() { - for (unsigned int i = 0; i < myVertices.GetVertexCount(); ++i) - myVertices[i].Color = myFillColor; + for (unsigned int i = 0; i < m_vertices.GetVertexCount(); ++i) + m_vertices[i].Color = m_fillColor; } //////////////////////////////////////////////////////////// void Shape::UpdateTexCoords() { - for (unsigned int i = 0; i < myVertices.GetVertexCount(); ++i) + for (unsigned int i = 0; i < m_vertices.GetVertexCount(); ++i) { - float xratio = (myVertices[i].Position.x - myInsideBounds.Left) / myInsideBounds.Width; - float yratio = (myVertices[i].Position.y - myInsideBounds.Top) / myInsideBounds.Height; - myVertices[i].TexCoords.x = myTextureRect.Left + myTextureRect.Width * xratio; - myVertices[i].TexCoords.y = myTextureRect.Top + myTextureRect.Height * yratio; + float xratio = (m_vertices[i].Position.x - m_insideBounds.Left) / m_insideBounds.Width; + float yratio = (m_vertices[i].Position.y - m_insideBounds.Top) / m_insideBounds.Height; + m_vertices[i].TexCoords.x = m_textureRect.Left + m_textureRect.Width * xratio; + m_vertices[i].TexCoords.y = m_textureRect.Top + m_textureRect.Height * yratio; } } @@ -245,17 +245,17 @@ void Shape::UpdateTexCoords() //////////////////////////////////////////////////////////// void Shape::UpdateOutline() { - unsigned int count = myVertices.GetVertexCount() - 2; - myOutlineVertices.Resize((count + 1) * 2); + unsigned int count = m_vertices.GetVertexCount() - 2; + m_outlineVertices.Resize((count + 1) * 2); for (unsigned int i = 0; i < count; ++i) { unsigned int index = i + 1; // Get the two segments shared by the current point - Vector2f p0 = (i == 0) ? myVertices[count].Position : myVertices[index - 1].Position; - Vector2f p1 = myVertices[index].Position; - Vector2f p2 = myVertices[index + 1].Position; + Vector2f p0 = (i == 0) ? m_vertices[count].Position : m_vertices[index - 1].Position; + Vector2f p1 = m_vertices[index].Position; + Vector2f p2 = m_vertices[index + 1].Position; // Compute their normal Vector2f n1 = ComputeNormal(p0, p1); @@ -266,27 +266,27 @@ void Shape::UpdateOutline() Vector2f normal = -(n1 + n2) / factor; // Update the outline points - myOutlineVertices[i * 2 + 0].Position = p1; - myOutlineVertices[i * 2 + 1].Position = p1 + normal * myOutlineThickness; + m_outlineVertices[i * 2 + 0].Position = p1; + m_outlineVertices[i * 2 + 1].Position = p1 + normal * m_outlineThickness; } // Duplicate the first point at the end, to close the outline - myOutlineVertices[count * 2 + 0].Position = myOutlineVertices[0].Position; - myOutlineVertices[count * 2 + 1].Position = myOutlineVertices[1].Position; + m_outlineVertices[count * 2 + 0].Position = m_outlineVertices[0].Position; + m_outlineVertices[count * 2 + 1].Position = m_outlineVertices[1].Position; // Update outline colors UpdateOutlineColors(); // Update the shape's bounds - myBounds = myOutlineVertices.GetBounds(); + m_bounds = m_outlineVertices.GetBounds(); } //////////////////////////////////////////////////////////// void Shape::UpdateOutlineColors() { - for (unsigned int i = 0; i < myOutlineVertices.GetVertexCount(); ++i) - myOutlineVertices[i].Color = myOutlineColor; + for (unsigned int i = 0; i < m_outlineVertices.GetVertexCount(); ++i) + m_outlineVertices[i].Color = m_outlineColor; } } // namespace sf diff --git a/src/SFML/Graphics/Sprite.cpp b/src/SFML/Graphics/Sprite.cpp index cb8b1db0..1655f45c 100644 --- a/src/SFML/Graphics/Sprite.cpp +++ b/src/SFML/Graphics/Sprite.cpp @@ -34,16 +34,16 @@ namespace sf { //////////////////////////////////////////////////////////// Sprite::Sprite() : -myTexture (NULL), -myTextureRect(0, 0, 0, 0) +m_texture (NULL), +m_textureRect(0, 0, 0, 0) { } //////////////////////////////////////////////////////////// Sprite::Sprite(const Texture& texture) : -myTexture (NULL), -myTextureRect(0, 0, 0, 0) +m_texture (NULL), +m_textureRect(0, 0, 0, 0) { SetTexture(texture); } @@ -51,8 +51,8 @@ myTextureRect(0, 0, 0, 0) //////////////////////////////////////////////////////////// Sprite::Sprite(const Texture& texture, const IntRect& rectangle) : -myTexture (NULL), -myTextureRect(0, 0, 0, 0) +m_texture (NULL), +m_textureRect(0, 0, 0, 0) { SetTexture(texture); SetTextureRect(rectangle); @@ -63,20 +63,20 @@ myTextureRect(0, 0, 0, 0) void Sprite::SetTexture(const Texture& texture, bool resetRect) { // Recompute the texture area if requested, or if there was no valid texture before - if (resetRect || !myTexture) + if (resetRect || !m_texture) SetTextureRect(IntRect(0, 0, texture.GetWidth(), texture.GetHeight())); // Assign the new texture - myTexture = &texture; + m_texture = &texture; } //////////////////////////////////////////////////////////// void Sprite::SetTextureRect(const IntRect& rectangle) { - if (rectangle != myTextureRect) + if (rectangle != m_textureRect) { - myTextureRect = rectangle; + m_textureRect = rectangle; UpdatePositions(); UpdateTexCoords(); } @@ -87,39 +87,39 @@ void Sprite::SetTextureRect(const IntRect& rectangle) void Sprite::SetColor(const Color& color) { // Update the vertices' color - myVertices[0].Color = color; - myVertices[1].Color = color; - myVertices[2].Color = color; - myVertices[3].Color = color; + m_vertices[0].Color = color; + m_vertices[1].Color = color; + m_vertices[2].Color = color; + m_vertices[3].Color = color; } //////////////////////////////////////////////////////////// const Texture* Sprite::GetTexture() const { - return myTexture; + return m_texture; } //////////////////////////////////////////////////////////// const IntRect& Sprite::GetTextureRect() const { - return myTextureRect; + return m_textureRect; } //////////////////////////////////////////////////////////// const Color& Sprite::GetColor() const { - return myVertices[0].Color; + return m_vertices[0].Color; } //////////////////////////////////////////////////////////// FloatRect Sprite::GetLocalBounds() const { - float width = static_cast(myTextureRect.Width); - float height = static_cast(myTextureRect.Height); + float width = static_cast(m_textureRect.Width); + float height = static_cast(m_textureRect.Height); return FloatRect(0.f, 0.f, width, height); } @@ -135,11 +135,11 @@ FloatRect Sprite::GetGlobalBounds() const //////////////////////////////////////////////////////////// void Sprite::Draw(RenderTarget& target, RenderStates states) const { - if (myTexture) + if (m_texture) { states.Transform *= GetTransform(); - states.Texture = myTexture; - target.Draw(myVertices, 4, Quads, states); + states.Texture = m_texture; + target.Draw(m_vertices, 4, Quads, states); } } @@ -147,28 +147,28 @@ void Sprite::Draw(RenderTarget& target, RenderStates states) const //////////////////////////////////////////////////////////// void Sprite::UpdatePositions() { - float width = static_cast(myTextureRect.Width); - float height = static_cast(myTextureRect.Height); + float width = static_cast(m_textureRect.Width); + float height = static_cast(m_textureRect.Height); - myVertices[0].Position = Vector2f(0, 0); - myVertices[1].Position = Vector2f(0, height); - myVertices[2].Position = Vector2f(width, height); - myVertices[3].Position = Vector2f(width, 0); + m_vertices[0].Position = Vector2f(0, 0); + m_vertices[1].Position = Vector2f(0, height); + m_vertices[2].Position = Vector2f(width, height); + m_vertices[3].Position = Vector2f(width, 0); } //////////////////////////////////////////////////////////// void Sprite::UpdateTexCoords() { - float left = static_cast(myTextureRect.Left); - float right = left + myTextureRect.Width; - float top = static_cast(myTextureRect.Top); - float bottom = top + myTextureRect.Height; + float left = static_cast(m_textureRect.Left); + float right = left + m_textureRect.Width; + float top = static_cast(m_textureRect.Top); + float bottom = top + m_textureRect.Height; - myVertices[0].TexCoords = Vector2f(left, top); - myVertices[1].TexCoords = Vector2f(left, bottom); - myVertices[2].TexCoords = Vector2f(right, bottom); - myVertices[3].TexCoords = Vector2f(right, top); + m_vertices[0].TexCoords = Vector2f(left, top); + m_vertices[1].TexCoords = Vector2f(left, bottom); + m_vertices[2].TexCoords = Vector2f(right, bottom); + m_vertices[3].TexCoords = Vector2f(right, top); } } // namespace sf diff --git a/src/SFML/Graphics/Text.cpp b/src/SFML/Graphics/Text.cpp index ce78c024..55933589 100644 --- a/src/SFML/Graphics/Text.cpp +++ b/src/SFML/Graphics/Text.cpp @@ -35,13 +35,13 @@ namespace sf { //////////////////////////////////////////////////////////// Text::Text() : -myString (), -myFont (&Font::GetDefaultFont()), -myCharacterSize(30), -myStyle (Regular), -myColor (255, 255, 255), -myVertices (Quads), -myBounds () +m_string (), +m_font (&Font::GetDefaultFont()), +m_characterSize(30), +m_style (Regular), +m_color (255, 255, 255), +m_vertices (Quads), +m_bounds () { } @@ -49,13 +49,13 @@ myBounds () //////////////////////////////////////////////////////////// Text::Text(const String& string, const Font& font, unsigned int characterSize) : -myString (string), -myFont (&font), -myCharacterSize(characterSize), -myStyle (Regular), -myColor (255, 255, 255), -myVertices (Quads), -myBounds () +m_string (string), +m_font (&font), +m_characterSize(characterSize), +m_style (Regular), +m_color (255, 255, 255), +m_vertices (Quads), +m_bounds () { UpdateGeometry(); } @@ -64,7 +64,7 @@ myBounds () //////////////////////////////////////////////////////////// void Text::SetString(const String& string) { - myString = string; + m_string = string; UpdateGeometry(); } @@ -72,9 +72,9 @@ void Text::SetString(const String& string) //////////////////////////////////////////////////////////// void Text::SetFont(const Font& font) { - if (myFont != &font) + if (m_font != &font) { - myFont = &font; + m_font = &font; UpdateGeometry(); } } @@ -83,9 +83,9 @@ void Text::SetFont(const Font& font) //////////////////////////////////////////////////////////// void Text::SetCharacterSize(unsigned int size) { - if (myCharacterSize != size) + if (m_characterSize != size) { - myCharacterSize = size; + m_characterSize = size; UpdateGeometry(); } } @@ -94,9 +94,9 @@ void Text::SetCharacterSize(unsigned int size) //////////////////////////////////////////////////////////// void Text::SetStyle(Uint32 style) { - if (myStyle != style) + if (m_style != style) { - myStyle = style; + m_style = style; UpdateGeometry(); } } @@ -105,11 +105,11 @@ void Text::SetStyle(Uint32 style) //////////////////////////////////////////////////////////// void Text::SetColor(const Color& color) { - if (color != myColor) + if (color != m_color) { - myColor = color; - for (unsigned int i = 0; i < myVertices.GetVertexCount(); ++i) - myVertices[i].Color = myColor; + m_color = color; + for (unsigned int i = 0; i < m_vertices.GetVertexCount(); ++i) + m_vertices[i].Color = m_color; } } @@ -117,62 +117,62 @@ void Text::SetColor(const Color& color) //////////////////////////////////////////////////////////// const String& Text::GetString() const { - return myString; + return m_string; } //////////////////////////////////////////////////////////// const Font& Text::GetFont() const { - assert(myFont != NULL); // can never be NULL, always &Font::GetDefaultFont() by default - return *myFont; + assert(m_font != NULL); // can never be NULL, always &Font::GetDefaultFont() by default + return *m_font; } //////////////////////////////////////////////////////////// unsigned int Text::GetCharacterSize() const { - return myCharacterSize; + return m_characterSize; } //////////////////////////////////////////////////////////// Uint32 Text::GetStyle() const { - return myStyle; + return m_style; } //////////////////////////////////////////////////////////// const Color& Text::GetColor() const { - return myColor; + return m_color; } //////////////////////////////////////////////////////////// Vector2f Text::FindCharacterPos(std::size_t index) const { - assert(myFont != NULL); + assert(m_font != NULL); // Adjust the index if it's out of range - if (index > myString.GetSize()) - index = myString.GetSize(); + if (index > m_string.GetSize()) + index = m_string.GetSize(); // Precompute the variables needed by the algorithm - bool bold = (myStyle & Bold) != 0; - float hspace = static_cast(myFont->GetGlyph(L' ', myCharacterSize, bold).Advance); - float vspace = static_cast(myFont->GetLineSpacing(myCharacterSize)); + bool bold = (m_style & Bold) != 0; + float hspace = static_cast(m_font->GetGlyph(L' ', m_characterSize, bold).Advance); + float vspace = static_cast(m_font->GetLineSpacing(m_characterSize)); // Compute the position Vector2f position; Uint32 prevChar = 0; for (std::size_t i = 0; i < index; ++i) { - Uint32 curChar = myString[i]; + Uint32 curChar = m_string[i]; // Apply the kerning offset - position.x += static_cast(myFont->GetKerning(prevChar, curChar, myCharacterSize)); + position.x += static_cast(m_font->GetKerning(prevChar, curChar, m_characterSize)); prevChar = curChar; // Handle special characters @@ -185,7 +185,7 @@ Vector2f Text::FindCharacterPos(std::size_t index) const } // For regular characters, add the advance offset of the glyph - position.x += static_cast(myFont->GetGlyph(curChar, myCharacterSize, bold).Advance); + position.x += static_cast(m_font->GetGlyph(curChar, m_characterSize, bold).Advance); } // Transform the position to global coordinates @@ -198,7 +198,7 @@ Vector2f Text::FindCharacterPos(std::size_t index) const //////////////////////////////////////////////////////////// FloatRect Text::GetLocalBounds() const { - return myBounds; + return m_bounds; } @@ -212,48 +212,48 @@ FloatRect Text::GetGlobalBounds() const //////////////////////////////////////////////////////////// void Text::Draw(RenderTarget& target, RenderStates states) const { - assert(myFont != NULL); + assert(m_font != NULL); states.Transform *= GetTransform(); states.BlendMode = BlendAlpha; // alpha blending is mandatory for proper text rendering - states.Texture = &myFont->GetTexture(myCharacterSize); - target.Draw(myVertices, states); + states.Texture = &m_font->GetTexture(m_characterSize); + target.Draw(m_vertices, states); } //////////////////////////////////////////////////////////// void Text::UpdateGeometry() { - assert(myFont != NULL); + assert(m_font != NULL); // Clear the previous geometry - myVertices.Clear(); + m_vertices.Clear(); // No text: nothing to draw - if (myString.IsEmpty()) + if (m_string.IsEmpty()) return; // Compute values related to the text style - bool bold = (myStyle & Bold) != 0; - bool underlined = (myStyle & Underlined) != 0; - float italic = (myStyle & Italic) ? 0.208f : 0.f; // 12 degrees - float underlineOffset = myCharacterSize * 0.1f; - float underlineThickness = myCharacterSize * (bold ? 0.1f : 0.07f); + bool bold = (m_style & Bold) != 0; + bool underlined = (m_style & Underlined) != 0; + float italic = (m_style & Italic) ? 0.208f : 0.f; // 12 degrees + float underlineOffset = m_characterSize * 0.1f; + float underlineThickness = m_characterSize * (bold ? 0.1f : 0.07f); // Precompute the variables needed by the algorithm - float hspace = static_cast(myFont->GetGlyph(L' ', myCharacterSize, bold).Advance); - float vspace = static_cast(myFont->GetLineSpacing(myCharacterSize)); + float hspace = static_cast(m_font->GetGlyph(L' ', m_characterSize, bold).Advance); + float vspace = static_cast(m_font->GetLineSpacing(m_characterSize)); float x = 0.f; - float y = static_cast(myCharacterSize); + float y = static_cast(m_characterSize); // Create one quad for each character Uint32 prevChar = 0; - for (std::size_t i = 0; i < myString.GetSize(); ++i) + for (std::size_t i = 0; i < m_string.GetSize(); ++i) { - Uint32 curChar = myString[i]; + Uint32 curChar = m_string[i]; // Apply the kerning offset - x += static_cast(myFont->GetKerning(prevChar, curChar, myCharacterSize)); + x += static_cast(m_font->GetKerning(prevChar, curChar, m_characterSize)); prevChar = curChar; // If we're using the underlined style and there's a new line, draw a line @@ -262,10 +262,10 @@ void Text::UpdateGeometry() float top = y + underlineOffset; float bottom = top + underlineThickness; - myVertices.Append(Vertex(Vector2f(0, top), myColor, Vector2f(1, 1))); - myVertices.Append(Vertex(Vector2f(x, top), myColor, Vector2f(1, 1))); - myVertices.Append(Vertex(Vector2f(x, bottom), myColor, Vector2f(1, 1))); - myVertices.Append(Vertex(Vector2f(0, bottom), myColor, Vector2f(1, 1))); + m_vertices.Append(Vertex(Vector2f(0, top), m_color, Vector2f(1, 1))); + m_vertices.Append(Vertex(Vector2f(x, top), m_color, Vector2f(1, 1))); + m_vertices.Append(Vertex(Vector2f(x, bottom), m_color, Vector2f(1, 1))); + m_vertices.Append(Vertex(Vector2f(0, bottom), m_color, Vector2f(1, 1))); } // Handle special characters @@ -278,7 +278,7 @@ void Text::UpdateGeometry() } // Extract the current glyph's description - const Glyph& glyph = myFont->GetGlyph(curChar, myCharacterSize, bold); + const Glyph& glyph = m_font->GetGlyph(curChar, m_characterSize, bold); int left = glyph.Bounds.Left; int top = glyph.Bounds.Top; @@ -291,10 +291,10 @@ void Text::UpdateGeometry() float v2 = static_cast(glyph.TextureRect.Top + glyph.TextureRect.Height); // Add a quad for the current character - myVertices.Append(Vertex(Vector2f(x + left - italic * top, y + top), myColor, Vector2f(u1, v1))); - myVertices.Append(Vertex(Vector2f(x + right - italic * top, y + top), myColor, Vector2f(u2, v1))); - myVertices.Append(Vertex(Vector2f(x + right - italic * bottom, y + bottom), myColor, Vector2f(u2, v2))); - myVertices.Append(Vertex(Vector2f(x + left - italic * bottom, y + bottom), myColor, Vector2f(u1, v2))); + m_vertices.Append(Vertex(Vector2f(x + left - italic * top, y + top), m_color, Vector2f(u1, v1))); + m_vertices.Append(Vertex(Vector2f(x + right - italic * top, y + top), m_color, Vector2f(u2, v1))); + m_vertices.Append(Vertex(Vector2f(x + right - italic * bottom, y + bottom), m_color, Vector2f(u2, v2))); + m_vertices.Append(Vertex(Vector2f(x + left - italic * bottom, y + bottom), m_color, Vector2f(u1, v2))); // Advance to the next character x += glyph.Advance; @@ -306,14 +306,14 @@ void Text::UpdateGeometry() float top = y + underlineOffset; float bottom = top + underlineThickness; - myVertices.Append(Vertex(Vector2f(0, top), myColor, Vector2f(1, 1))); - myVertices.Append(Vertex(Vector2f(x, top), myColor, Vector2f(1, 1))); - myVertices.Append(Vertex(Vector2f(x, bottom), myColor, Vector2f(1, 1))); - myVertices.Append(Vertex(Vector2f(0, bottom), myColor, Vector2f(1, 1))); + m_vertices.Append(Vertex(Vector2f(0, top), m_color, Vector2f(1, 1))); + m_vertices.Append(Vertex(Vector2f(x, top), m_color, Vector2f(1, 1))); + m_vertices.Append(Vertex(Vector2f(x, bottom), m_color, Vector2f(1, 1))); + m_vertices.Append(Vertex(Vector2f(0, bottom), m_color, Vector2f(1, 1))); } // Recompute the bounding rectangle - myBounds = myVertices.GetBounds(); + m_bounds = m_vertices.GetBounds(); } } // namespace sf diff --git a/src/SFML/Graphics/Texture.cpp b/src/SFML/Graphics/Texture.cpp index 9052caf1..d6c1a043 100644 --- a/src/SFML/Graphics/Texture.cpp +++ b/src/SFML/Graphics/Texture.cpp @@ -56,15 +56,15 @@ namespace sf { //////////////////////////////////////////////////////////// Texture::Texture() : -myWidth (0), -myHeight (0), -myTextureWidth (0), -myTextureHeight(0), -myTexture (0), -myIsSmooth (false), -myIsRepeated (false), -myPixelsFlipped(false), -myCacheId (GetUniqueId()) +m_width (0), +m_height (0), +m_textureWidth (0), +m_textureHeight(0), +m_texture (0), +m_isSmooth (false), +m_isRepeated (false), +m_pixelsFlipped(false), +m_cacheId (GetUniqueId()) { } @@ -72,17 +72,17 @@ myCacheId (GetUniqueId()) //////////////////////////////////////////////////////////// Texture::Texture(const Texture& copy) : -myWidth (0), -myHeight (0), -myTextureWidth (0), -myTextureHeight(0), -myTexture (0), -myIsSmooth (copy.myIsSmooth), -myIsRepeated (copy.myIsRepeated), -myPixelsFlipped(false), -myCacheId (GetUniqueId()) +m_width (0), +m_height (0), +m_textureWidth (0), +m_textureHeight(0), +m_texture (0), +m_isSmooth (copy.m_isSmooth), +m_isRepeated (copy.m_isRepeated), +m_pixelsFlipped(false), +m_cacheId (GetUniqueId()) { - if (copy.myTexture) + if (copy.m_texture) LoadFromImage(copy.CopyToImage()); } @@ -91,11 +91,11 @@ myCacheId (GetUniqueId()) Texture::~Texture() { // Destroy the OpenGL texture - if (myTexture) + if (m_texture) { EnsureGlContext(); - GLuint Texture = static_cast(myTexture); + GLuint Texture = static_cast(m_texture); GLCheck(glDeleteTextures(1, &Texture)); } } @@ -127,33 +127,33 @@ bool Texture::Create(unsigned int width, unsigned int height) } // All the validity checks passed, we can store the new texture settings - myWidth = width; - myHeight = height; - myTextureWidth = textureWidth; - myTextureHeight = textureHeight; - myPixelsFlipped = false; + m_width = width; + m_height = height; + m_textureWidth = textureWidth; + m_textureHeight = textureHeight; + m_pixelsFlipped = false; EnsureGlContext(); // Create the OpenGL texture if it doesn't exist yet - if (!myTexture) + if (!m_texture) { GLuint texture; GLCheck(glGenTextures(1, &texture)); - myTexture = static_cast(texture); + m_texture = static_cast(texture); } // Make sure that the current texture binding will be preserved priv::TextureSaver save; // Initialize the texture - GLCheck(glBindTexture(GL_TEXTURE_2D, myTexture)); - GLCheck(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, myTextureWidth, myTextureHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL)); - GLCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, myIsRepeated ? GL_REPEAT : GL_CLAMP_TO_EDGE)); - GLCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, myIsRepeated ? GL_REPEAT : GL_CLAMP_TO_EDGE)); - GLCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, myIsSmooth ? GL_LINEAR : GL_NEAREST)); - GLCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, myIsSmooth ? GL_LINEAR : GL_NEAREST)); - myCacheId = GetUniqueId(); + GLCheck(glBindTexture(GL_TEXTURE_2D, m_texture)); + GLCheck(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, m_textureWidth, m_textureHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL)); + GLCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, m_isRepeated ? GL_REPEAT : GL_CLAMP_TO_EDGE)); + GLCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, m_isRepeated ? GL_REPEAT : GL_CLAMP_TO_EDGE)); + GLCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, m_isSmooth ? GL_LINEAR : GL_NEAREST)); + GLCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_isSmooth ? GL_LINEAR : GL_NEAREST)); + m_cacheId = GetUniqueId(); return true; } @@ -224,10 +224,10 @@ bool Texture::LoadFromImage(const Image& image, const IntRect& area) // Copy the pixels to the texture, row by row const Uint8* pixels = image.GetPixelsPtr() + 4 * (rectangle.Left + (width * rectangle.Top)); - GLCheck(glBindTexture(GL_TEXTURE_2D, myTexture)); + GLCheck(glBindTexture(GL_TEXTURE_2D, m_texture)); for (int i = 0; i < rectangle.Height; ++i) { - GLCheck(glTexSubImage2D(GL_TEXTURE_2D, 0, 0, i, myWidth, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixels)); + GLCheck(glTexSubImage2D(GL_TEXTURE_2D, 0, 0, i, m_width, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixels)); pixels += 4 * width; } @@ -244,14 +244,14 @@ bool Texture::LoadFromImage(const Image& image, const IntRect& area) //////////////////////////////////////////////////////////// unsigned int Texture::GetWidth() const { - return myWidth; + return m_width; } //////////////////////////////////////////////////////////// unsigned int Texture::GetHeight() const { - return myHeight; + return m_height; } @@ -259,7 +259,7 @@ unsigned int Texture::GetHeight() const Image Texture::CopyToImage() const { // Easy case: empty texture - if (!myTexture) + if (!m_texture) return Image(); EnsureGlContext(); @@ -268,12 +268,12 @@ Image Texture::CopyToImage() const priv::TextureSaver save; // Create an array of pixels - std::vector pixels(myWidth * myHeight * 4); + std::vector pixels(m_width * m_height * 4); - if ((myWidth == myTextureWidth) && (myHeight == myTextureHeight) && !myPixelsFlipped) + if ((m_width == m_textureWidth) && (m_height == m_textureHeight) && !m_pixelsFlipped) { // Texture is not padded nor flipped, we can use a direct copy - GLCheck(glBindTexture(GL_TEXTURE_2D, myTexture)); + GLCheck(glBindTexture(GL_TEXTURE_2D, m_texture)); GLCheck(glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, &pixels[0])); } else @@ -281,24 +281,24 @@ Image Texture::CopyToImage() const // Texture is either padded or flipped, we have to use a slower algorithm // All the pixels will first be copied to a temporary array - std::vector allPixels(myTextureWidth * myTextureHeight * 4); - GLCheck(glBindTexture(GL_TEXTURE_2D, myTexture)); + std::vector allPixels(m_textureWidth * m_textureHeight * 4); + GLCheck(glBindTexture(GL_TEXTURE_2D, m_texture)); GLCheck(glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, &allPixels[0])); // Then we copy the useful pixels from the temporary array to the final one const Uint8* src = &allPixels[0]; Uint8* dst = &pixels[0]; - int srcPitch = myTextureWidth * 4; - int dstPitch = myWidth * 4; + int srcPitch = m_textureWidth * 4; + int dstPitch = m_width * 4; // Handle the case where source pixels are flipped vertically - if (myPixelsFlipped) + if (m_pixelsFlipped) { - src += srcPitch * (myHeight - 1); + src += srcPitch * (m_height - 1); srcPitch = -srcPitch; } - for (unsigned int i = 0; i < myHeight; ++i) + for (unsigned int i = 0; i < m_height; ++i) { std::memcpy(dst, src, dstPitch); src += srcPitch; @@ -308,7 +308,7 @@ Image Texture::CopyToImage() const // Create the image Image image; - image.Create(myWidth, myHeight, &pixels[0]); + image.Create(m_width, m_height, &pixels[0]); return image; } @@ -318,17 +318,17 @@ Image Texture::CopyToImage() const void Texture::Update(const Uint8* pixels) { // Update the whole texture - Update(pixels, myWidth, myHeight, 0, 0); + Update(pixels, m_width, m_height, 0, 0); } //////////////////////////////////////////////////////////// void Texture::Update(const Uint8* pixels, unsigned int width, unsigned int height, unsigned int x, unsigned int y) { - assert(x + width <= myWidth); - assert(y + height <= myHeight); + assert(x + width <= m_width); + assert(y + height <= m_height); - if (pixels && myTexture) + if (pixels && m_texture) { EnsureGlContext(); @@ -336,10 +336,10 @@ void Texture::Update(const Uint8* pixels, unsigned int width, unsigned int heigh priv::TextureSaver save; // Copy pixels from the given array to the texture - GLCheck(glBindTexture(GL_TEXTURE_2D, myTexture)); + GLCheck(glBindTexture(GL_TEXTURE_2D, m_texture)); GLCheck(glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels)); - myPixelsFlipped = false; - myCacheId = GetUniqueId(); + m_pixelsFlipped = false; + m_cacheId = GetUniqueId(); } } @@ -369,19 +369,19 @@ void Texture::Update(const Window& window) //////////////////////////////////////////////////////////// void Texture::Update(const Window& window, unsigned int x, unsigned int y) { - assert(x + window.GetSize().x <= myWidth); - assert(y + window.GetSize().y <= myHeight); + assert(x + window.GetSize().x <= m_width); + assert(y + window.GetSize().y <= m_height); - if (myTexture && window.SetActive(true)) + if (m_texture && window.SetActive(true)) { // Make sure that the current texture binding will be preserved priv::TextureSaver save; // Copy pixels from the back-buffer to the texture - GLCheck(glBindTexture(GL_TEXTURE_2D, myTexture)); + GLCheck(glBindTexture(GL_TEXTURE_2D, m_texture)); GLCheck(glCopyTexSubImage2D(GL_TEXTURE_2D, 0, x, y, 0, 0, window.GetSize().x, window.GetSize().y)); - myPixelsFlipped = true; - myCacheId = GetUniqueId(); + m_pixelsFlipped = true; + m_cacheId = GetUniqueId(); } } @@ -390,10 +390,10 @@ void Texture::Update(const Window& window, unsigned int x, unsigned int y) void Texture::Bind(CoordinateType coordinateType) const { // Bind the texture - GLCheck(glBindTexture(GL_TEXTURE_2D, myTexture)); + GLCheck(glBindTexture(GL_TEXTURE_2D, m_texture)); // Check if we need to define a special texture matrix - if ((coordinateType == Pixels) || myPixelsFlipped) + if ((coordinateType == Pixels) || m_pixelsFlipped) { GLfloat matrix[16] = {1.f, 0.f, 0.f, 0.f, 0.f, 1.f, 0.f, 0.f, @@ -404,15 +404,15 @@ void Texture::Bind(CoordinateType coordinateType) const // setup scale factors that convert the range [0 .. size] to [0 .. 1] if (coordinateType == Pixels) { - matrix[0] = 1.f / myTextureWidth; - matrix[5] = 1.f / myTextureHeight; + matrix[0] = 1.f / m_textureWidth; + matrix[5] = 1.f / m_textureHeight; } // If pixels are flipped we must invert the Y axis - if (myPixelsFlipped) + if (m_pixelsFlipped) { matrix[5] = -matrix[5]; - matrix[13] = static_cast(myHeight / myTextureHeight); + matrix[13] = static_cast(m_height / m_textureHeight); } // Load the matrix @@ -428,20 +428,20 @@ void Texture::Bind(CoordinateType coordinateType) const //////////////////////////////////////////////////////////// void Texture::SetSmooth(bool smooth) { - if (smooth != myIsSmooth) + if (smooth != m_isSmooth) { - myIsSmooth = smooth; + m_isSmooth = smooth; - if (myTexture) + if (m_texture) { EnsureGlContext(); // Make sure that the current texture binding will be preserved priv::TextureSaver save; - GLCheck(glBindTexture(GL_TEXTURE_2D, myTexture)); - GLCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, myIsSmooth ? GL_LINEAR : GL_NEAREST)); - GLCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, myIsSmooth ? GL_LINEAR : GL_NEAREST)); + GLCheck(glBindTexture(GL_TEXTURE_2D, m_texture)); + GLCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, m_isSmooth ? GL_LINEAR : GL_NEAREST)); + GLCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_isSmooth ? GL_LINEAR : GL_NEAREST)); } } } @@ -450,27 +450,27 @@ void Texture::SetSmooth(bool smooth) //////////////////////////////////////////////////////////// bool Texture::IsSmooth() const { - return myIsSmooth; + return m_isSmooth; } //////////////////////////////////////////////////////////// void Texture::SetRepeated(bool repeated) { - if (repeated != myIsRepeated) + if (repeated != m_isRepeated) { - myIsRepeated = repeated; + m_isRepeated = repeated; - if (myTexture) + if (m_texture) { EnsureGlContext(); // Make sure that the current texture binding will be preserved priv::TextureSaver save; - GLCheck(glBindTexture(GL_TEXTURE_2D, myTexture)); - GLCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, myIsRepeated ? GL_REPEAT : GL_CLAMP_TO_EDGE)); - GLCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, myIsRepeated ? GL_REPEAT : GL_CLAMP_TO_EDGE)); + GLCheck(glBindTexture(GL_TEXTURE_2D, m_texture)); + GLCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, m_isRepeated ? GL_REPEAT : GL_CLAMP_TO_EDGE)); + GLCheck(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, m_isRepeated ? GL_REPEAT : GL_CLAMP_TO_EDGE)); } } } @@ -479,7 +479,7 @@ void Texture::SetRepeated(bool repeated) //////////////////////////////////////////////////////////// bool Texture::IsRepeated() const { - return myIsRepeated; + return m_isRepeated; } @@ -500,15 +500,15 @@ Texture& Texture::operator =(const Texture& right) { Texture temp(right); - std::swap(myWidth, temp.myWidth); - std::swap(myHeight, temp.myHeight); - std::swap(myTextureWidth, temp.myTextureWidth); - std::swap(myTextureHeight, temp.myTextureHeight); - std::swap(myTexture, temp.myTexture); - std::swap(myIsSmooth, temp.myIsSmooth); - std::swap(myIsRepeated, temp.myIsRepeated); - std::swap(myPixelsFlipped, temp.myPixelsFlipped); - myCacheId = GetUniqueId(); + std::swap(m_width, temp.m_width); + std::swap(m_height, temp.m_height); + std::swap(m_textureWidth, temp.m_textureWidth); + std::swap(m_textureHeight, temp.m_textureHeight); + std::swap(m_texture, temp.m_texture); + std::swap(m_isSmooth, temp.m_isSmooth); + std::swap(m_isRepeated, temp.m_isRepeated); + std::swap(m_pixelsFlipped, temp.m_pixelsFlipped); + m_cacheId = GetUniqueId(); return *this; } diff --git a/src/SFML/Graphics/TextureSaver.cpp b/src/SFML/Graphics/TextureSaver.cpp index e4bbecd3..868cf559 100644 --- a/src/SFML/Graphics/TextureSaver.cpp +++ b/src/SFML/Graphics/TextureSaver.cpp @@ -35,14 +35,14 @@ namespace priv //////////////////////////////////////////////////////////// TextureSaver::TextureSaver() { - GLCheck(glGetIntegerv(GL_TEXTURE_BINDING_2D, &myTextureBinding)); + GLCheck(glGetIntegerv(GL_TEXTURE_BINDING_2D, &m_textureBinding)); } //////////////////////////////////////////////////////////// TextureSaver::~TextureSaver() { - GLCheck(glBindTexture(GL_TEXTURE_2D, myTextureBinding)); + GLCheck(glBindTexture(GL_TEXTURE_2D, m_textureBinding)); } } // namespace priv diff --git a/src/SFML/Graphics/TextureSaver.hpp b/src/SFML/Graphics/TextureSaver.hpp index 845cffb7..9cab0ec9 100644 --- a/src/SFML/Graphics/TextureSaver.hpp +++ b/src/SFML/Graphics/TextureSaver.hpp @@ -64,7 +64,7 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - GLint myTextureBinding; ///< Texture binding to restore + GLint m_textureBinding; ///< Texture binding to restore }; } // namespace priv diff --git a/src/SFML/Graphics/Transform.cpp b/src/SFML/Graphics/Transform.cpp index eb027ea8..03cc358e 100644 --- a/src/SFML/Graphics/Transform.cpp +++ b/src/SFML/Graphics/Transform.cpp @@ -39,10 +39,10 @@ const Transform Transform::Identity; Transform::Transform() { // Identity matrix - myMatrix[0] = 1.f; myMatrix[4] = 0.f; myMatrix[8] = 0.f; myMatrix[12] = 0.f; - myMatrix[1] = 0.f; myMatrix[5] = 1.f; myMatrix[9] = 0.f; myMatrix[13] = 0.f; - myMatrix[2] = 0.f; myMatrix[6] = 0.f; myMatrix[10] = 1.f; myMatrix[14] = 0.f; - myMatrix[3] = 0.f; myMatrix[7] = 0.f; myMatrix[11] = 0.f; myMatrix[15] = 1.f; + m_matrix[0] = 1.f; m_matrix[4] = 0.f; m_matrix[8] = 0.f; m_matrix[12] = 0.f; + m_matrix[1] = 0.f; m_matrix[5] = 1.f; m_matrix[9] = 0.f; m_matrix[13] = 0.f; + m_matrix[2] = 0.f; m_matrix[6] = 0.f; m_matrix[10] = 1.f; m_matrix[14] = 0.f; + m_matrix[3] = 0.f; m_matrix[7] = 0.f; m_matrix[11] = 0.f; m_matrix[15] = 1.f; } @@ -51,17 +51,17 @@ Transform::Transform(float a00, float a01, float a02, float a10, float a11, float a12, float a20, float a21, float a22) { - myMatrix[0] = a00; myMatrix[4] = a01; myMatrix[8] = 0.f; myMatrix[12] = a02; - myMatrix[1] = a10; myMatrix[5] = a11; myMatrix[9] = 0.f; myMatrix[13] = a12; - myMatrix[2] = 0.f; myMatrix[6] = 0.f; myMatrix[10] = 1.f; myMatrix[14] = 0.f; - myMatrix[3] = a20; myMatrix[7] = a21; myMatrix[11] = 0.f; myMatrix[15] = a22; + m_matrix[0] = a00; m_matrix[4] = a01; m_matrix[8] = 0.f; m_matrix[12] = a02; + m_matrix[1] = a10; m_matrix[5] = a11; m_matrix[9] = 0.f; m_matrix[13] = a12; + m_matrix[2] = 0.f; m_matrix[6] = 0.f; m_matrix[10] = 1.f; m_matrix[14] = 0.f; + m_matrix[3] = a20; m_matrix[7] = a21; m_matrix[11] = 0.f; m_matrix[15] = a22; } //////////////////////////////////////////////////////////// const float* Transform::GetMatrix() const { - return myMatrix; + return m_matrix; } @@ -69,23 +69,23 @@ const float* Transform::GetMatrix() const Transform Transform::GetInverse() const { // Compute the determinant - float det = myMatrix[0] * (myMatrix[15] * myMatrix[5] - myMatrix[7] * myMatrix[13]) - - myMatrix[1] * (myMatrix[15] * myMatrix[4] - myMatrix[7] * myMatrix[12]) + - myMatrix[3] * (myMatrix[13] * myMatrix[4] - myMatrix[5] * myMatrix[12]); + float det = m_matrix[0] * (m_matrix[15] * m_matrix[5] - m_matrix[7] * m_matrix[13]) - + m_matrix[1] * (m_matrix[15] * m_matrix[4] - m_matrix[7] * m_matrix[12]) + + m_matrix[3] * (m_matrix[13] * m_matrix[4] - m_matrix[5] * m_matrix[12]); // Compute the inverse if the determinant is not zero // (don't use an epsilon because the determinant may *really* be tiny) if (det != 0.f) { - return Transform( (myMatrix[15] * myMatrix[5] - myMatrix[7] * myMatrix[13]) / det, - -(myMatrix[15] * myMatrix[4] - myMatrix[7] * myMatrix[12]) / det, - (myMatrix[13] * myMatrix[4] - myMatrix[5] * myMatrix[12]) / det, - -(myMatrix[15] * myMatrix[1] - myMatrix[3] * myMatrix[13]) / det, - (myMatrix[15] * myMatrix[0] - myMatrix[3] * myMatrix[12]) / det, - -(myMatrix[13] * myMatrix[0] - myMatrix[1] * myMatrix[12]) / det, - (myMatrix[7] * myMatrix[1] - myMatrix[3] * myMatrix[5]) / det, - -(myMatrix[7] * myMatrix[0] - myMatrix[3] * myMatrix[4]) / det, - (myMatrix[5] * myMatrix[0] - myMatrix[1] * myMatrix[4]) / det); + return Transform( (m_matrix[15] * m_matrix[5] - m_matrix[7] * m_matrix[13]) / det, + -(m_matrix[15] * m_matrix[4] - m_matrix[7] * m_matrix[12]) / det, + (m_matrix[13] * m_matrix[4] - m_matrix[5] * m_matrix[12]) / det, + -(m_matrix[15] * m_matrix[1] - m_matrix[3] * m_matrix[13]) / det, + (m_matrix[15] * m_matrix[0] - m_matrix[3] * m_matrix[12]) / det, + -(m_matrix[13] * m_matrix[0] - m_matrix[1] * m_matrix[12]) / det, + (m_matrix[7] * m_matrix[1] - m_matrix[3] * m_matrix[5]) / det, + -(m_matrix[7] * m_matrix[0] - m_matrix[3] * m_matrix[4]) / det, + (m_matrix[5] * m_matrix[0] - m_matrix[1] * m_matrix[4]) / det); } else { @@ -97,8 +97,8 @@ Transform Transform::GetInverse() const //////////////////////////////////////////////////////////// Vector2f Transform::TransformPoint(float x, float y) const { - return Vector2f(myMatrix[0] * x + myMatrix[4] * y + myMatrix[12], - myMatrix[1] * x + myMatrix[5] * y + myMatrix[13]); + return Vector2f(m_matrix[0] * x + m_matrix[4] * y + m_matrix[12], + m_matrix[1] * x + m_matrix[5] * y + m_matrix[13]); } @@ -141,8 +141,8 @@ FloatRect Transform::TransformRect(const FloatRect& rectangle) const //////////////////////////////////////////////////////////// Transform& Transform::Combine(const Transform& transform) { - const float* a = myMatrix; - const float* b = transform.myMatrix; + const float* a = m_matrix; + const float* b = transform.m_matrix; *this = Transform(a[0] * b[0] + a[4] * b[1] + a[12] * b[3], a[0] * b[4] + a[4] * b[5] + a[12] * b[7], diff --git a/src/SFML/Graphics/Transformable.cpp b/src/SFML/Graphics/Transformable.cpp index 004a22b5..c266965e 100644 --- a/src/SFML/Graphics/Transformable.cpp +++ b/src/SFML/Graphics/Transformable.cpp @@ -33,14 +33,14 @@ namespace sf { //////////////////////////////////////////////////////////// Transformable::Transformable() : -myOrigin (0, 0), -myPosition (0, 0), -myRotation (0), -myScale (1, 1), -myTransform (), -myTransformNeedUpdate (true), -myInverseTransform (), -myInverseTransformNeedUpdate(true) +m_origin (0, 0), +m_position (0, 0), +m_rotation (0), +m_scale (1, 1), +m_transform (), +m_transformNeedUpdate (true), +m_inverseTransform (), +m_inverseTransformNeedUpdate(true) { } @@ -54,10 +54,10 @@ Transformable::~Transformable() //////////////////////////////////////////////////////////// void Transformable::SetPosition(float x, float y) { - myPosition.x = x; - myPosition.y = y; - myTransformNeedUpdate = true; - myInverseTransformNeedUpdate = true; + m_position.x = x; + m_position.y = y; + m_transformNeedUpdate = true; + m_inverseTransformNeedUpdate = true; } @@ -71,19 +71,19 @@ void Transformable::SetPosition(const Vector2f& position) //////////////////////////////////////////////////////////// void Transformable::SetRotation(float angle) { - myRotation = angle; - myTransformNeedUpdate = true; - myInverseTransformNeedUpdate = true; + m_rotation = angle; + m_transformNeedUpdate = true; + m_inverseTransformNeedUpdate = true; } //////////////////////////////////////////////////////////// void Transformable::SetScale(float factorX, float factorY) { - myScale.x = factorX; - myScale.y = factorY; - myTransformNeedUpdate = true; - myInverseTransformNeedUpdate = true; + m_scale.x = factorX; + m_scale.y = factorY; + m_transformNeedUpdate = true; + m_inverseTransformNeedUpdate = true; } @@ -97,10 +97,10 @@ void Transformable::SetScale(const Vector2f& factors) //////////////////////////////////////////////////////////// void Transformable::SetOrigin(float x, float y) { - myOrigin.x = x; - myOrigin.y = y; - myTransformNeedUpdate = true; - myInverseTransformNeedUpdate = true; + m_origin.x = x; + m_origin.y = y; + m_transformNeedUpdate = true; + m_inverseTransformNeedUpdate = true; } @@ -114,63 +114,63 @@ void Transformable::SetOrigin(const Vector2f& origin) //////////////////////////////////////////////////////////// const Vector2f& Transformable::GetPosition() const { - return myPosition; + return m_position; } //////////////////////////////////////////////////////////// float Transformable::GetRotation() const { - return myRotation; + return m_rotation; } //////////////////////////////////////////////////////////// const Vector2f& Transformable::GetScale() const { - return myScale; + return m_scale; } //////////////////////////////////////////////////////////// const Vector2f& Transformable::GetOrigin() const { - return myOrigin; + return m_origin; } //////////////////////////////////////////////////////////// void Transformable::Move(float offsetX, float offsetY) { - SetPosition(myPosition.x + offsetX, myPosition.y + offsetY); + SetPosition(m_position.x + offsetX, m_position.y + offsetY); } //////////////////////////////////////////////////////////// void Transformable::Move(const Vector2f& offset) { - SetPosition(myPosition.x + offset.x, myPosition.y + offset.y); + SetPosition(m_position.x + offset.x, m_position.y + offset.y); } //////////////////////////////////////////////////////////// void Transformable::Rotate(float angle) { - SetRotation(myRotation + angle); + SetRotation(m_rotation + angle); } //////////////////////////////////////////////////////////// void Transformable::Scale(float factorX, float factorY) { - SetScale(myScale.x * factorX, myScale.y * factorY); + SetScale(m_scale.x * factorX, m_scale.y * factorY); } //////////////////////////////////////////////////////////// void Transformable::Scale(const Vector2f& factor) { - SetScale(myScale.x * factor.x, myScale.y * factor.y); + SetScale(m_scale.x * factor.x, m_scale.y * factor.y); } @@ -178,25 +178,25 @@ void Transformable::Scale(const Vector2f& factor) const Transform& Transformable::GetTransform() const { // Recompute the combined transform if needed - if (myTransformNeedUpdate) + if (m_transformNeedUpdate) { - float angle = -myRotation * 3.141592654f / 180.f; + float angle = -m_rotation * 3.141592654f / 180.f; float cosine = static_cast(std::cos(angle)); float sine = static_cast(std::sin(angle)); - float sxc = myScale.x * cosine; - float syc = myScale.y * cosine; - float sxs = myScale.x * sine; - float sys = myScale.y * sine; - float tx = -myOrigin.x * sxc - myOrigin.y * sys + myPosition.x; - float ty = myOrigin.x * sxs - myOrigin.y * syc + myPosition.y; + float sxc = m_scale.x * cosine; + float syc = m_scale.y * cosine; + float sxs = m_scale.x * sine; + float sys = m_scale.y * sine; + float tx = -m_origin.x * sxc - m_origin.y * sys + m_position.x; + float ty = m_origin.x * sxs - m_origin.y * syc + m_position.y; - myTransform = Transform( sxc, sys, tx, + m_transform = Transform( sxc, sys, tx, -sxs, syc, ty, 0.f, 0.f, 1.f); - myTransformNeedUpdate = false; + m_transformNeedUpdate = false; } - return myTransform; + return m_transform; } @@ -204,13 +204,13 @@ const Transform& Transformable::GetTransform() const const Transform& Transformable::GetInverseTransform() const { // Recompute the inverse transform if needed - if (myInverseTransformNeedUpdate) + if (m_inverseTransformNeedUpdate) { - myInverseTransform = GetTransform().GetInverse(); - myInverseTransformNeedUpdate = false; + m_inverseTransform = GetTransform().GetInverse(); + m_inverseTransformNeedUpdate = false; } - return myInverseTransform; + return m_inverseTransform; } } // namespace sf diff --git a/src/SFML/Graphics/VertexArray.cpp b/src/SFML/Graphics/VertexArray.cpp index 60a3a88e..f47576d2 100644 --- a/src/SFML/Graphics/VertexArray.cpp +++ b/src/SFML/Graphics/VertexArray.cpp @@ -33,16 +33,16 @@ namespace sf { //////////////////////////////////////////////////////////// VertexArray::VertexArray() : -myVertices (), -myPrimitiveType(Points) +m_vertices (), +m_primitiveType(Points) { } //////////////////////////////////////////////////////////// VertexArray::VertexArray(PrimitiveType type, unsigned int vertexCount) : -myVertices (vertexCount), -myPrimitiveType(type) +m_vertices (vertexCount), +m_primitiveType(type) { } @@ -50,72 +50,72 @@ myPrimitiveType(type) //////////////////////////////////////////////////////////// unsigned int VertexArray::GetVertexCount() const { - return static_cast(myVertices.size()); + return static_cast(m_vertices.size()); } //////////////////////////////////////////////////////////// Vertex& VertexArray::operator [](unsigned int index) { - return myVertices[index]; + return m_vertices[index]; } //////////////////////////////////////////////////////////// const Vertex& VertexArray::operator [](unsigned int index) const { - return myVertices[index]; + return m_vertices[index]; } //////////////////////////////////////////////////////////// void VertexArray::Clear() { - myVertices.clear(); + m_vertices.clear(); } //////////////////////////////////////////////////////////// void VertexArray::Resize(unsigned int vertexCount) { - myVertices.resize(vertexCount); + m_vertices.resize(vertexCount); } //////////////////////////////////////////////////////////// void VertexArray::Append(const Vertex& vertex) { - myVertices.push_back(vertex); + m_vertices.push_back(vertex); } //////////////////////////////////////////////////////////// void VertexArray::SetPrimitiveType(PrimitiveType type) { - myPrimitiveType = type; + m_primitiveType = type; } //////////////////////////////////////////////////////////// PrimitiveType VertexArray::GetPrimitiveType() const { - return myPrimitiveType; + return m_primitiveType; } //////////////////////////////////////////////////////////// FloatRect VertexArray::GetBounds() const { - if (!myVertices.empty()) + if (!m_vertices.empty()) { - float left = myVertices[0].Position.x; - float top = myVertices[0].Position.y; - float right = myVertices[0].Position.x; - float bottom = myVertices[0].Position.y; + float left = m_vertices[0].Position.x; + float top = m_vertices[0].Position.y; + float right = m_vertices[0].Position.x; + float bottom = m_vertices[0].Position.y; - for (std::size_t i = 0; i < myVertices.size(); ++i) + for (std::size_t i = 0; i < m_vertices.size(); ++i) { - Vector2f position = myVertices[i].Position; + Vector2f position = m_vertices[i].Position; // Update left and right if (position.x < left) @@ -143,8 +143,8 @@ FloatRect VertexArray::GetBounds() const //////////////////////////////////////////////////////////// void VertexArray::Draw(RenderTarget& target, RenderStates states) const { - if (!myVertices.empty()) - target.Draw(&myVertices[0], static_cast(myVertices.size()), myPrimitiveType, states); + if (!m_vertices.empty()) + target.Draw(&m_vertices[0], static_cast(m_vertices.size()), m_primitiveType, states); } } // namespace sf diff --git a/src/SFML/Graphics/View.cpp b/src/SFML/Graphics/View.cpp index ec95ddba..d42ee852 100644 --- a/src/SFML/Graphics/View.cpp +++ b/src/SFML/Graphics/View.cpp @@ -33,12 +33,12 @@ namespace sf { //////////////////////////////////////////////////////////// View::View() : -myCenter (), -mySize (), -myRotation (0), -myViewport (0, 0, 1, 1), -myTransformUpdated (false), -myInvTransformUpdated(false) +m_center (), +m_size (), +m_rotation (0), +m_viewport (0, 0, 1, 1), +m_transformUpdated (false), +m_invTransformUpdated(false) { Reset(FloatRect(0, 0, 1000, 1000)); } @@ -46,12 +46,12 @@ myInvTransformUpdated(false) //////////////////////////////////////////////////////////// View::View(const FloatRect& rectangle) : -myCenter (), -mySize (), -myRotation (0), -myViewport (0, 0, 1, 1), -myTransformUpdated (false), -myInvTransformUpdated(false) +m_center (), +m_size (), +m_rotation (0), +m_viewport (0, 0, 1, 1), +m_transformUpdated (false), +m_invTransformUpdated(false) { Reset(rectangle); } @@ -59,12 +59,12 @@ myInvTransformUpdated(false) //////////////////////////////////////////////////////////// View::View(const Vector2f& center, const Vector2f& size) : -myCenter (center), -mySize (size), -myRotation (0), -myViewport (0, 0, 1, 1), -myTransformUpdated (false), -myInvTransformUpdated(false) +m_center (center), +m_size (size), +m_rotation (0), +m_viewport (0, 0, 1, 1), +m_transformUpdated (false), +m_invTransformUpdated(false) { } @@ -72,11 +72,11 @@ myInvTransformUpdated(false) //////////////////////////////////////////////////////////// void View::SetCenter(float x, float y) { - myCenter.x = x; - myCenter.y = y; + m_center.x = x; + m_center.y = y; - myTransformUpdated = false; - myInvTransformUpdated = false; + m_transformUpdated = false; + m_invTransformUpdated = false; } @@ -90,11 +90,11 @@ void View::SetCenter(const Vector2f& center) //////////////////////////////////////////////////////////// void View::SetSize(float width, float height) { - mySize.x = width; - mySize.y = height; + m_size.x = width; + m_size.y = height; - myTransformUpdated = false; - myInvTransformUpdated = false; + m_transformUpdated = false; + m_invTransformUpdated = false; } @@ -108,89 +108,89 @@ void View::SetSize(const Vector2f& size) //////////////////////////////////////////////////////////// void View::SetRotation(float angle) { - myRotation = static_cast(fmod(angle, 360)); - if (myRotation < 0) - myRotation += 360.f; + m_rotation = static_cast(fmod(angle, 360)); + if (m_rotation < 0) + m_rotation += 360.f; - myTransformUpdated = false; - myInvTransformUpdated = false; + m_transformUpdated = false; + m_invTransformUpdated = false; } //////////////////////////////////////////////////////////// void View::SetViewport(const FloatRect& viewport) { - myViewport = viewport; + m_viewport = viewport; } //////////////////////////////////////////////////////////// void View::Reset(const FloatRect& rectangle) { - myCenter.x = rectangle.Left + rectangle.Width / 2.f; - myCenter.y = rectangle.Top + rectangle.Height / 2.f; - mySize.x = rectangle.Width; - mySize.y = rectangle.Height; - myRotation = 0; + m_center.x = rectangle.Left + rectangle.Width / 2.f; + m_center.y = rectangle.Top + rectangle.Height / 2.f; + m_size.x = rectangle.Width; + m_size.y = rectangle.Height; + m_rotation = 0; - myTransformUpdated = false; - myInvTransformUpdated = false; + m_transformUpdated = false; + m_invTransformUpdated = false; } //////////////////////////////////////////////////////////// const Vector2f& View::GetCenter() const { - return myCenter; + return m_center; } //////////////////////////////////////////////////////////// const Vector2f& View::GetSize() const { - return mySize; + return m_size; } //////////////////////////////////////////////////////////// float View::GetRotation() const { - return myRotation; + return m_rotation; } //////////////////////////////////////////////////////////// const FloatRect& View::GetViewport() const { - return myViewport; + return m_viewport; } //////////////////////////////////////////////////////////// void View::Move(float offsetX, float offsetY) { - SetCenter(myCenter.x + offsetX, myCenter.y + offsetY); + SetCenter(m_center.x + offsetX, m_center.y + offsetY); } //////////////////////////////////////////////////////////// void View::Move(const Vector2f& offset) { - SetCenter(myCenter + offset); + SetCenter(m_center + offset); } //////////////////////////////////////////////////////////// void View::Rotate(float angle) { - SetRotation(myRotation + angle); + SetRotation(m_rotation + angle); } //////////////////////////////////////////////////////////// void View::Zoom(float factor) { - SetSize(mySize.x * factor, mySize.y * factor); + SetSize(m_size.x * factor, m_size.y * factor); } @@ -198,29 +198,29 @@ void View::Zoom(float factor) const Transform& View::GetTransform() const { // Recompute the matrix if needed - if (!myTransformUpdated) + if (!m_transformUpdated) { // Rotation components - float angle = myRotation * 3.141592654f / 180.f; + float angle = m_rotation * 3.141592654f / 180.f; float cosine = static_cast(std::cos(angle)); float sine = static_cast(std::sin(angle)); - float tx = -myCenter.x * cosine - myCenter.y * sine + myCenter.x; - float ty = myCenter.x * sine - myCenter.y * cosine + myCenter.y; + float tx = -m_center.x * cosine - m_center.y * sine + m_center.x; + float ty = m_center.x * sine - m_center.y * cosine + m_center.y; // Projection components - float a = 2.f / mySize.x; - float b = -2.f / mySize.y; - float c = -a * myCenter.x; - float d = -b * myCenter.y; + float a = 2.f / m_size.x; + float b = -2.f / m_size.y; + float c = -a * m_center.x; + float d = -b * m_center.y; // Rebuild the projection matrix - myTransform = Transform( a * cosine, a * sine, a * tx + c, + m_transform = Transform( a * cosine, a * sine, a * tx + c, -b * sine, b * cosine, b * ty + d, 0.f, 0.f, 1.f); - myTransformUpdated = true; + m_transformUpdated = true; } - return myTransform; + return m_transform; } @@ -228,13 +228,13 @@ const Transform& View::GetTransform() const const Transform& View::GetInverseTransform() const { // Recompute the matrix if needed - if (!myInvTransformUpdated) + if (!m_invTransformUpdated) { - myInverseTransform = GetTransform().GetInverse(); - myInvTransformUpdated = true; + m_inverseTransform = GetTransform().GetInverse(); + m_invTransformUpdated = true; } - return myInverseTransform; + return m_inverseTransform; } } // namespace sf diff --git a/src/SFML/Network/Ftp.cpp b/src/SFML/Network/Ftp.cpp index ffe059f2..65cc017a 100644 --- a/src/SFML/Network/Ftp.cpp +++ b/src/SFML/Network/Ftp.cpp @@ -57,15 +57,15 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - Ftp& myFtp; ///< Reference to the owner Ftp instance - TcpSocket myDataSocket; ///< Socket used for data transfers + Ftp& m_ftp; ///< Reference to the owner Ftp instance + TcpSocket m_dataSocket; ///< Socket used for data transfers }; //////////////////////////////////////////////////////////// Ftp::Response::Response(Status code, const std::string& message) : -myStatus (code), -myMessage(message) +m_status (code), +m_message(message) { } @@ -74,21 +74,21 @@ myMessage(message) //////////////////////////////////////////////////////////// bool Ftp::Response::IsOk() const { - return myStatus < 400; + return m_status < 400; } //////////////////////////////////////////////////////////// Ftp::Response::Status Ftp::Response::GetStatus() const { - return myStatus; + return m_status; } //////////////////////////////////////////////////////////// const std::string& Ftp::Response::GetMessage() const { - return myMessage; + return m_message; } @@ -101,7 +101,7 @@ Ftp::Response(response) // Extract the directory from the server response std::string::size_type begin = GetMessage().find('"', 0); std::string::size_type end = GetMessage().find('"', begin + 1); - myDirectory = GetMessage().substr(begin + 1, end - begin - 1); + m_directory = GetMessage().substr(begin + 1, end - begin - 1); } } @@ -109,7 +109,7 @@ Ftp::Response(response) //////////////////////////////////////////////////////////// const std::string& Ftp::DirectoryResponse::GetDirectory() const { - return myDirectory; + return m_directory; } @@ -124,7 +124,7 @@ Ftp::Response(response) std::string::size_type lastPos = 0; for (std::string::size_type pos = paths.find("\r\n"); pos != std::string::npos; pos = paths.find("\r\n", lastPos)) { - myFilenames.push_back(paths.substr(lastPos, pos - lastPos)); + m_filenames.push_back(paths.substr(lastPos, pos - lastPos)); lastPos = pos + 2; } } @@ -134,7 +134,7 @@ Ftp::Response(response) //////////////////////////////////////////////////////////// const std::vector& Ftp::ListingResponse::GetFilenames() const { - return myFilenames; + return m_filenames; } @@ -149,7 +149,7 @@ Ftp::~Ftp() Ftp::Response Ftp::Connect(const IpAddress& server, unsigned short port, Time timeout) { // Connect to the server - if (myCommandSocket.Connect(server, port, timeout) != Socket::Done) + if (m_commandSocket.Connect(server, port, timeout) != Socket::Done) return Response(Response::ConnectionFailed); // Get the response to the connection @@ -181,7 +181,7 @@ Ftp::Response Ftp::Disconnect() // Send the exit command Response response = SendCommand("QUIT"); if (response.IsOk()) - myCommandSocket.Disconnect(); + m_commandSocket.Disconnect(); return response; } @@ -376,7 +376,7 @@ Ftp::Response Ftp::SendCommand(const std::string& command, const std::string& pa commandStr = command + "\r\n"; // Send it to the server - if (myCommandSocket.Send(commandStr.c_str(), commandStr.length()) != Socket::Done) + if (m_commandSocket.Send(commandStr.c_str(), commandStr.length()) != Socket::Done) return Response(Response::ConnectionClosed); // Get the response @@ -399,7 +399,7 @@ Ftp::Response Ftp::GetResponse() // Receive the response from the server char buffer[1024]; std::size_t length; - if (myCommandSocket.Receive(buffer, sizeof(buffer), length) != Socket::Done) + if (m_commandSocket.Receive(buffer, sizeof(buffer), length) != Socket::Done) return Response(Response::ConnectionClosed); // There can be several lines inside the received buffer, extract them all @@ -518,7 +518,7 @@ Ftp::Response Ftp::GetResponse() //////////////////////////////////////////////////////////// Ftp::DataChannel::DataChannel(Ftp& owner) : -myFtp(owner) +m_ftp(owner) { } @@ -528,7 +528,7 @@ myFtp(owner) Ftp::Response Ftp::DataChannel::Open(Ftp::TransferMode mode) { // Open a data connection in active mode (we connect to the server) - Ftp::Response response = myFtp.SendCommand("PASV"); + Ftp::Response response = m_ftp.SendCommand("PASV"); if (response.IsOk()) { // Extract the connection address and port from the response @@ -559,7 +559,7 @@ Ftp::Response Ftp::DataChannel::Open(Ftp::TransferMode mode) static_cast(data[3])); // Connect the data channel to the server - if (myDataSocket.Connect(address, port) == Socket::Done) + if (m_dataSocket.Connect(address, port) == Socket::Done) { // Translate the transfer mode to the corresponding FTP parameter std::string modeStr; @@ -571,7 +571,7 @@ Ftp::Response Ftp::DataChannel::Open(Ftp::TransferMode mode) } // Set the transfer mode - response = myFtp.SendCommand("TYPE", modeStr); + response = m_ftp.SendCommand("TYPE", modeStr); } else { @@ -592,13 +592,13 @@ void Ftp::DataChannel::Receive(std::vector& data) data.clear(); char buffer[1024]; std::size_t received; - while (myDataSocket.Receive(buffer, sizeof(buffer), received) == Socket::Done) + while (m_dataSocket.Receive(buffer, sizeof(buffer), received) == Socket::Done) { std::copy(buffer, buffer + received, std::back_inserter(data)); } // Close the data socket - myDataSocket.Disconnect(); + m_dataSocket.Disconnect(); } @@ -607,10 +607,10 @@ void Ftp::DataChannel::Send(const std::vector& data) { // Send data if (!data.empty()) - myDataSocket.Send(&data[0], data.size()); + m_dataSocket.Send(&data[0], data.size()); // Close the data socket - myDataSocket.Disconnect(); + m_dataSocket.Disconnect(); } } // namespace sf diff --git a/src/SFML/Network/Http.cpp b/src/SFML/Network/Http.cpp index 51adf88f..24af5288 100644 --- a/src/SFML/Network/Http.cpp +++ b/src/SFML/Network/Http.cpp @@ -59,40 +59,40 @@ Http::Request::Request(const std::string& uri, Method method, const std::string& //////////////////////////////////////////////////////////// void Http::Request::SetField(const std::string& field, const std::string& value) { - myFields[ToLower(field)] = value; + m_fields[ToLower(field)] = value; } //////////////////////////////////////////////////////////// void Http::Request::SetMethod(Http::Request::Method method) { - myMethod = method; + m_method = method; } //////////////////////////////////////////////////////////// void Http::Request::SetUri(const std::string& uri) { - myURI = uri; + m_uRI = uri; // Make sure it starts with a '/' - if (myURI.empty() || (myURI[0] != '/')) - myURI.insert(0, "/"); + if (m_uRI.empty() || (m_uRI[0] != '/')) + m_uRI.insert(0, "/"); } //////////////////////////////////////////////////////////// void Http::Request::SetHttpVersion(unsigned int major, unsigned int minor) { - myMajorVersion = major; - myMinorVersion = minor; + m_majorVersion = major; + m_minorVersion = minor; } //////////////////////////////////////////////////////////// void Http::Request::SetBody(const std::string& body) { - myBody = body; + m_body = body; } @@ -103,7 +103,7 @@ std::string Http::Request::Prepare() const // Convert the method to its string representation std::string method; - switch (myMethod) + switch (m_method) { default : case Get : method = "GET"; break; @@ -112,11 +112,11 @@ std::string Http::Request::Prepare() const } // Write the first line containing the request type - out << method << " " << myURI << " "; - out << "HTTP/" << myMajorVersion << "." << myMinorVersion << "\r\n"; + out << method << " " << m_uRI << " "; + out << "HTTP/" << m_majorVersion << "." << m_minorVersion << "\r\n"; // Write fields - for (FieldTable::const_iterator i = myFields.begin(); i != myFields.end(); ++i) + for (FieldTable::const_iterator i = m_fields.begin(); i != m_fields.end(); ++i) { out << i->first << ": " << i->second << "\r\n"; } @@ -125,7 +125,7 @@ std::string Http::Request::Prepare() const out << "\r\n"; // Add the body - out << myBody; + out << m_body; return out.str(); } @@ -134,15 +134,15 @@ std::string Http::Request::Prepare() const //////////////////////////////////////////////////////////// bool Http::Request::HasField(const std::string& field) const { - return myFields.find(ToLower(field)) != myFields.end(); + return m_fields.find(ToLower(field)) != m_fields.end(); } //////////////////////////////////////////////////////////// Http::Response::Response() : -myStatus (ConnectionFailed), -myMajorVersion(0), -myMinorVersion(0) +m_status (ConnectionFailed), +m_majorVersion(0), +m_minorVersion(0) { } @@ -151,8 +151,8 @@ myMinorVersion(0) //////////////////////////////////////////////////////////// const std::string& Http::Response::GetField(const std::string& field) const { - FieldTable::const_iterator it = myFields.find(ToLower(field)); - if (it != myFields.end()) + FieldTable::const_iterator it = m_fields.find(ToLower(field)); + if (it != m_fields.end()) { return it->second; } @@ -167,28 +167,28 @@ const std::string& Http::Response::GetField(const std::string& field) const //////////////////////////////////////////////////////////// Http::Response::Status Http::Response::GetStatus() const { - return myStatus; + return m_status; } //////////////////////////////////////////////////////////// unsigned int Http::Response::GetMajorHttpVersion() const { - return myMajorVersion; + return m_majorVersion; } //////////////////////////////////////////////////////////// unsigned int Http::Response::GetMinorHttpVersion() const { - return myMinorVersion; + return m_minorVersion; } //////////////////////////////////////////////////////////// const std::string& Http::Response::GetBody() const { - return myBody; + return m_body; } @@ -205,13 +205,13 @@ void Http::Response::Parse(const std::string& data) (ToLower(version.substr(0, 5)) == "http/") && isdigit(version[5]) && isdigit(version[7])) { - myMajorVersion = version[5] - '0'; - myMinorVersion = version[7] - '0'; + m_majorVersion = version[5] - '0'; + m_minorVersion = version[7] - '0'; } else { // Invalid HTTP version - myStatus = InvalidResponse; + m_status = InvalidResponse; return; } } @@ -220,12 +220,12 @@ void Http::Response::Parse(const std::string& data) int status; if (in >> status) { - myStatus = static_cast(status); + m_status = static_cast(status); } else { // Invalid status code - myStatus = InvalidResponse; + m_status = InvalidResponse; return; } @@ -248,20 +248,20 @@ void Http::Response::Parse(const std::string& data) value.erase(value.size() - 1); // Add the field - myFields[ToLower(field)] = value; + m_fields[ToLower(field)] = value; } } // Finally extract the body - myBody.clear(); - std::copy(std::istreambuf_iterator(in), std::istreambuf_iterator(), std::back_inserter(myBody)); + m_body.clear(); + std::copy(std::istreambuf_iterator(in), std::istreambuf_iterator(), std::back_inserter(m_body)); } //////////////////////////////////////////////////////////// Http::Http() : -myHost(), -myPort(0) +m_host(), +m_port(0) { } @@ -282,27 +282,27 @@ void Http::SetHost(const std::string& host, unsigned short port) if (protocol.substr(0, 7) == "http://") { // HTTP protocol - myHostName = host.substr(7); - myPort = (port != 0 ? port : 80); + m_hostName = host.substr(7); + m_port = (port != 0 ? port : 80); } else if (protocol == "https://") { // HTTPS protocol - myHostName = host.substr(8); - myPort = (port != 0 ? port : 443); + m_hostName = host.substr(8); + m_port = (port != 0 ? port : 443); } else { // Undefined protocol - use HTTP - myHostName = host; - myPort = (port != 0 ? port : 80); + m_hostName = host; + m_port = (port != 0 ? port : 80); } // Remove any trailing '/' from the host name - if (!myHostName.empty() && (*myHostName.rbegin() == '/')) - myHostName.erase(myHostName.size() - 1); + if (!m_hostName.empty() && (*m_hostName.rbegin() == '/')) + m_hostName.erase(m_hostName.size() - 1); - myHost = IpAddress(myHostName); + m_host = IpAddress(m_hostName); } @@ -321,19 +321,19 @@ Http::Response Http::SendRequest(const Http::Request& request, Time timeout) } if (!toSend.HasField("Host")) { - toSend.SetField("Host", myHostName); + toSend.SetField("Host", m_hostName); } if (!toSend.HasField("Content-Length")) { std::ostringstream out; - out << toSend.myBody.size(); + out << toSend.m_body.size(); toSend.SetField("Content-Length", out.str()); } - if ((toSend.myMethod == Request::Post) && !toSend.HasField("Content-Type")) + if ((toSend.m_method == Request::Post) && !toSend.HasField("Content-Type")) { toSend.SetField("Content-Type", "application/x-www-form-urlencoded"); } - if ((toSend.myMajorVersion * 10 + toSend.myMinorVersion >= 11) && !toSend.HasField("Connection")) + if ((toSend.m_majorVersion * 10 + toSend.m_minorVersion >= 11) && !toSend.HasField("Connection")) { toSend.SetField("Connection", "close"); } @@ -342,7 +342,7 @@ Http::Response Http::SendRequest(const Http::Request& request, Time timeout) Response received; // Connect the socket to the host - if (myConnection.Connect(myHost, myPort, timeout) == Socket::Done) + if (m_connection.Connect(m_host, m_port, timeout) == Socket::Done) { // Convert the request to string and send it through the connected socket std::string requestStr = toSend.Prepare(); @@ -350,13 +350,13 @@ Http::Response Http::SendRequest(const Http::Request& request, Time timeout) if (!requestStr.empty()) { // Send it through the socket - if (myConnection.Send(requestStr.c_str(), requestStr.size()) == Socket::Done) + if (m_connection.Send(requestStr.c_str(), requestStr.size()) == Socket::Done) { // Wait for the server's response std::string receivedStr; std::size_t size = 0; char buffer[1024]; - while (myConnection.Receive(buffer, sizeof(buffer), size) == Socket::Done) + while (m_connection.Receive(buffer, sizeof(buffer), size) == Socket::Done) { receivedStr.append(buffer, buffer + size); } @@ -367,7 +367,7 @@ Http::Response Http::SendRequest(const Http::Request& request, Time timeout) } // Close the connection - myConnection.Disconnect(); + m_connection.Disconnect(); } return received; diff --git a/src/SFML/Network/IpAddress.cpp b/src/SFML/Network/IpAddress.cpp index 5e50b9e9..33e37ade 100644 --- a/src/SFML/Network/IpAddress.cpp +++ b/src/SFML/Network/IpAddress.cpp @@ -69,7 +69,7 @@ const IpAddress IpAddress::Broadcast(255, 255, 255, 255); //////////////////////////////////////////////////////////// IpAddress::IpAddress() : -myAddress(0) +m_address(0) { // We're using 0 (INADDR_ANY) instead of INADDR_NONE to represent the invalid address, // because the latter is also the broadcast address (255.255.255.255); it's ok because @@ -79,28 +79,28 @@ myAddress(0) //////////////////////////////////////////////////////////// IpAddress::IpAddress(const std::string& address) : -myAddress(Resolve(address)) +m_address(Resolve(address)) { } //////////////////////////////////////////////////////////// IpAddress::IpAddress(const char* address) : -myAddress(Resolve(address)) +m_address(Resolve(address)) { } //////////////////////////////////////////////////////////// IpAddress::IpAddress(Uint8 byte0, Uint8 byte1, Uint8 byte2, Uint8 byte3) : -myAddress(htonl((byte0 << 24) | (byte1 << 16) | (byte2 << 8) | byte3)) +m_address(htonl((byte0 << 24) | (byte1 << 16) | (byte2 << 8) | byte3)) { } //////////////////////////////////////////////////////////// IpAddress::IpAddress(Uint32 address) : -myAddress(htonl(address)) +m_address(htonl(address)) { } @@ -109,7 +109,7 @@ myAddress(htonl(address)) std::string IpAddress::ToString() const { in_addr address; - address.s_addr = myAddress; + address.s_addr = m_address; return inet_ntoa(address); } @@ -118,7 +118,7 @@ std::string IpAddress::ToString() const //////////////////////////////////////////////////////////// Uint32 IpAddress::ToInteger() const { - return ntohl(myAddress); + return ntohl(m_address); } diff --git a/src/SFML/Network/Packet.cpp b/src/SFML/Network/Packet.cpp index 0a747360..91bfcd53 100644 --- a/src/SFML/Network/Packet.cpp +++ b/src/SFML/Network/Packet.cpp @@ -35,8 +35,8 @@ namespace sf { //////////////////////////////////////////////////////////// Packet::Packet() : -myReadPos(0), -myIsValid(true) +m_readPos(0), +m_isValid(true) { } @@ -54,9 +54,9 @@ void Packet::Append(const void* data, std::size_t sizeInBytes) { if (data && (sizeInBytes > 0)) { - std::size_t start = myData.size(); - myData.resize(start + sizeInBytes); - std::memcpy(&myData[start], data, sizeInBytes); + std::size_t start = m_data.size(); + m_data.resize(start + sizeInBytes); + std::memcpy(&m_data[start], data, sizeInBytes); } } @@ -64,37 +64,37 @@ void Packet::Append(const void* data, std::size_t sizeInBytes) //////////////////////////////////////////////////////////// void Packet::Clear() { - myData.clear(); - myReadPos = 0; - myIsValid = true; + m_data.clear(); + m_readPos = 0; + m_isValid = true; } //////////////////////////////////////////////////////////// const char* Packet::GetData() const { - return !myData.empty() ? &myData[0] : NULL; + return !m_data.empty() ? &m_data[0] : NULL; } //////////////////////////////////////////////////////////// std::size_t Packet::GetDataSize() const { - return myData.size(); + return m_data.size(); } //////////////////////////////////////////////////////////// bool Packet::EndOfPacket() const { - return myReadPos >= myData.size(); + return m_readPos >= m_data.size(); } //////////////////////////////////////////////////////////// Packet::operator BoolType() const { - return myIsValid ? &Packet::CheckSize : NULL; + return m_isValid ? &Packet::CheckSize : NULL; } @@ -114,8 +114,8 @@ Packet& Packet::operator >>(Int8& data) { if (CheckSize(sizeof(data))) { - data = *reinterpret_cast(GetData() + myReadPos); - myReadPos += sizeof(data); + data = *reinterpret_cast(GetData() + m_readPos); + m_readPos += sizeof(data); } return *this; @@ -127,8 +127,8 @@ Packet& Packet::operator >>(Uint8& data) { if (CheckSize(sizeof(data))) { - data = *reinterpret_cast(GetData() + myReadPos); - myReadPos += sizeof(data); + data = *reinterpret_cast(GetData() + m_readPos); + m_readPos += sizeof(data); } return *this; @@ -140,8 +140,8 @@ Packet& Packet::operator >>(Int16& data) { if (CheckSize(sizeof(data))) { - data = ntohs(*reinterpret_cast(GetData() + myReadPos)); - myReadPos += sizeof(data); + data = ntohs(*reinterpret_cast(GetData() + m_readPos)); + m_readPos += sizeof(data); } return *this; @@ -153,8 +153,8 @@ Packet& Packet::operator >>(Uint16& data) { if (CheckSize(sizeof(data))) { - data = ntohs(*reinterpret_cast(GetData() + myReadPos)); - myReadPos += sizeof(data); + data = ntohs(*reinterpret_cast(GetData() + m_readPos)); + m_readPos += sizeof(data); } return *this; @@ -166,8 +166,8 @@ Packet& Packet::operator >>(Int32& data) { if (CheckSize(sizeof(data))) { - data = ntohl(*reinterpret_cast(GetData() + myReadPos)); - myReadPos += sizeof(data); + data = ntohl(*reinterpret_cast(GetData() + m_readPos)); + m_readPos += sizeof(data); } return *this; @@ -179,8 +179,8 @@ Packet& Packet::operator >>(Uint32& data) { if (CheckSize(sizeof(data))) { - data = ntohl(*reinterpret_cast(GetData() + myReadPos)); - myReadPos += sizeof(data); + data = ntohl(*reinterpret_cast(GetData() + m_readPos)); + m_readPos += sizeof(data); } return *this; @@ -192,8 +192,8 @@ Packet& Packet::operator >>(float& data) { if (CheckSize(sizeof(data))) { - data = *reinterpret_cast(GetData() + myReadPos); - myReadPos += sizeof(data); + data = *reinterpret_cast(GetData() + m_readPos); + m_readPos += sizeof(data); } return *this; @@ -205,8 +205,8 @@ Packet& Packet::operator >>(double& data) { if (CheckSize(sizeof(data))) { - data = *reinterpret_cast(GetData() + myReadPos); - myReadPos += sizeof(data); + data = *reinterpret_cast(GetData() + m_readPos); + m_readPos += sizeof(data); } return *this; @@ -223,11 +223,11 @@ Packet& Packet::operator >>(char* data) if ((length > 0) && CheckSize(length)) { // Then extract characters - std::memcpy(data, GetData() + myReadPos, length); + std::memcpy(data, GetData() + m_readPos, length); data[length] = '\0'; // Update reading position - myReadPos += length; + m_readPos += length; } return *this; @@ -245,10 +245,10 @@ Packet& Packet::operator >>(std::string& data) if ((length > 0) && CheckSize(length)) { // Then extract characters - data.assign(GetData() + myReadPos, length); + data.assign(GetData() + m_readPos, length); // Update reading position - myReadPos += length; + m_readPos += length; } return *this; @@ -489,9 +489,9 @@ Packet& Packet::operator <<(const String& data) //////////////////////////////////////////////////////////// bool Packet::CheckSize(std::size_t size) { - myIsValid = myIsValid && (myReadPos + size <= myData.size()); + m_isValid = m_isValid && (m_readPos + size <= m_data.size()); - return myIsValid; + return m_isValid; } diff --git a/src/SFML/Network/Socket.cpp b/src/SFML/Network/Socket.cpp index 110ef71c..de2322af 100644 --- a/src/SFML/Network/Socket.cpp +++ b/src/SFML/Network/Socket.cpp @@ -34,9 +34,9 @@ namespace sf { //////////////////////////////////////////////////////////// Socket::Socket(Type type) : -myType (type), -mySocket (priv::SocketImpl::InvalidSocket()), -myIsBlocking(true) +m_type (type), +m_socket (priv::SocketImpl::InvalidSocket()), +m_isBlocking(true) { } @@ -54,24 +54,24 @@ Socket::~Socket() void Socket::SetBlocking(bool blocking) { // Apply if the socket is already created - if (mySocket != priv::SocketImpl::InvalidSocket()) - priv::SocketImpl::SetBlocking(mySocket, blocking); + if (m_socket != priv::SocketImpl::InvalidSocket()) + priv::SocketImpl::SetBlocking(m_socket, blocking); - myIsBlocking = blocking; + m_isBlocking = blocking; } //////////////////////////////////////////////////////////// bool Socket::IsBlocking() const { - return myIsBlocking; + return m_isBlocking; } //////////////////////////////////////////////////////////// SocketHandle Socket::GetHandle() const { - return mySocket; + return m_socket; } @@ -79,9 +79,9 @@ SocketHandle Socket::GetHandle() const void Socket::Create() { // Don't create the socket if it already exists - if (mySocket == priv::SocketImpl::InvalidSocket()) + if (m_socket == priv::SocketImpl::InvalidSocket()) { - SocketHandle handle = socket(PF_INET, myType == Tcp ? SOCK_STREAM : SOCK_DGRAM, 0); + SocketHandle handle = socket(PF_INET, m_type == Tcp ? SOCK_STREAM : SOCK_DGRAM, 0); Create(handle); } } @@ -91,19 +91,19 @@ void Socket::Create() void Socket::Create(SocketHandle handle) { // Don't create the socket if it already exists - if (mySocket == priv::SocketImpl::InvalidSocket()) + if (m_socket == priv::SocketImpl::InvalidSocket()) { // Assign the new handle - mySocket = handle; + m_socket = handle; // Set the current blocking state - SetBlocking(myIsBlocking); + SetBlocking(m_isBlocking); - if (myType == Tcp) + if (m_type == Tcp) { // Disable the Nagle algorithm (ie. removes buffering of TCP packets) int yes = 1; - if (setsockopt(mySocket, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast(&yes), sizeof(yes)) == -1) + if (setsockopt(m_socket, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast(&yes), sizeof(yes)) == -1) { Err() << "Failed to set socket option \"TCP_NODELAY\" ; " << "all your TCP packets will be buffered" << std::endl; @@ -113,7 +113,7 @@ void Socket::Create(SocketHandle handle) { // Enable broadcast by default for UDP sockets int yes = 1; - if (setsockopt(mySocket, SOL_SOCKET, SO_BROADCAST, reinterpret_cast(&yes), sizeof(yes)) == -1) + if (setsockopt(m_socket, SOL_SOCKET, SO_BROADCAST, reinterpret_cast(&yes), sizeof(yes)) == -1) { Err() << "Failed to enable broadcast on UDP socket" << std::endl; } @@ -126,10 +126,10 @@ void Socket::Create(SocketHandle handle) void Socket::Close() { // Close the socket - if (mySocket != priv::SocketImpl::InvalidSocket()) + if (m_socket != priv::SocketImpl::InvalidSocket()) { - priv::SocketImpl::Close(mySocket); - mySocket = priv::SocketImpl::InvalidSocket(); + priv::SocketImpl::Close(m_socket); + m_socket = priv::SocketImpl::InvalidSocket(); } } diff --git a/src/SFML/Network/SocketSelector.cpp b/src/SFML/Network/SocketSelector.cpp index 9872a070..196e5ca1 100644 --- a/src/SFML/Network/SocketSelector.cpp +++ b/src/SFML/Network/SocketSelector.cpp @@ -49,7 +49,7 @@ struct SocketSelector::SocketSelectorImpl //////////////////////////////////////////////////////////// SocketSelector::SocketSelector() : -myImpl(new SocketSelectorImpl) +m_impl(new SocketSelectorImpl) { Clear(); } @@ -57,7 +57,7 @@ myImpl(new SocketSelectorImpl) //////////////////////////////////////////////////////////// SocketSelector::SocketSelector(const SocketSelector& copy) : -myImpl(new SocketSelectorImpl(*copy.myImpl)) +m_impl(new SocketSelectorImpl(*copy.m_impl)) { } @@ -66,36 +66,36 @@ myImpl(new SocketSelectorImpl(*copy.myImpl)) //////////////////////////////////////////////////////////// SocketSelector::~SocketSelector() { - delete myImpl; + delete m_impl; } //////////////////////////////////////////////////////////// void SocketSelector::Add(Socket& socket) { - FD_SET(socket.GetHandle(), &myImpl->AllSockets); + FD_SET(socket.GetHandle(), &m_impl->AllSockets); int size = static_cast(socket.GetHandle()); - if (size > myImpl->MaxSocket) - myImpl->MaxSocket = size; + if (size > m_impl->MaxSocket) + m_impl->MaxSocket = size; } //////////////////////////////////////////////////////////// void SocketSelector::Remove(Socket& socket) { - FD_CLR(socket.GetHandle(), &myImpl->AllSockets); - FD_CLR(socket.GetHandle(), &myImpl->SocketsReady); + FD_CLR(socket.GetHandle(), &m_impl->AllSockets); + FD_CLR(socket.GetHandle(), &m_impl->SocketsReady); } //////////////////////////////////////////////////////////// void SocketSelector::Clear() { - FD_ZERO(&myImpl->AllSockets); - FD_ZERO(&myImpl->SocketsReady); + FD_ZERO(&m_impl->AllSockets); + FD_ZERO(&m_impl->SocketsReady); - myImpl->MaxSocket = 0; + m_impl->MaxSocket = 0; } @@ -108,10 +108,10 @@ bool SocketSelector::Wait(Time timeout) time.tv_usec = static_cast(timeout.AsMicroseconds() % 1000000); // Initialize the set that will contain the sockets that are ready - myImpl->SocketsReady = myImpl->AllSockets; + m_impl->SocketsReady = m_impl->AllSockets; // Wait until one of the sockets is ready for reading, or timeout is reached - int count = select(myImpl->MaxSocket + 1, &myImpl->SocketsReady, NULL, NULL, timeout != Time::Zero ? &time : NULL); + int count = select(m_impl->MaxSocket + 1, &m_impl->SocketsReady, NULL, NULL, timeout != Time::Zero ? &time : NULL); return count > 0; } @@ -120,7 +120,7 @@ bool SocketSelector::Wait(Time timeout) //////////////////////////////////////////////////////////// bool SocketSelector::IsReady(Socket& socket) const { - return FD_ISSET(socket.GetHandle(), &myImpl->SocketsReady) != 0; + return FD_ISSET(socket.GetHandle(), &m_impl->SocketsReady) != 0; } @@ -129,7 +129,7 @@ SocketSelector& SocketSelector::operator =(const SocketSelector& right) { SocketSelector temp(right); - std::swap(myImpl, temp.myImpl); + std::swap(m_impl, temp.m_impl); return *this; } diff --git a/src/SFML/Network/TcpSocket.cpp b/src/SFML/Network/TcpSocket.cpp index a4842f29..62ccdb97 100644 --- a/src/SFML/Network/TcpSocket.cpp +++ b/src/SFML/Network/TcpSocket.cpp @@ -201,7 +201,7 @@ void TcpSocket::Disconnect() Close(); // Reset the pending packet data - myPendingPacket = PendingPacket(); + m_pendingPacket = PendingPacket(); } @@ -305,35 +305,35 @@ Socket::Status TcpSocket::Receive(Packet& packet) // We start by getting the size of the incoming packet Uint32 packetSize = 0; std::size_t received = 0; - if (myPendingPacket.SizeReceived < sizeof(myPendingPacket.Size)) + if (m_pendingPacket.SizeReceived < sizeof(m_pendingPacket.Size)) { // Loop until we've received the entire size of the packet // (even a 4 byte variable may be received in more than one call) - while (myPendingPacket.SizeReceived < sizeof(myPendingPacket.Size)) + while (m_pendingPacket.SizeReceived < sizeof(m_pendingPacket.Size)) { - char* data = reinterpret_cast(&myPendingPacket.Size) + myPendingPacket.SizeReceived; - Status status = Receive(data, sizeof(myPendingPacket.Size) - myPendingPacket.SizeReceived, received); - myPendingPacket.SizeReceived += received; + char* data = reinterpret_cast(&m_pendingPacket.Size) + m_pendingPacket.SizeReceived; + Status status = Receive(data, sizeof(m_pendingPacket.Size) - m_pendingPacket.SizeReceived, received); + m_pendingPacket.SizeReceived += received; if (status != Done) return status; } // The packet size has been fully received - packetSize = ntohl(myPendingPacket.Size); + packetSize = ntohl(m_pendingPacket.Size); } else { // The packet size has already been received in a previous call - packetSize = ntohl(myPendingPacket.Size); + packetSize = ntohl(m_pendingPacket.Size); } // Loop until we receive all the packet data char buffer[1024]; - while (myPendingPacket.Data.size() < packetSize) + while (m_pendingPacket.Data.size() < packetSize) { // Receive a chunk of data - std::size_t sizeToGet = std::min(static_cast(packetSize - myPendingPacket.Data.size()), sizeof(buffer)); + std::size_t sizeToGet = std::min(static_cast(packetSize - m_pendingPacket.Data.size()), sizeof(buffer)); Status status = Receive(buffer, sizeToGet, received); if (status != Done) return status; @@ -341,18 +341,18 @@ Socket::Status TcpSocket::Receive(Packet& packet) // Append it into the packet if (received > 0) { - myPendingPacket.Data.resize(myPendingPacket.Data.size() + received); - char* begin = &myPendingPacket.Data[0] + myPendingPacket.Data.size() - received; + m_pendingPacket.Data.resize(m_pendingPacket.Data.size() + received); + char* begin = &m_pendingPacket.Data[0] + m_pendingPacket.Data.size() - received; std::memcpy(begin, buffer, received); } } // We have received all the packet data: we can copy it to the user packet - if (!myPendingPacket.Data.empty()) - packet.OnReceive(&myPendingPacket.Data[0], myPendingPacket.Data.size()); + if (!m_pendingPacket.Data.empty()) + packet.OnReceive(&m_pendingPacket.Data[0], m_pendingPacket.Data.size()); // Clear the pending packet data - myPendingPacket = PendingPacket(); + m_pendingPacket = PendingPacket(); return Done; } diff --git a/src/SFML/Network/UdpSocket.cpp b/src/SFML/Network/UdpSocket.cpp index 3eed3b35..68deaf6d 100644 --- a/src/SFML/Network/UdpSocket.cpp +++ b/src/SFML/Network/UdpSocket.cpp @@ -38,7 +38,7 @@ namespace sf //////////////////////////////////////////////////////////// UdpSocket::UdpSocket() : Socket (Udp), -myBuffer(MaxDatagramSize) +m_buffer(MaxDatagramSize) { } @@ -179,12 +179,12 @@ Socket::Status UdpSocket::Receive(Packet& packet, IpAddress& remoteAddress, unsi // Receive the datagram std::size_t received = 0; - Status status = Receive(&myBuffer[0], myBuffer.size(), received, remoteAddress, remotePort); + Status status = Receive(&m_buffer[0], m_buffer.size(), received, remoteAddress, remotePort); // If we received valid data, we can copy it to the user packet packet.Clear(); if ((status == Done) && (received > 0)) - packet.OnReceive(&myBuffer[0], received); + packet.OnReceive(&m_buffer[0], received); return status; } diff --git a/src/SFML/System/Clock.cpp b/src/SFML/System/Clock.cpp index 5b310d7f..3d629c7c 100644 --- a/src/SFML/System/Clock.cpp +++ b/src/SFML/System/Clock.cpp @@ -38,7 +38,7 @@ namespace sf { //////////////////////////////////////////////////////////// Clock::Clock() : -myStartTime(priv::ClockImpl::GetCurrentTime()) +m_startTime(priv::ClockImpl::GetCurrentTime()) { } @@ -46,7 +46,7 @@ myStartTime(priv::ClockImpl::GetCurrentTime()) //////////////////////////////////////////////////////////// Time Clock::GetElapsedTime() const { - return priv::ClockImpl::GetCurrentTime() - myStartTime; + return priv::ClockImpl::GetCurrentTime() - m_startTime; } @@ -54,8 +54,8 @@ Time Clock::GetElapsedTime() const Time Clock::Restart() { Time now = priv::ClockImpl::GetCurrentTime(); - Time elapsed = now - myStartTime; - myStartTime = now; + Time elapsed = now - m_startTime; + m_startTime = now; return elapsed; } diff --git a/src/SFML/System/Lock.cpp b/src/SFML/System/Lock.cpp index e3a4970c..c9dd8152 100644 --- a/src/SFML/System/Lock.cpp +++ b/src/SFML/System/Lock.cpp @@ -33,16 +33,16 @@ namespace sf { //////////////////////////////////////////////////////////// Lock::Lock(Mutex& mutex) : -myMutex(mutex) +m_mutex(mutex) { - myMutex.Lock(); + m_mutex.Lock(); } //////////////////////////////////////////////////////////// Lock::~Lock() { - myMutex.Unlock(); + m_mutex.Unlock(); } } // namespace sf diff --git a/src/SFML/System/Mutex.cpp b/src/SFML/System/Mutex.cpp index fa542500..6e4d9b0d 100644 --- a/src/SFML/System/Mutex.cpp +++ b/src/SFML/System/Mutex.cpp @@ -44,28 +44,28 @@ namespace sf //////////////////////////////////////////////////////////// Mutex::Mutex() { - myMutexImpl = new priv::MutexImpl; + m_mutexImpl = new priv::MutexImpl; } //////////////////////////////////////////////////////////// Mutex::~Mutex() { - delete myMutexImpl; + delete m_mutexImpl; } //////////////////////////////////////////////////////////// void Mutex::Lock() { - myMutexImpl->Lock(); + m_mutexImpl->Lock(); } //////////////////////////////////////////////////////////// void Mutex::Unlock() { - myMutexImpl->Unlock(); + m_mutexImpl->Unlock(); } } // namespace sf diff --git a/src/SFML/System/String.cpp b/src/SFML/System/String.cpp index c7e970f3..71e96b8e 100644 --- a/src/SFML/System/String.cpp +++ b/src/SFML/System/String.cpp @@ -46,21 +46,21 @@ String::String() //////////////////////////////////////////////////////////// String::String(char ansiChar, const std::locale& locale) { - myString += Utf32::DecodeAnsi(ansiChar, locale); + m_string += Utf32::DecodeAnsi(ansiChar, locale); } //////////////////////////////////////////////////////////// String::String(wchar_t wideChar) { - myString += Utf32::DecodeWide(wideChar); + m_string += Utf32::DecodeWide(wideChar); } //////////////////////////////////////////////////////////// String::String(Uint32 utf32Char) { - myString += utf32Char; + m_string += utf32Char; } @@ -72,8 +72,8 @@ String::String(const char* ansiString, const std::locale& locale) std::size_t length = strlen(ansiString); if (length > 0) { - myString.reserve(length + 1); - Utf32::FromAnsi(ansiString, ansiString + length, std::back_inserter(myString), locale); + m_string.reserve(length + 1); + Utf32::FromAnsi(ansiString, ansiString + length, std::back_inserter(m_string), locale); } } } @@ -82,8 +82,8 @@ String::String(const char* ansiString, const std::locale& locale) //////////////////////////////////////////////////////////// String::String(const std::string& ansiString, const std::locale& locale) { - myString.reserve(ansiString.length() + 1); - Utf32::FromAnsi(ansiString.begin(), ansiString.end(), std::back_inserter(myString), locale); + m_string.reserve(ansiString.length() + 1); + Utf32::FromAnsi(ansiString.begin(), ansiString.end(), std::back_inserter(m_string), locale); } @@ -95,8 +95,8 @@ String::String(const wchar_t* wideString) std::size_t length = std::wcslen(wideString); if (length > 0) { - myString.reserve(length + 1); - Utf32::FromWide(wideString, wideString + length, std::back_inserter(myString)); + m_string.reserve(length + 1); + Utf32::FromWide(wideString, wideString + length, std::back_inserter(m_string)); } } } @@ -105,8 +105,8 @@ String::String(const wchar_t* wideString) //////////////////////////////////////////////////////////// String::String(const std::wstring& wideString) { - myString.reserve(wideString.length() + 1); - Utf32::FromWide(wideString.begin(), wideString.end(), std::back_inserter(myString)); + m_string.reserve(wideString.length() + 1); + Utf32::FromWide(wideString.begin(), wideString.end(), std::back_inserter(m_string)); } @@ -114,20 +114,20 @@ String::String(const std::wstring& wideString) String::String(const Uint32* utf32String) { if (utf32String) - myString = utf32String; + m_string = utf32String; } //////////////////////////////////////////////////////////// String::String(const std::basic_string& utf32String) : -myString(utf32String) +m_string(utf32String) { } //////////////////////////////////////////////////////////// String::String(const String& copy) : -myString(copy.myString) +m_string(copy.m_string) { } @@ -151,10 +151,10 @@ std::string String::ToAnsiString(const std::locale& locale) const { // Prepare the output string std::string output; - output.reserve(myString.length() + 1); + output.reserve(m_string.length() + 1); // Convert - Utf32::ToAnsi(myString.begin(), myString.end(), std::back_inserter(output), 0, locale); + Utf32::ToAnsi(m_string.begin(), m_string.end(), std::back_inserter(output), 0, locale); return output; } @@ -165,10 +165,10 @@ std::wstring String::ToWideString() const { // Prepare the output string std::wstring output; - output.reserve(myString.length() + 1); + output.reserve(m_string.length() + 1); // Convert - Utf32::ToWide(myString.begin(), myString.end(), std::back_inserter(output), 0); + Utf32::ToWide(m_string.begin(), m_string.end(), std::back_inserter(output), 0); return output; } @@ -177,7 +177,7 @@ std::wstring String::ToWideString() const //////////////////////////////////////////////////////////// String& String::operator =(const String& right) { - myString = right.myString; + m_string = right.m_string; return *this; } @@ -185,7 +185,7 @@ String& String::operator =(const String& right) //////////////////////////////////////////////////////////// String& String::operator +=(const String& right) { - myString += right.myString; + m_string += right.m_string; return *this; } @@ -193,98 +193,98 @@ String& String::operator +=(const String& right) //////////////////////////////////////////////////////////// Uint32 String::operator [](std::size_t index) const { - return myString[index]; + return m_string[index]; } //////////////////////////////////////////////////////////// Uint32& String::operator [](std::size_t index) { - return myString[index]; + return m_string[index]; } //////////////////////////////////////////////////////////// void String::Clear() { - myString.clear(); + m_string.clear(); } //////////////////////////////////////////////////////////// std::size_t String::GetSize() const { - return myString.size(); + return m_string.size(); } //////////////////////////////////////////////////////////// bool String::IsEmpty() const { - return myString.empty(); + return m_string.empty(); } //////////////////////////////////////////////////////////// void String::Erase(std::size_t position, std::size_t count) { - myString.erase(position, count); + m_string.erase(position, count); } //////////////////////////////////////////////////////////// void String::Insert(std::size_t position, const String& str) { - myString.insert(position, str.myString); + m_string.insert(position, str.m_string); } //////////////////////////////////////////////////////////// std::size_t String::Find(const String& str, std::size_t start) const { - return myString.find(str.myString, start); + return m_string.find(str.m_string, start); } //////////////////////////////////////////////////////////// const Uint32* String::GetData() const { - return myString.c_str(); + return m_string.c_str(); } //////////////////////////////////////////////////////////// String::Iterator String::Begin() { - return myString.begin(); + return m_string.begin(); } //////////////////////////////////////////////////////////// String::ConstIterator String::Begin() const { - return myString.begin(); + return m_string.begin(); } //////////////////////////////////////////////////////////// String::Iterator String::End() { - return myString.end(); + return m_string.end(); } //////////////////////////////////////////////////////////// String::ConstIterator String::End() const { - return myString.end(); + return m_string.end(); } //////////////////////////////////////////////////////////// bool operator ==(const String& left, const String& right) { - return left.myString == right.myString; + return left.m_string == right.m_string; } @@ -298,7 +298,7 @@ bool operator !=(const String& left, const String& right) //////////////////////////////////////////////////////////// bool operator <(const String& left, const String& right) { - return left.myString < right.myString; + return left.m_string < right.m_string; } diff --git a/src/SFML/System/Thread.cpp b/src/SFML/System/Thread.cpp index 9fe51629..3499cbf9 100644 --- a/src/SFML/System/Thread.cpp +++ b/src/SFML/System/Thread.cpp @@ -41,7 +41,7 @@ namespace sf Thread::~Thread() { Wait(); - delete myEntryPoint; + delete m_entryPoint; } @@ -49,18 +49,18 @@ Thread::~Thread() void Thread::Launch() { Wait(); - myImpl = new priv::ThreadImpl(this); + m_impl = new priv::ThreadImpl(this); } //////////////////////////////////////////////////////////// void Thread::Wait() { - if (myImpl) + if (m_impl) { - myImpl->Wait(); - delete myImpl; - myImpl = NULL; + m_impl->Wait(); + delete m_impl; + m_impl = NULL; } } @@ -68,11 +68,11 @@ void Thread::Wait() //////////////////////////////////////////////////////////// void Thread::Terminate() { - if (myImpl) + if (m_impl) { - myImpl->Terminate(); - delete myImpl; - myImpl = NULL; + m_impl->Terminate(); + delete m_impl; + m_impl = NULL; } } @@ -80,7 +80,7 @@ void Thread::Terminate() //////////////////////////////////////////////////////////// void Thread::Run() { - myEntryPoint->Run(); + m_entryPoint->Run(); } } // namespace sf diff --git a/src/SFML/System/ThreadLocal.cpp b/src/SFML/System/ThreadLocal.cpp index 594c1d03..8d93c0ac 100644 --- a/src/SFML/System/ThreadLocal.cpp +++ b/src/SFML/System/ThreadLocal.cpp @@ -44,7 +44,7 @@ namespace sf //////////////////////////////////////////////////////////// ThreadLocal::ThreadLocal(void* value) { - myImpl = new priv::ThreadLocalImpl; + m_impl = new priv::ThreadLocalImpl; SetValue(value); } @@ -52,21 +52,21 @@ ThreadLocal::ThreadLocal(void* value) //////////////////////////////////////////////////////////// ThreadLocal::~ThreadLocal() { - delete myImpl; + delete m_impl; } //////////////////////////////////////////////////////////// void ThreadLocal::SetValue(void* value) { - myImpl->SetValue(value); + m_impl->SetValue(value); } //////////////////////////////////////////////////////////// void* ThreadLocal::GetValue() const { - return myImpl->GetValue(); + return m_impl->GetValue(); } } // namespace sf diff --git a/src/SFML/System/Time.cpp b/src/SFML/System/Time.cpp index 22fa55bd..c1b8d003 100644 --- a/src/SFML/System/Time.cpp +++ b/src/SFML/System/Time.cpp @@ -36,7 +36,7 @@ const Time Time::Zero; //////////////////////////////////////////////////////////// Time::Time() : -myMicroseconds(0) +m_microseconds(0) { } @@ -44,27 +44,27 @@ myMicroseconds(0) //////////////////////////////////////////////////////////// float Time::AsSeconds() const { - return myMicroseconds / 1000000.f; + return m_microseconds / 1000000.f; } //////////////////////////////////////////////////////////// Int32 Time::AsMilliseconds() const { - return static_cast(myMicroseconds / 1000); + return static_cast(m_microseconds / 1000); } //////////////////////////////////////////////////////////// Int64 Time::AsMicroseconds() const { - return myMicroseconds; + return m_microseconds; } //////////////////////////////////////////////////////////// Time::Time(Int64 microseconds) : -myMicroseconds(microseconds) +m_microseconds(microseconds) { } diff --git a/src/SFML/System/Unix/MutexImpl.cpp b/src/SFML/System/Unix/MutexImpl.cpp index c9cc5549..4f1f52b3 100644 --- a/src/SFML/System/Unix/MutexImpl.cpp +++ b/src/SFML/System/Unix/MutexImpl.cpp @@ -40,28 +40,28 @@ MutexImpl::MutexImpl() pthread_mutexattr_init(&attributes); pthread_mutexattr_settype(&attributes, PTHREAD_MUTEX_RECURSIVE); - pthread_mutex_init(&myMutex, &attributes); + pthread_mutex_init(&m_mutex, &attributes); } //////////////////////////////////////////////////////////// MutexImpl::~MutexImpl() { - pthread_mutex_destroy(&myMutex); + pthread_mutex_destroy(&m_mutex); } //////////////////////////////////////////////////////////// void MutexImpl::Lock() { - pthread_mutex_lock(&myMutex); + pthread_mutex_lock(&m_mutex); } //////////////////////////////////////////////////////////// void MutexImpl::Unlock() { - pthread_mutex_unlock(&myMutex); + pthread_mutex_unlock(&m_mutex); } } // namespace priv diff --git a/src/SFML/System/Unix/MutexImpl.hpp b/src/SFML/System/Unix/MutexImpl.hpp index e6cb5873..7c87ac30 100644 --- a/src/SFML/System/Unix/MutexImpl.hpp +++ b/src/SFML/System/Unix/MutexImpl.hpp @@ -72,7 +72,7 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - pthread_mutex_t myMutex; ///< pthread handle of the mutex + pthread_mutex_t m_mutex; ///< pthread handle of the mutex }; } // namespace priv diff --git a/src/SFML/System/Unix/ThreadImpl.cpp b/src/SFML/System/Unix/ThreadImpl.cpp index c85396a5..7a8b4855 100644 --- a/src/SFML/System/Unix/ThreadImpl.cpp +++ b/src/SFML/System/Unix/ThreadImpl.cpp @@ -37,11 +37,11 @@ namespace priv { //////////////////////////////////////////////////////////// ThreadImpl::ThreadImpl(Thread* owner) : -myIsActive(true) +m_isActive(true) { - myIsActive = pthread_create(&myThread, NULL, &ThreadImpl::EntryPoint, owner) == 0; + m_isActive = pthread_create(&m_thread, NULL, &ThreadImpl::EntryPoint, owner) == 0; - if (!myIsActive) + if (!m_isActive) std::cerr << "Failed to create thread" << std::endl; } @@ -49,10 +49,10 @@ myIsActive(true) //////////////////////////////////////////////////////////// void ThreadImpl::Wait() { - if (myIsActive) + if (m_isActive) { - assert(pthread_equal(pthread_self(), myThread) == 0); // A thread cannot wait for itself! - pthread_join(myThread, NULL); + assert(pthread_equal(pthread_self(), m_thread) == 0); // A thread cannot wait for itself! + pthread_join(m_thread, NULL); } } @@ -60,8 +60,8 @@ void ThreadImpl::Wait() //////////////////////////////////////////////////////////// void ThreadImpl::Terminate() { - if (myIsActive) - pthread_cancel(myThread); + if (m_isActive) + pthread_cancel(m_thread); } diff --git a/src/SFML/System/Unix/ThreadImpl.hpp b/src/SFML/System/Unix/ThreadImpl.hpp index f059ca6f..760c36bd 100644 --- a/src/SFML/System/Unix/ThreadImpl.hpp +++ b/src/SFML/System/Unix/ThreadImpl.hpp @@ -80,8 +80,8 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - pthread_t myThread; ///< pthread thread instance - bool myIsActive; ///< Thread state (active or inactive) + pthread_t m_thread; ///< pthread thread instance + bool m_isActive; ///< Thread state (active or inactive) }; } // namespace priv diff --git a/src/SFML/System/Unix/ThreadLocalImpl.cpp b/src/SFML/System/Unix/ThreadLocalImpl.cpp index d7f71b77..5c929d46 100644 --- a/src/SFML/System/Unix/ThreadLocalImpl.cpp +++ b/src/SFML/System/Unix/ThreadLocalImpl.cpp @@ -35,28 +35,28 @@ namespace priv //////////////////////////////////////////////////////////// ThreadLocalImpl::ThreadLocalImpl() { - pthread_key_create(&myKey, NULL); + pthread_key_create(&m_key, NULL); } //////////////////////////////////////////////////////////// ThreadLocalImpl::~ThreadLocalImpl() { - pthread_key_delete(myKey); + pthread_key_delete(m_key); } //////////////////////////////////////////////////////////// void ThreadLocalImpl::SetValue(void* value) { - pthread_setspecific(myKey, value); + pthread_setspecific(m_key, value); } //////////////////////////////////////////////////////////// void* ThreadLocalImpl::GetValue() const { - return pthread_getspecific(myKey); + return pthread_getspecific(m_key); } } // namespace priv diff --git a/src/SFML/System/Unix/ThreadLocalImpl.hpp b/src/SFML/System/Unix/ThreadLocalImpl.hpp index a3ade9d2..86986b23 100644 --- a/src/SFML/System/Unix/ThreadLocalImpl.hpp +++ b/src/SFML/System/Unix/ThreadLocalImpl.hpp @@ -76,7 +76,7 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - pthread_key_t myKey; ///< Index of our thread-local storage slot + pthread_key_t m_key; ///< Index of our thread-local storage slot }; } // namespace priv diff --git a/src/SFML/System/Win32/MutexImpl.cpp b/src/SFML/System/Win32/MutexImpl.cpp index 2532445b..e847511f 100644 --- a/src/SFML/System/Win32/MutexImpl.cpp +++ b/src/SFML/System/Win32/MutexImpl.cpp @@ -35,28 +35,28 @@ namespace priv //////////////////////////////////////////////////////////// MutexImpl::MutexImpl() { - InitializeCriticalSection(&myMutex); + InitializeCriticalSection(&m_mutex); } //////////////////////////////////////////////////////////// MutexImpl::~MutexImpl() { - DeleteCriticalSection(&myMutex); + DeleteCriticalSection(&m_mutex); } //////////////////////////////////////////////////////////// void MutexImpl::Lock() { - EnterCriticalSection(&myMutex); + EnterCriticalSection(&m_mutex); } //////////////////////////////////////////////////////////// void MutexImpl::Unlock() { - LeaveCriticalSection(&myMutex); + LeaveCriticalSection(&m_mutex); } } // namespace priv diff --git a/src/SFML/System/Win32/MutexImpl.hpp b/src/SFML/System/Win32/MutexImpl.hpp index 743a4549..46d624de 100644 --- a/src/SFML/System/Win32/MutexImpl.hpp +++ b/src/SFML/System/Win32/MutexImpl.hpp @@ -72,7 +72,7 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - CRITICAL_SECTION myMutex; ///< Win32 handle of the mutex + CRITICAL_SECTION m_mutex; ///< Win32 handle of the mutex }; } // namespace priv diff --git a/src/SFML/System/Win32/ThreadImpl.cpp b/src/SFML/System/Win32/ThreadImpl.cpp index 6cc09957..c4c7cb74 100644 --- a/src/SFML/System/Win32/ThreadImpl.cpp +++ b/src/SFML/System/Win32/ThreadImpl.cpp @@ -39,9 +39,9 @@ namespace priv //////////////////////////////////////////////////////////// ThreadImpl::ThreadImpl(Thread* owner) { - myThread = reinterpret_cast(_beginthreadex(NULL, 0, &ThreadImpl::EntryPoint, owner, 0, &myThreadId)); + m_thread = reinterpret_cast(_beginthreadex(NULL, 0, &ThreadImpl::EntryPoint, owner, 0, &m_threadId)); - if (!myThread) + if (!m_thread) Err() << "Failed to create thread" << std::endl; } @@ -49,18 +49,18 @@ ThreadImpl::ThreadImpl(Thread* owner) //////////////////////////////////////////////////////////// ThreadImpl::~ThreadImpl() { - if (myThread) - CloseHandle(myThread); + if (m_thread) + CloseHandle(m_thread); } //////////////////////////////////////////////////////////// void ThreadImpl::Wait() { - if (myThread) + if (m_thread) { - assert(myThreadId != GetCurrentThreadId()); // A thread cannot wait for itself! - WaitForSingleObject(myThread, INFINITE); + assert(m_threadId != GetCurrentThreadId()); // A thread cannot wait for itself! + WaitForSingleObject(m_thread, INFINITE); } } @@ -68,8 +68,8 @@ void ThreadImpl::Wait() //////////////////////////////////////////////////////////// void ThreadImpl::Terminate() { - if (myThread) - TerminateThread(myThread, 0); + if (m_thread) + TerminateThread(m_thread, 0); } diff --git a/src/SFML/System/Win32/ThreadImpl.hpp b/src/SFML/System/Win32/ThreadImpl.hpp index f565ac1f..47616219 100644 --- a/src/SFML/System/Win32/ThreadImpl.hpp +++ b/src/SFML/System/Win32/ThreadImpl.hpp @@ -86,8 +86,8 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - HANDLE myThread; ///< Win32 thread handle - unsigned int myThreadId; ///< Win32 thread identifier + HANDLE m_thread; ///< Win32 thread handle + unsigned int m_threadId; ///< Win32 thread identifier }; } // namespace priv diff --git a/src/SFML/System/Win32/ThreadLocalImpl.cpp b/src/SFML/System/Win32/ThreadLocalImpl.cpp index d5868b92..b7ff429b 100644 --- a/src/SFML/System/Win32/ThreadLocalImpl.cpp +++ b/src/SFML/System/Win32/ThreadLocalImpl.cpp @@ -35,28 +35,28 @@ namespace priv //////////////////////////////////////////////////////////// ThreadLocalImpl::ThreadLocalImpl() { - myIndex = TlsAlloc(); + m_index = TlsAlloc(); } //////////////////////////////////////////////////////////// ThreadLocalImpl::~ThreadLocalImpl() { - TlsFree(myIndex); + TlsFree(m_index); } //////////////////////////////////////////////////////////// void ThreadLocalImpl::SetValue(void* value) { - TlsSetValue(myIndex, value); + TlsSetValue(m_index, value); } //////////////////////////////////////////////////////////// void* ThreadLocalImpl::GetValue() const { - return TlsGetValue(myIndex); + return TlsGetValue(m_index); } } // namespace priv diff --git a/src/SFML/System/Win32/ThreadLocalImpl.hpp b/src/SFML/System/Win32/ThreadLocalImpl.hpp index cb21cfc1..0a50c274 100644 --- a/src/SFML/System/Win32/ThreadLocalImpl.hpp +++ b/src/SFML/System/Win32/ThreadLocalImpl.hpp @@ -76,7 +76,7 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - DWORD myIndex; ///< Index of our thread-local storage slot + DWORD m_index; ///< Index of our thread-local storage slot }; } // namespace priv diff --git a/src/SFML/Window/Context.cpp b/src/SFML/Window/Context.cpp index fa323d5f..cfd07c1b 100644 --- a/src/SFML/Window/Context.cpp +++ b/src/SFML/Window/Context.cpp @@ -34,7 +34,7 @@ namespace sf //////////////////////////////////////////////////////////// Context::Context() { - myContext = priv::GlContext::Create(); + m_context = priv::GlContext::Create(); SetActive(true); } @@ -42,21 +42,21 @@ Context::Context() //////////////////////////////////////////////////////////// Context::~Context() { - delete myContext; + delete m_context; } //////////////////////////////////////////////////////////// bool Context::SetActive(bool active) { - return myContext->SetActive(active); + return m_context->SetActive(active); } //////////////////////////////////////////////////////////// Context::Context(const ContextSettings& settings, unsigned int width, unsigned int height) { - myContext = priv::GlContext::Create(settings, width, height); + m_context = priv::GlContext::Create(settings, width, height); SetActive(true); } diff --git a/src/SFML/Window/GlContext.cpp b/src/SFML/Window/GlContext.cpp index 73914c89..0154c951 100644 --- a/src/SFML/Window/GlContext.cpp +++ b/src/SFML/Window/GlContext.cpp @@ -186,7 +186,7 @@ GlContext::~GlContext() //////////////////////////////////////////////////////////// const ContextSettings& GlContext::GetSettings() const { - return mySettings; + return m_settings; } @@ -260,18 +260,18 @@ void GlContext::Initialize() if (version) { // The beginning of the returned string is "major.minor" (this is standard) - mySettings.MajorVersion = version[0] - '0'; - mySettings.MinorVersion = version[2] - '0'; + m_settings.MajorVersion = version[0] - '0'; + m_settings.MinorVersion = version[2] - '0'; } else { // Can't get the version number, assume 2.0 - mySettings.MajorVersion = 2; - mySettings.MinorVersion = 0; + m_settings.MajorVersion = 2; + m_settings.MinorVersion = 0; } // Enable antialiasing if needed - if (mySettings.AntialiasingLevel > 0) + if (m_settings.AntialiasingLevel > 0) glEnable(GL_MULTISAMPLE_ARB); } diff --git a/src/SFML/Window/GlContext.hpp b/src/SFML/Window/GlContext.hpp index c08b0d39..e5b05462 100644 --- a/src/SFML/Window/GlContext.hpp +++ b/src/SFML/Window/GlContext.hpp @@ -216,7 +216,7 @@ protected : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - ContextSettings mySettings; ///< Creation settings of the context + ContextSettings m_settings; ///< Creation settings of the context private: diff --git a/src/SFML/Window/JoystickManager.cpp b/src/SFML/Window/JoystickManager.cpp index 322815f2..3f01acf3 100644 --- a/src/SFML/Window/JoystickManager.cpp +++ b/src/SFML/Window/JoystickManager.cpp @@ -43,14 +43,14 @@ JoystickManager& JoystickManager::GetInstance() //////////////////////////////////////////////////////////// const JoystickCaps& JoystickManager::GetCapabilities(unsigned int joystick) const { - return myJoysticks[joystick].Capabilities; + return m_joysticks[joystick].Capabilities; } //////////////////////////////////////////////////////////// const JoystickState& JoystickManager::GetState(unsigned int joystick) const { - return myJoysticks[joystick].State; + return m_joysticks[joystick].State; } @@ -59,7 +59,7 @@ void JoystickManager::Update() { for (int i = 0; i < Joystick::Count; ++i) { - Item& item = myJoysticks[i]; + Item& item = m_joysticks[i]; if (item.State.Connected) { @@ -101,8 +101,8 @@ JoystickManager::~JoystickManager() { for (int i = 0; i < Joystick::Count; ++i) { - if (myJoysticks[i].State.Connected) - myJoysticks[i].Joystick.Close(); + if (m_joysticks[i].State.Connected) + m_joysticks[i].Joystick.Close(); } } diff --git a/src/SFML/Window/JoystickManager.hpp b/src/SFML/Window/JoystickManager.hpp index 32141dd3..f6bbb2d5 100644 --- a/src/SFML/Window/JoystickManager.hpp +++ b/src/SFML/Window/JoystickManager.hpp @@ -107,7 +107,7 @@ private: //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - Item myJoysticks[Joystick::Count]; ///< Joysticks information and state + Item m_joysticks[Joystick::Count]; ///< Joysticks information and state }; } // namespace priv diff --git a/src/SFML/Window/Linux/GlxContext.cpp b/src/SFML/Window/Linux/GlxContext.cpp index de2d15bf..09de8c4f 100644 --- a/src/SFML/Window/Linux/GlxContext.cpp +++ b/src/SFML/Window/Linux/GlxContext.cpp @@ -39,23 +39,23 @@ namespace priv { //////////////////////////////////////////////////////////// GlxContext::GlxContext(GlxContext* shared) : -myWindow (0), -myContext (NULL), -myOwnsWindow(true) +m_window (0), +m_context (NULL), +m_ownsWindow(true) { // Open a connection with the X server - myDisplay = XOpenDisplay(NULL); + m_display = XOpenDisplay(NULL); // Create a dummy window (disabled and hidden) - int screen = DefaultScreen(myDisplay); - myWindow = XCreateWindow(myDisplay, - RootWindow(myDisplay, screen), + int screen = DefaultScreen(m_display); + m_window = XCreateWindow(m_display, + RootWindow(m_display, screen), 0, 0, 1, 1, 0, - DefaultDepth(myDisplay, screen), + DefaultDepth(m_display, screen), InputOutput, - DefaultVisual(myDisplay, screen), + DefaultVisual(m_display, screen), 0, NULL); // Create the context @@ -65,41 +65,41 @@ myOwnsWindow(true) //////////////////////////////////////////////////////////// GlxContext::GlxContext(GlxContext* shared, const ContextSettings& settings, const WindowImpl* owner, unsigned int bitsPerPixel) : -myWindow (0), -myContext (NULL), -myOwnsWindow(false) +m_window (0), +m_context (NULL), +m_ownsWindow(false) { // Use the same display as the owner window (important!) - myDisplay = static_cast(owner)->GetDisplay(); + m_display = static_cast(owner)->GetDisplay(); // Get the owner window and its device context - myWindow = static_cast< ::Window>(owner->GetSystemHandle()); + m_window = static_cast< ::Window>(owner->GetSystemHandle()); // Create the context - if (myWindow) + if (m_window) CreateContext(shared, bitsPerPixel, settings); } //////////////////////////////////////////////////////////// GlxContext::GlxContext(GlxContext* shared, const ContextSettings& settings, unsigned int width, unsigned int height) : -myWindow (0), -myContext (NULL), -myOwnsWindow(true) +m_window (0), +m_context (NULL), +m_ownsWindow(true) { // Open a connection with the X server - myDisplay = XOpenDisplay(NULL); + m_display = XOpenDisplay(NULL); // Create the hidden window - int screen = DefaultScreen(myDisplay); - myWindow = XCreateWindow(myDisplay, - RootWindow(myDisplay, screen), + int screen = DefaultScreen(m_display); + m_window = XCreateWindow(m_display, + RootWindow(m_display, screen), 0, 0, width, height, 0, - DefaultDepth(myDisplay, screen), + DefaultDepth(m_display, screen), InputOutput, - DefaultVisual(myDisplay, screen), + DefaultVisual(m_display, screen), 0, NULL); // Create the context @@ -111,38 +111,38 @@ myOwnsWindow(true) GlxContext::~GlxContext() { // Destroy the context - if (myContext) + if (m_context) { - if (glXGetCurrentContext() == myContext) - glXMakeCurrent(myDisplay, None, NULL); - glXDestroyContext(myDisplay, myContext); + if (glXGetCurrentContext() == m_context) + glXMakeCurrent(m_display, None, NULL); + glXDestroyContext(m_display, m_context); } // Destroy the window if we own it - if (myWindow && myOwnsWindow) + if (m_window && m_ownsWindow) { - XDestroyWindow(myDisplay, myWindow); - XFlush(myDisplay); + XDestroyWindow(m_display, m_window); + XFlush(m_display); } // Close the connection with the X server - if (myOwnsWindow) - XCloseDisplay(myDisplay); + if (m_ownsWindow) + XCloseDisplay(m_display); } //////////////////////////////////////////////////////////// bool GlxContext::MakeCurrent() { - return myContext && glXMakeCurrent(myDisplay, myWindow, myContext); + return m_context && glXMakeCurrent(m_display, m_window, m_context); } //////////////////////////////////////////////////////////// void GlxContext::Display() { - if (myWindow) - glXSwapBuffers(myDisplay, myWindow); + if (m_window) + glXSwapBuffers(m_display, m_window); } @@ -160,11 +160,11 @@ void GlxContext::SetVerticalSyncEnabled(bool enabled) void GlxContext::CreateContext(GlxContext* shared, unsigned int bitsPerPixel, const ContextSettings& settings) { // Save the creation settings - mySettings = settings; + m_settings = settings; // Get the attributes of the target window XWindowAttributes windowAttributes; - if (XGetWindowAttributes(myDisplay, myWindow, &windowAttributes) == 0) + if (XGetWindowAttributes(m_display, m_window, &windowAttributes) == 0) { Err() << "Failed to get the window attributes" << std::endl; return; @@ -174,11 +174,11 @@ void GlxContext::CreateContext(GlxContext* shared, unsigned int bitsPerPixel, co XVisualInfo tpl; tpl.depth = windowAttributes.depth; tpl.visualid = XVisualIDFromVisual(windowAttributes.visual); - tpl.screen = DefaultScreen(myDisplay); + tpl.screen = DefaultScreen(m_display); // Get all the visuals matching the template int nbVisuals = 0; - XVisualInfo* visuals = XGetVisualInfo(myDisplay, VisualDepthMask | VisualIDMask | VisualScreenMask, &tpl, &nbVisuals); + XVisualInfo* visuals = XGetVisualInfo(m_display, VisualDepthMask | VisualIDMask | VisualScreenMask, &tpl, &nbVisuals); if (!visuals || (nbVisuals == 0)) { if (visuals) @@ -194,16 +194,16 @@ void GlxContext::CreateContext(GlxContext* shared, unsigned int bitsPerPixel, co { // Get the current visual attributes int RGBA, doubleBuffer, red, green, blue, alpha, depth, stencil, multiSampling, samples; - glXGetConfig(myDisplay, &visuals[i], GLX_RGBA, &RGBA); - glXGetConfig(myDisplay, &visuals[i], GLX_DOUBLEBUFFER, &doubleBuffer); - glXGetConfig(myDisplay, &visuals[i], GLX_RED_SIZE, &red); - glXGetConfig(myDisplay, &visuals[i], GLX_GREEN_SIZE, &green); - glXGetConfig(myDisplay, &visuals[i], GLX_BLUE_SIZE, &blue); - glXGetConfig(myDisplay, &visuals[i], GLX_ALPHA_SIZE, &alpha); - glXGetConfig(myDisplay, &visuals[i], GLX_DEPTH_SIZE, &depth); - glXGetConfig(myDisplay, &visuals[i], GLX_STENCIL_SIZE, &stencil); - glXGetConfig(myDisplay, &visuals[i], GLX_SAMPLE_BUFFERS_ARB, &multiSampling); - glXGetConfig(myDisplay, &visuals[i], GLX_SAMPLES_ARB, &samples); + glXGetConfig(m_display, &visuals[i], GLX_RGBA, &RGBA); + glXGetConfig(m_display, &visuals[i], GLX_DOUBLEBUFFER, &doubleBuffer); + glXGetConfig(m_display, &visuals[i], GLX_RED_SIZE, &red); + glXGetConfig(m_display, &visuals[i], GLX_GREEN_SIZE, &green); + glXGetConfig(m_display, &visuals[i], GLX_BLUE_SIZE, &blue); + glXGetConfig(m_display, &visuals[i], GLX_ALPHA_SIZE, &alpha); + glXGetConfig(m_display, &visuals[i], GLX_DEPTH_SIZE, &depth); + glXGetConfig(m_display, &visuals[i], GLX_STENCIL_SIZE, &stencil); + glXGetConfig(m_display, &visuals[i], GLX_SAMPLE_BUFFERS_ARB, &multiSampling); + glXGetConfig(m_display, &visuals[i], GLX_SAMPLES_ARB, &samples); // First check the mandatory parameters if ((RGBA == 0) || (doubleBuffer == 0)) @@ -211,7 +211,7 @@ void GlxContext::CreateContext(GlxContext* shared, unsigned int bitsPerPixel, co // Evaluate the current configuration int color = red + green + blue + alpha; - int score = EvaluateFormat(bitsPerPixel, mySettings, color, depth, stencil, multiSampling ? samples : 0); + int score = EvaluateFormat(bitsPerPixel, m_settings, color, depth, stencil, multiSampling ? samples : 0); // Keep it if it's better than the current best if (score < bestScore) @@ -229,28 +229,28 @@ void GlxContext::CreateContext(GlxContext* shared, unsigned int bitsPerPixel, co } // Get the context to share display lists with - GLXContext toShare = shared ? shared->myContext : NULL; + GLXContext toShare = shared ? shared->m_context : NULL; // Create the OpenGL context -- first try context versions >= 3.0 if it is requested (they require special code) - while (!myContext && (mySettings.MajorVersion >= 3)) + while (!m_context && (m_settings.MajorVersion >= 3)) { const GLubyte* name = reinterpret_cast("glXCreateContextAttribsARB"); PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribsARB = reinterpret_cast(glXGetProcAddress(name)); if (glXCreateContextAttribsARB) { int nbConfigs = 0; - GLXFBConfig* configs = glXChooseFBConfig(myDisplay, DefaultScreen(myDisplay), NULL, &nbConfigs); + GLXFBConfig* configs = glXChooseFBConfig(m_display, DefaultScreen(m_display), NULL, &nbConfigs); if (configs && nbConfigs) { // Create the context int attributes[] = { - GLX_CONTEXT_MAJOR_VERSION_ARB, mySettings.MajorVersion, - GLX_CONTEXT_MINOR_VERSION_ARB, mySettings.MinorVersion, + GLX_CONTEXT_MAJOR_VERSION_ARB, m_settings.MajorVersion, + GLX_CONTEXT_MINOR_VERSION_ARB, m_settings.MinorVersion, GLX_CONTEXT_PROFILE_MASK_ARB, GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB, 0, 0 }; - myContext = glXCreateContextAttribsARB(myDisplay, configs[0], toShare, true, attributes); + m_context = glXCreateContextAttribsARB(m_display, configs[0], toShare, true, attributes); } if (configs) @@ -259,31 +259,31 @@ void GlxContext::CreateContext(GlxContext* shared, unsigned int bitsPerPixel, co // If we couldn't create the context, lower the version number and try again -- stop at 3.0 // Invalid version numbers will be generated by this algorithm (like 3.9), but we really don't care - if (!myContext) + if (!m_context) { - if (mySettings.MinorVersion > 0) + if (m_settings.MinorVersion > 0) { // If the minor version is not 0, we decrease it and try again - mySettings.MinorVersion--; + m_settings.MinorVersion--; } else { // If the minor version is 0, we decrease the major version - mySettings.MajorVersion--; - mySettings.MinorVersion = 9; + m_settings.MajorVersion--; + m_settings.MinorVersion = 9; } } } // If the OpenGL >= 3.0 context failed or if we don't want one, create a regular OpenGL 1.x/2.x context - if (!myContext) + if (!m_context) { // set the context version to 2.0 (arbitrary) - mySettings.MajorVersion = 2; - mySettings.MinorVersion = 0; + m_settings.MajorVersion = 2; + m_settings.MinorVersion = 0; - myContext = glXCreateContext(myDisplay, bestVisual, toShare, true); - if (!myContext) + m_context = glXCreateContext(m_display, bestVisual, toShare, true); + if (!m_context) { Err() << "Failed to create an OpenGL context for this window" << std::endl; return; @@ -292,18 +292,18 @@ void GlxContext::CreateContext(GlxContext* shared, unsigned int bitsPerPixel, co // Update the creation settings from the chosen format int depth, stencil, multiSampling, samples; - glXGetConfig(myDisplay, bestVisual, GLX_DEPTH_SIZE, &depth); - glXGetConfig(myDisplay, bestVisual, GLX_STENCIL_SIZE, &stencil); - glXGetConfig(myDisplay, bestVisual, GLX_SAMPLE_BUFFERS_ARB, &multiSampling); - glXGetConfig(myDisplay, bestVisual, GLX_SAMPLES_ARB, &samples); - mySettings.DepthBits = static_cast(depth); - mySettings.StencilBits = static_cast(stencil); - mySettings.AntialiasingLevel = multiSampling ? samples : 0; + glXGetConfig(m_display, bestVisual, GLX_DEPTH_SIZE, &depth); + glXGetConfig(m_display, bestVisual, GLX_STENCIL_SIZE, &stencil); + glXGetConfig(m_display, bestVisual, GLX_SAMPLE_BUFFERS_ARB, &multiSampling); + glXGetConfig(m_display, bestVisual, GLX_SAMPLES_ARB, &samples); + m_settings.DepthBits = static_cast(depth); + m_settings.StencilBits = static_cast(stencil); + m_settings.AntialiasingLevel = multiSampling ? samples : 0; // Change the target window's colormap so that it matches the context's one - ::Window root = RootWindow(myDisplay, DefaultScreen(myDisplay)); - Colormap colorMap = XCreateColormap(myDisplay, root, bestVisual->visual, AllocNone); - XSetWindowColormap(myDisplay, myWindow, colorMap); + ::Window root = RootWindow(m_display, DefaultScreen(m_display)); + Colormap colorMap = XCreateColormap(m_display, root, bestVisual->visual, AllocNone); + XSetWindowColormap(m_display, m_window, colorMap); // Free the temporary visuals array XFree(visuals); diff --git a/src/SFML/Window/Linux/GlxContext.hpp b/src/SFML/Window/Linux/GlxContext.hpp index b6a7ba8e..630177b5 100644 --- a/src/SFML/Window/Linux/GlxContext.hpp +++ b/src/SFML/Window/Linux/GlxContext.hpp @@ -124,10 +124,10 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - ::Display* myDisplay; ///< Connection to the X server - ::Window myWindow; ///< Window to which the context is attached - GLXContext myContext; ///< OpenGL context - bool myOwnsWindow; ///< Do we own the window associated to the context? + ::Display* m_display; ///< Connection to the X server + ::Window m_window; ///< Window to which the context is attached + GLXContext m_context; ///< OpenGL context + bool m_ownsWindow; ///< Do we own the window associated to the context? }; } // namespace priv diff --git a/src/SFML/Window/Linux/JoystickImpl.cpp b/src/SFML/Window/Linux/JoystickImpl.cpp index ad03dcfa..53c7dae6 100644 --- a/src/SFML/Window/Linux/JoystickImpl.cpp +++ b/src/SFML/Window/Linux/JoystickImpl.cpp @@ -53,17 +53,17 @@ bool JoystickImpl::Open(unsigned int index) std::ostringstream oss; oss << "/dev/input/js" << index; - myFile = open(oss.str().c_str(), O_RDONLY); - if (myFile > 0) + m_file = open(oss.str().c_str(), O_RDONLY); + if (m_file > 0) { // Use non-blocking mode - fcntl(myFile, F_SETFL, O_NONBLOCK); + fcntl(m_file, F_SETFL, O_NONBLOCK); // Retrieve the axes mapping - ioctl(myFile, JSIOCGAXMAP, myMapping); + ioctl(m_file, JSIOCGAXMAP, m_mapping); // Reset the joystick state - myState = JoystickState(); + m_state = JoystickState(); return true; } @@ -77,7 +77,7 @@ bool JoystickImpl::Open(unsigned int index) //////////////////////////////////////////////////////////// void JoystickImpl::Close() { - close(myFile); + close(m_file); } @@ -88,17 +88,17 @@ JoystickCaps JoystickImpl::GetCapabilities() const // Get the number of buttons char buttonCount; - ioctl(myFile, JSIOCGBUTTONS, &buttonCount); + ioctl(m_file, JSIOCGBUTTONS, &buttonCount); caps.ButtonCount = buttonCount; if (caps.ButtonCount > Joystick::ButtonCount) caps.ButtonCount = Joystick::ButtonCount; // Get the supported axes char axesCount; - ioctl(myFile, JSIOCGAXES, &axesCount); + ioctl(m_file, JSIOCGAXES, &axesCount); for (int i = 0; i < axesCount; ++i) { - switch (myMapping[i]) + switch (m_mapping[i]) { case ABS_X : caps.Axes[Joystick::X] = true; break; case ABS_Y : caps.Axes[Joystick::Y] = true; break; @@ -123,7 +123,7 @@ JoystickState JoystickImpl::JoystickImpl::Update() { // pop events from the joystick file js_event joyState; - while (read(myFile, &joyState, sizeof(joyState)) > 0) + while (read(m_file, &joyState, sizeof(joyState)) > 0) { switch (joyState.type & ~JS_EVENT_INIT) { @@ -131,18 +131,18 @@ JoystickState JoystickImpl::JoystickImpl::Update() case JS_EVENT_AXIS : { float value = joyState.value * 100.f / 32767.f; - switch (myMapping[joyState.number]) + switch (m_mapping[joyState.number]) { - case ABS_X : myState.Axes[Joystick::X] = value; break; - case ABS_Y : myState.Axes[Joystick::Y] = value; break; + case ABS_X : m_state.Axes[Joystick::X] = value; break; + case ABS_Y : m_state.Axes[Joystick::Y] = value; break; case ABS_Z : - case ABS_THROTTLE : myState.Axes[Joystick::Z] = value; break; + case ABS_THROTTLE : m_state.Axes[Joystick::Z] = value; break; case ABS_RZ: - case ABS_RUDDER: myState.Axes[Joystick::R] = value; break; - case ABS_RX : myState.Axes[Joystick::U] = value; break; - case ABS_RY : myState.Axes[Joystick::V] = value; break; - case ABS_HAT0X : myState.Axes[Joystick::PovX] = value; break; - case ABS_HAT0Y : myState.Axes[Joystick::PovY] = value; break; + case ABS_RUDDER: m_state.Axes[Joystick::R] = value; break; + case ABS_RX : m_state.Axes[Joystick::U] = value; break; + case ABS_RY : m_state.Axes[Joystick::V] = value; break; + case ABS_HAT0X : m_state.Axes[Joystick::PovX] = value; break; + case ABS_HAT0Y : m_state.Axes[Joystick::PovY] = value; break; default : break; } break; @@ -152,16 +152,16 @@ JoystickState JoystickImpl::JoystickImpl::Update() case JS_EVENT_BUTTON : { if (joyState.number < Joystick::ButtonCount) - myState.Buttons[joyState.number] = (joyState.value != 0); + m_state.Buttons[joyState.number] = (joyState.value != 0); break; } } } // Check the connection state of the joystick (read() fails with an error != EGAIN if it's no longer connected) - myState.Connected = (errno == EAGAIN); + m_state.Connected = (errno == EAGAIN); - return myState; + return m_state; } } // namespace priv diff --git a/src/SFML/Window/Linux/JoystickImpl.hpp b/src/SFML/Window/Linux/JoystickImpl.hpp index c3d64f59..34b3af17 100644 --- a/src/SFML/Window/Linux/JoystickImpl.hpp +++ b/src/SFML/Window/Linux/JoystickImpl.hpp @@ -96,9 +96,9 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - int myFile; ///< File descriptor of the joystick - char myMapping[ABS_MAX + 1]; ///< Axes mapping (index to axis id) - JoystickState myState; ///< Current state of the joystick + int m_file; ///< File descriptor of the joystick + char m_mapping[ABS_MAX + 1]; ///< Axes mapping (index to axis id) + JoystickState m_state; ///< Current state of the joystick }; } // namespace priv diff --git a/src/SFML/Window/Linux/WindowImplX11.cpp b/src/SFML/Window/Linux/WindowImplX11.cpp index a184f0a9..52f278df 100644 --- a/src/SFML/Window/Linux/WindowImplX11.cpp +++ b/src/SFML/Window/Linux/WindowImplX11.cpp @@ -62,26 +62,26 @@ namespace priv { //////////////////////////////////////////////////////////// WindowImplX11::WindowImplX11(WindowHandle handle) : -myWindow (0), -myInputMethod (NULL), -myInputContext(NULL), -myIsExternal (true), -myAtomClose (0), -myOldVideoMode(-1), -myHiddenCursor(0), -myKeyRepeat (true) +m_window (0), +m_inputMethod (NULL), +m_inputContext(NULL), +m_isExternal (true), +m_atomClose (0), +m_oldVideoMode(-1), +m_hiddenCursor(0), +m_keyRepeat (true) { // Open a connection with the X server - myDisplay = XOpenDisplay(NULL); - myScreen = DefaultScreen(myDisplay); + m_display = XOpenDisplay(NULL); + m_screen = DefaultScreen(m_display); // Save the window handle - myWindow = handle; + m_window = handle; - if (myWindow) + if (m_window) { // Make sure the window is listening to all the requiered events - XSelectInput(myDisplay, myWindow, eventMask & ~ButtonPressMask); + XSelectInput(m_display, m_window, eventMask & ~ButtonPressMask); // Do some common initializations Initialize(); @@ -91,26 +91,26 @@ myKeyRepeat (true) //////////////////////////////////////////////////////////// WindowImplX11::WindowImplX11(VideoMode mode, const std::string& title, unsigned long style) : -myWindow (0), -myInputMethod (NULL), -myInputContext(NULL), -myIsExternal (false), -myAtomClose (0), -myOldVideoMode(-1), -myHiddenCursor(0), -myKeyRepeat (true) +m_window (0), +m_inputMethod (NULL), +m_inputContext(NULL), +m_isExternal (false), +m_atomClose (0), +m_oldVideoMode(-1), +m_hiddenCursor(0), +m_keyRepeat (true) { // Open a connection with the X server - myDisplay = XOpenDisplay(NULL); - myScreen = DefaultScreen(myDisplay); + m_display = XOpenDisplay(NULL); + m_screen = DefaultScreen(m_display); // Compute position and size int left, top; bool fullscreen = (style & Style::Fullscreen) != 0; if (!fullscreen) { - left = (DisplayWidth(myDisplay, myScreen) - mode.Width) / 2; - top = (DisplayHeight(myDisplay, myScreen) - mode.Height) / 2; + left = (DisplayWidth(m_display, m_screen) - mode.Width) / 2; + top = (DisplayHeight(m_display, m_screen) - mode.Height) / 2; } else { @@ -130,16 +130,16 @@ myKeyRepeat (true) attributes.override_redirect = fullscreen; // Create the window - myWindow = XCreateWindow(myDisplay, - RootWindow(myDisplay, myScreen), + m_window = XCreateWindow(m_display, + RootWindow(m_display, m_screen), left, top, width, height, 0, - DefaultDepth(myDisplay, myScreen), + DefaultDepth(m_display, m_screen), InputOutput, - DefaultVisual(myDisplay, myScreen), + DefaultVisual(m_display, m_screen), CWEventMask | CWOverrideRedirect, &attributes); - if (!myWindow) + if (!m_window) { Err() << "Failed to create window" << std::endl; return; @@ -151,7 +151,7 @@ myKeyRepeat (true) // Set the window's style (tell the windows manager to change our window's decorations and functions according to the requested style) if (!fullscreen) { - Atom WMHintsAtom = XInternAtom(myDisplay, "_MOTIF_WM_HINTS", false); + Atom WMHintsAtom = XInternAtom(m_display, "_MOTIF_WM_HINTS", false); if (WMHintsAtom) { static const unsigned long MWM_HINTS_FUNCTIONS = 1 << 0; @@ -203,7 +203,7 @@ myKeyRepeat (true) } const unsigned char* ptr = reinterpret_cast(&hints); - XChangeProperty(myDisplay, myWindow, WMHintsAtom, WMHintsAtom, 32, PropModeReplace, ptr, 5); + XChangeProperty(m_display, m_window, WMHintsAtom, WMHintsAtom, 32, PropModeReplace, ptr, 5); } // This is a hack to force some windows managers to disable resizing @@ -213,7 +213,7 @@ myKeyRepeat (true) sizeHints.flags = PMinSize | PMaxSize; sizeHints.min_width = sizeHints.max_width = width; sizeHints.min_height = sizeHints.max_height = height; - XSetWMNormalHints(myDisplay, myWindow, &sizeHints); + XSetWMNormalHints(m_display, m_window, &sizeHints); } } @@ -223,8 +223,8 @@ myKeyRepeat (true) // In fullscreen mode, we must grab keyboard and mouse inputs if (fullscreen) { - XGrabPointer(myDisplay, myWindow, true, 0, GrabModeAsync, GrabModeAsync, myWindow, None, CurrentTime); - XGrabKeyboard(myDisplay, myWindow, true, GrabModeAsync, GrabModeAsync, CurrentTime); + XGrabPointer(m_display, m_window, true, 0, GrabModeAsync, GrabModeAsync, m_window, None, CurrentTime); + XGrabKeyboard(m_display, m_window, true, GrabModeAsync, GrabModeAsync, CurrentTime); } } @@ -236,40 +236,40 @@ WindowImplX11::~WindowImplX11() Cleanup(); // Destroy the cursor - if (myHiddenCursor) - XFreeCursor(myDisplay, myHiddenCursor); + if (m_hiddenCursor) + XFreeCursor(m_display, m_hiddenCursor); // Destroy the input context - if (myInputContext) - XDestroyIC(myInputContext); + if (m_inputContext) + XDestroyIC(m_inputContext); // Destroy the window - if (myWindow && !myIsExternal) + if (m_window && !m_isExternal) { - XDestroyWindow(myDisplay, myWindow); - XFlush(myDisplay); + XDestroyWindow(m_display, m_window); + XFlush(m_display); } // Close the input method - if (myInputMethod) - XCloseIM(myInputMethod); + if (m_inputMethod) + XCloseIM(m_inputMethod); // Close the connection with the X server - XCloseDisplay(myDisplay); + XCloseDisplay(m_display); } //////////////////////////////////////////////////////////// ::Display* WindowImplX11::GetDisplay() const { - return myDisplay; + return m_display; } //////////////////////////////////////////////////////////// WindowHandle WindowImplX11::GetSystemHandle() const { - return myWindow; + return m_window; } @@ -277,7 +277,7 @@ WindowHandle WindowImplX11::GetSystemHandle() const void WindowImplX11::ProcessEvents() { XEvent event; - while (XCheckIfEvent(myDisplay, &event, &CheckEvent, reinterpret_cast(myWindow))) + while (XCheckIfEvent(m_display, &event, &CheckEvent, reinterpret_cast(m_window))) { ProcessEvent(event); } @@ -288,7 +288,7 @@ void WindowImplX11::ProcessEvents() Vector2i WindowImplX11::GetPosition() const { XWindowAttributes attributes; - XGetWindowAttributes(myDisplay, myWindow, &attributes); + XGetWindowAttributes(m_display, m_window, &attributes); return Vector2i(attributes.x, attributes.y); } @@ -296,8 +296,8 @@ Vector2i WindowImplX11::GetPosition() const //////////////////////////////////////////////////////////// void WindowImplX11::SetPosition(const Vector2i& position) { - XMoveWindow(myDisplay, myWindow, position.x, position.y); - XFlush(myDisplay); + XMoveWindow(m_display, m_window, position.x, position.y); + XFlush(m_display); } @@ -305,7 +305,7 @@ void WindowImplX11::SetPosition(const Vector2i& position) Vector2u WindowImplX11::GetSize() const { XWindowAttributes attributes; - XGetWindowAttributes(myDisplay, myWindow, &attributes); + XGetWindowAttributes(m_display, m_window, &attributes); return Vector2u(attributes.width, attributes.height); } @@ -313,15 +313,15 @@ Vector2u WindowImplX11::GetSize() const //////////////////////////////////////////////////////////// void WindowImplX11::SetSize(const Vector2u& size) { - XResizeWindow(myDisplay, myWindow, size.x, size.y); - XFlush(myDisplay); + XResizeWindow(m_display, m_window, size.x, size.y); + XFlush(m_display); } //////////////////////////////////////////////////////////// void WindowImplX11::SetTitle(const std::string& title) { - XStoreName(myDisplay, myWindow, title.c_str()); + XStoreName(m_display, m_window, title.c_str()); } @@ -340,19 +340,19 @@ void WindowImplX11::SetIcon(unsigned int width, unsigned int height, const Uint8 } // Create the icon pixmap - Visual* defVisual = DefaultVisual(myDisplay, myScreen); - unsigned int defDepth = DefaultDepth(myDisplay, myScreen); - XImage* iconImage = XCreateImage(myDisplay, defVisual, defDepth, ZPixmap, 0, (char*)iconPixels, width, height, 32, 0); + Visual* defVisual = DefaultVisual(m_display, m_screen); + unsigned int defDepth = DefaultDepth(m_display, m_screen); + XImage* iconImage = XCreateImage(m_display, defVisual, defDepth, ZPixmap, 0, (char*)iconPixels, width, height, 32, 0); if (!iconImage) { Err() << "Failed to set the window's icon" << std::endl; return; } - Pixmap iconPixmap = XCreatePixmap(myDisplay, RootWindow(myDisplay, myScreen), width, height, defDepth); + Pixmap iconPixmap = XCreatePixmap(m_display, RootWindow(m_display, m_screen), width, height, defDepth); XGCValues values; - GC iconGC = XCreateGC(myDisplay, iconPixmap, 0, &values); - XPutImage(myDisplay, iconPixmap, iconGC, iconImage, 0, 0, 0, 0, width, height); - XFreeGC(myDisplay, iconGC); + GC iconGC = XCreateGC(m_display, iconPixmap, 0, &values); + XPutImage(m_display, iconPixmap, iconGC, iconImage, 0, 0, 0, 0, width, height); + XFreeGC(m_display, iconGC); XDestroyImage(iconImage); // Create the mask pixmap (must have 1 bit depth) @@ -372,17 +372,17 @@ void WindowImplX11::SetIcon(unsigned int width, unsigned int height, const Uint8 } } } - Pixmap maskPixmap = XCreatePixmapFromBitmapData(myDisplay, myWindow, (char*)&maskPixels[0], width, height, 1, 0, 1); + Pixmap maskPixmap = XCreatePixmapFromBitmapData(m_display, m_window, (char*)&maskPixels[0], width, height, 1, 0, 1); // Send our new icon to the window through the WMHints XWMHints* hints = XAllocWMHints(); hints->flags = IconPixmapHint | IconMaskHint; hints->icon_pixmap = iconPixmap; hints->icon_mask = maskPixmap; - XSetWMHints(myDisplay, myWindow, hints); + XSetWMHints(m_display, m_window, hints); XFree(hints); - XFlush(myDisplay); + XFlush(m_display); } @@ -390,26 +390,26 @@ void WindowImplX11::SetIcon(unsigned int width, unsigned int height, const Uint8 void WindowImplX11::SetVisible(bool visible) { if (visible) - XMapWindow(myDisplay, myWindow); + XMapWindow(m_display, m_window); else - XUnmapWindow(myDisplay, myWindow); + XUnmapWindow(m_display, m_window); - XFlush(myDisplay); + XFlush(m_display); } //////////////////////////////////////////////////////////// void WindowImplX11::SetMouseCursorVisible(bool visible) { - XDefineCursor(myDisplay, myWindow, visible ? None : myHiddenCursor); - XFlush(myDisplay); + XDefineCursor(m_display, m_window, visible ? None : m_hiddenCursor); + XFlush(m_display); } //////////////////////////////////////////////////////////// void WindowImplX11::SetKeyRepeatEnabled(bool enabled) { - myKeyRepeat = enabled; + m_keyRepeat = enabled; } @@ -418,15 +418,15 @@ void WindowImplX11::SwitchToFullscreen(const VideoMode& mode) { // Check if the XRandR extension is present int version; - if (XQueryExtension(myDisplay, "RANDR", &version, &version, &version)) + if (XQueryExtension(m_display, "RANDR", &version, &version, &version)) { // Get the current configuration - XRRScreenConfiguration* config = XRRGetScreenInfo(myDisplay, RootWindow(myDisplay, myScreen)); + XRRScreenConfiguration* config = XRRGetScreenInfo(m_display, RootWindow(m_display, m_screen)); if (config) { // Get the current rotation Rotation currentRotation; - myOldVideoMode = XRRConfigCurrentConfiguration(config, ¤tRotation); + m_oldVideoMode = XRRConfigCurrentConfiguration(config, ¤tRotation); // Get the available screen sizes int nbSizes; @@ -439,7 +439,7 @@ void WindowImplX11::SwitchToFullscreen(const VideoMode& mode) if ((sizes[i].width == static_cast(mode.Width)) && (sizes[i].height == static_cast(mode.Height))) { // Switch to fullscreen mode - XRRSetScreenConfig(myDisplay, config, RootWindow(myDisplay, myScreen), i, currentRotation, CurrentTime); + XRRSetScreenConfig(m_display, config, RootWindow(m_display, m_screen), i, currentRotation, CurrentTime); // Set "this" as the current fullscreen window fullscreenWindow = this; @@ -469,38 +469,38 @@ void WindowImplX11::SwitchToFullscreen(const VideoMode& mode) void WindowImplX11::Initialize() { // Make sure the "last key release" is initialized with invalid values - myLastKeyReleaseEvent.type = -1; + m_lastKeyReleaseEvent.type = -1; // Get the atom defining the close event - myAtomClose = XInternAtom(myDisplay, "WM_DELETE_WINDOW", false); - XSetWMProtocols(myDisplay, myWindow, &myAtomClose, 1); + m_atomClose = XInternAtom(m_display, "WM_DELETE_WINDOW", false); + XSetWMProtocols(m_display, m_window, &m_atomClose, 1); // Create the input context - myInputMethod = XOpenIM(myDisplay, NULL, NULL, NULL); - if (myInputMethod) + m_inputMethod = XOpenIM(m_display, NULL, NULL, NULL); + if (m_inputMethod) { - myInputContext = XCreateIC(myInputMethod, - XNClientWindow, myWindow, - XNFocusWindow, myWindow, + m_inputContext = XCreateIC(m_inputMethod, + XNClientWindow, m_window, + XNFocusWindow, m_window, XNInputStyle, XIMPreeditNothing | XIMStatusNothing, NULL); } else { - myInputContext = NULL; + m_inputContext = NULL; } - if (!myInputContext) + if (!m_inputContext) Err() << "Failed to create input context for window -- TextEntered event won't be able to return unicode" << std::endl; // Show the window - XMapWindow(myDisplay, myWindow); - XFlush(myDisplay); + XMapWindow(m_display, m_window); + XFlush(m_display); // Create the hiden cursor CreateHiddenCursor(); // Flush the commands queue - XFlush(myDisplay); + XFlush(m_display); } @@ -508,19 +508,19 @@ void WindowImplX11::Initialize() void WindowImplX11::CreateHiddenCursor() { // Create the cursor's pixmap (1x1 pixels) - Pixmap cursorPixmap = XCreatePixmap(myDisplay, myWindow, 1, 1, 1); - GC graphicsContext = XCreateGC(myDisplay, cursorPixmap, 0, NULL); - XDrawPoint(myDisplay, cursorPixmap, graphicsContext, 0, 0); - XFreeGC(myDisplay, graphicsContext); + Pixmap cursorPixmap = XCreatePixmap(m_display, m_window, 1, 1, 1); + GC graphicsContext = XCreateGC(m_display, cursorPixmap, 0, NULL); + XDrawPoint(m_display, cursorPixmap, graphicsContext, 0, 0); + XFreeGC(m_display, graphicsContext); // Create the cursor, using the pixmap as both the shape and the mask of the cursor XColor color; color.flags = DoRed | DoGreen | DoBlue; color.red = color.blue = color.green = 0; - myHiddenCursor = XCreatePixmapCursor(myDisplay, cursorPixmap, cursorPixmap, &color, &color, 0, 0); + m_hiddenCursor = XCreatePixmapCursor(m_display, cursorPixmap, cursorPixmap, &color, &color, 0, 0); // We don't need the pixmap any longer, free it - XFreePixmap(myDisplay, cursorPixmap); + XFreePixmap(m_display, cursorPixmap); } @@ -531,7 +531,7 @@ void WindowImplX11::Cleanup() if (fullscreenWindow == this) { // Get current screen info - XRRScreenConfiguration* config = XRRGetScreenInfo(myDisplay, RootWindow(myDisplay, myScreen)); + XRRScreenConfiguration* config = XRRGetScreenInfo(m_display, RootWindow(m_display, m_screen)); if (config) { // Get the current rotation @@ -539,7 +539,7 @@ void WindowImplX11::Cleanup() XRRConfigCurrentConfiguration(config, ¤tRotation); // Reset the video mode - XRRSetScreenConfig(myDisplay, config, RootWindow(myDisplay, myScreen), myOldVideoMode, currentRotation, CurrentTime); + XRRSetScreenConfig(m_display, config, RootWindow(m_display, m_screen), m_oldVideoMode, currentRotation, CurrentTime); // Free the configuration instance XRRFreeScreenConfigInfo(config); @@ -575,20 +575,20 @@ bool WindowImplX11::ProcessEvent(XEvent windowEvent) // - KeyPress events are a little bit harder to handle: they depend on the EnableKeyRepeat state, // and we need to properly forward the first one. char keys[32]; - XQueryKeymap(myDisplay, keys); + XQueryKeymap(m_display, keys); if (keys[windowEvent.xkey.keycode / 8] & (1 << (windowEvent.xkey.keycode % 8))) { // KeyRelease event + key down = repeated event --> discard if (windowEvent.type == KeyRelease) { - myLastKeyReleaseEvent = windowEvent; + m_lastKeyReleaseEvent = windowEvent; return false; } // KeyPress event + key repeat disabled + matching KeyRelease event = repeated event --> discard - if ((windowEvent.type == KeyPress) && !myKeyRepeat && - (myLastKeyReleaseEvent.xkey.keycode == windowEvent.xkey.keycode) && - (myLastKeyReleaseEvent.xkey.time == windowEvent.xkey.time)) + if ((windowEvent.type == KeyPress) && !m_keyRepeat && + (m_lastKeyReleaseEvent.xkey.keycode == windowEvent.xkey.keycode) && + (m_lastKeyReleaseEvent.xkey.time == windowEvent.xkey.time)) { return false; } @@ -611,8 +611,8 @@ bool WindowImplX11::ProcessEvent(XEvent windowEvent) case FocusIn : { // Update the input context - if (myInputContext) - XSetICFocus(myInputContext); + if (m_inputContext) + XSetICFocus(m_inputContext); Event event; event.Type = Event::GainedFocus; @@ -624,8 +624,8 @@ bool WindowImplX11::ProcessEvent(XEvent windowEvent) case FocusOut : { // Update the input context - if (myInputContext) - XUnsetICFocus(myInputContext); + if (m_inputContext) + XUnsetICFocus(m_inputContext); Event event; event.Type = Event::LostFocus; @@ -647,7 +647,7 @@ bool WindowImplX11::ProcessEvent(XEvent windowEvent) // Close event case ClientMessage : { - if ((windowEvent.xclient.format == 32) && (windowEvent.xclient.data.l[0]) == static_cast(myAtomClose)) + if ((windowEvent.xclient.format == 32) && (windowEvent.xclient.data.l[0]) == static_cast(m_atomClose)) { Event event; event.Type = Event::Closed; @@ -680,11 +680,11 @@ bool WindowImplX11::ProcessEvent(XEvent windowEvent) if (!XFilterEvent(&windowEvent, None)) { #ifdef X_HAVE_UTF8_STRING - if (myInputContext) + if (m_inputContext) { Status status; Uint8 keyBuffer[16]; - int length = Xutf8LookupString(myInputContext, &windowEvent.xkey, reinterpret_cast(keyBuffer), sizeof(keyBuffer), NULL, &status); + int length = Xutf8LookupString(m_inputContext, &windowEvent.xkey, reinterpret_cast(keyBuffer), sizeof(keyBuffer), NULL, &status); if (length > 0) { Uint32 unicode = 0; diff --git a/src/SFML/Window/Linux/WindowImplX11.hpp b/src/SFML/Window/Linux/WindowImplX11.hpp index e8d7e7ae..6bd61c0a 100644 --- a/src/SFML/Window/Linux/WindowImplX11.hpp +++ b/src/SFML/Window/Linux/WindowImplX11.hpp @@ -222,17 +222,17 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - ::Window myWindow; ///< X11 structure defining our window - ::Display* myDisplay; ///< Pointer to the display - int myScreen; ///< Screen identifier - XIM myInputMethod; ///< Input method linked to the X display - XIC myInputContext; ///< Input context used to get unicode input in our window - bool myIsExternal; ///< Tell whether the window has been created externally or by SFML - Atom myAtomClose; ///< Atom used to identify the close event - int myOldVideoMode; ///< Video mode in use before we switch to fullscreen - Cursor myHiddenCursor; ///< As X11 doesn't provide cursor hidding, we must create a transparent one - bool myKeyRepeat; ///< Is the KeyRepeat feature enabled ? - XEvent myLastKeyReleaseEvent; ///< Last key release event we received (needed for discarding repeated key events) + ::Window m_window; ///< X11 structure defining our window + ::Display* m_display; ///< Pointer to the display + int m_screen; ///< Screen identifier + XIM m_inputMethod; ///< Input method linked to the X display + XIC m_inputContext; ///< Input context used to get unicode input in our window + bool m_isExternal; ///< Tell whether the window has been created externally or by SFML + Atom m_atomClose; ///< Atom used to identify the close event + int m_oldVideoMode; ///< Video mode in use before we switch to fullscreen + Cursor m_hiddenCursor; ///< As X11 doesn't provide cursor hidding, we must create a transparent one + bool m_keyRepeat; ///< Is the KeyRepeat feature enabled ? + XEvent m_lastKeyReleaseEvent; ///< Last key release event we received (needed for discarding repeated key events) }; } // namespace priv diff --git a/src/SFML/Window/Win32/JoystickImpl.cpp b/src/SFML/Window/Win32/JoystickImpl.cpp index 862e488f..5c8d1c3c 100644 --- a/src/SFML/Window/Win32/JoystickImpl.cpp +++ b/src/SFML/Window/Win32/JoystickImpl.cpp @@ -49,10 +49,10 @@ bool JoystickImpl::IsConnected(unsigned int index) bool JoystickImpl::Open(unsigned int index) { // No explicit "open" action is required - myIndex = JOYSTICKID1 + index; + m_index = JOYSTICKID1 + index; // Store the joystick capabilities - return joyGetDevCaps(myIndex, &myCaps, sizeof(myCaps)) == JOYERR_NOERROR; + return joyGetDevCaps(m_index, &m_caps, sizeof(m_caps)) == JOYERR_NOERROR; } @@ -68,18 +68,18 @@ JoystickCaps JoystickImpl::GetCapabilities() const { JoystickCaps caps; - caps.ButtonCount = myCaps.wNumButtons; + caps.ButtonCount = m_caps.wNumButtons; if (caps.ButtonCount > Joystick::ButtonCount) caps.ButtonCount = Joystick::ButtonCount; caps.Axes[Joystick::X] = true; caps.Axes[Joystick::Y] = true; - caps.Axes[Joystick::Z] = (myCaps.wCaps & JOYCAPS_HASZ) != 0; - caps.Axes[Joystick::R] = (myCaps.wCaps & JOYCAPS_HASR) != 0; - caps.Axes[Joystick::U] = (myCaps.wCaps & JOYCAPS_HASU) != 0; - caps.Axes[Joystick::V] = (myCaps.wCaps & JOYCAPS_HASV) != 0; - caps.Axes[Joystick::PovX] = (myCaps.wCaps & JOYCAPS_HASPOV) != 0; - caps.Axes[Joystick::PovY] = (myCaps.wCaps & JOYCAPS_HASPOV) != 0; + caps.Axes[Joystick::Z] = (m_caps.wCaps & JOYCAPS_HASZ) != 0; + caps.Axes[Joystick::R] = (m_caps.wCaps & JOYCAPS_HASR) != 0; + caps.Axes[Joystick::U] = (m_caps.wCaps & JOYCAPS_HASU) != 0; + caps.Axes[Joystick::V] = (m_caps.wCaps & JOYCAPS_HASV) != 0; + caps.Axes[Joystick::PovX] = (m_caps.wCaps & JOYCAPS_HASPOV) != 0; + caps.Axes[Joystick::PovY] = (m_caps.wCaps & JOYCAPS_HASPOV) != 0; return caps; } @@ -93,20 +93,20 @@ JoystickState JoystickImpl::Update() // Get the current joystick state JOYINFOEX pos; pos.dwFlags = JOY_RETURNX | JOY_RETURNY | JOY_RETURNZ | JOY_RETURNR | JOY_RETURNU | JOY_RETURNV | JOY_RETURNBUTTONS; - pos.dwFlags |= (myCaps.wCaps & JOYCAPS_POVCTS) ? JOY_RETURNPOVCTS : JOY_RETURNPOV; + pos.dwFlags |= (m_caps.wCaps & JOYCAPS_POVCTS) ? JOY_RETURNPOVCTS : JOY_RETURNPOV; pos.dwSize = sizeof(JOYINFOEX); - if (joyGetPosEx(myIndex, &pos) == JOYERR_NOERROR) + if (joyGetPosEx(m_index, &pos) == JOYERR_NOERROR) { // The joystick is connected state.Connected = true; // Axes - state.Axes[Joystick::X] = (pos.dwXpos - (myCaps.wXmax + myCaps.wXmin) / 2.f) * 200.f / (myCaps.wXmax - myCaps.wXmin); - state.Axes[Joystick::Y] = (pos.dwYpos - (myCaps.wYmax + myCaps.wYmin) / 2.f) * 200.f / (myCaps.wYmax - myCaps.wYmin); - state.Axes[Joystick::Z] = (pos.dwZpos - (myCaps.wZmax + myCaps.wZmin) / 2.f) * 200.f / (myCaps.wZmax - myCaps.wZmin); - state.Axes[Joystick::R] = (pos.dwRpos - (myCaps.wRmax + myCaps.wRmin) / 2.f) * 200.f / (myCaps.wRmax - myCaps.wRmin); - state.Axes[Joystick::U] = (pos.dwUpos - (myCaps.wUmax + myCaps.wUmin) / 2.f) * 200.f / (myCaps.wUmax - myCaps.wUmin); - state.Axes[Joystick::V] = (pos.dwVpos - (myCaps.wVmax + myCaps.wVmin) / 2.f) * 200.f / (myCaps.wVmax - myCaps.wVmin); + state.Axes[Joystick::X] = (pos.dwXpos - (m_caps.wXmax + m_caps.wXmin) / 2.f) * 200.f / (m_caps.wXmax - m_caps.wXmin); + state.Axes[Joystick::Y] = (pos.dwYpos - (m_caps.wYmax + m_caps.wYmin) / 2.f) * 200.f / (m_caps.wYmax - m_caps.wYmin); + state.Axes[Joystick::Z] = (pos.dwZpos - (m_caps.wZmax + m_caps.wZmin) / 2.f) * 200.f / (m_caps.wZmax - m_caps.wZmin); + state.Axes[Joystick::R] = (pos.dwRpos - (m_caps.wRmax + m_caps.wRmin) / 2.f) * 200.f / (m_caps.wRmax - m_caps.wRmin); + state.Axes[Joystick::U] = (pos.dwUpos - (m_caps.wUmax + m_caps.wUmin) / 2.f) * 200.f / (m_caps.wUmax - m_caps.wUmin); + state.Axes[Joystick::V] = (pos.dwVpos - (m_caps.wVmax + m_caps.wVmin) / 2.f) * 200.f / (m_caps.wVmax - m_caps.wVmin); // Special case for POV, it is given as an angle if (pos.dwPOV != 0xFFFF) diff --git a/src/SFML/Window/Win32/JoystickImpl.hpp b/src/SFML/Window/Win32/JoystickImpl.hpp index 800f0d72..9b6c0673 100644 --- a/src/SFML/Window/Win32/JoystickImpl.hpp +++ b/src/SFML/Window/Win32/JoystickImpl.hpp @@ -95,8 +95,8 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - unsigned int myIndex; ///< Index of the joystick - JOYCAPS myCaps; ///< Joystick capabilities + unsigned int m_index; ///< Index of the joystick + JOYCAPS m_caps; ///< Joystick capabilities }; } // namespace priv diff --git a/src/SFML/Window/Win32/WglContext.cpp b/src/SFML/Window/Win32/WglContext.cpp index 75e7dff7..aab1eeb2 100644 --- a/src/SFML/Window/Win32/WglContext.cpp +++ b/src/SFML/Window/Win32/WglContext.cpp @@ -39,49 +39,49 @@ namespace priv { //////////////////////////////////////////////////////////// WglContext::WglContext(WglContext* shared) : -myWindow (NULL), -myDeviceContext(NULL), -myContext (NULL), -myOwnsWindow (true) +m_window (NULL), +m_deviceContext(NULL), +m_context (NULL), +m_ownsWindow (true) { // Creating a dummy window is mandatory: we could create a memory DC but then // its pixel format wouldn't match the regular contexts' format, and thus // wglShareLists would always fail. Too bad... // Create a dummy window (disabled and hidden) - myWindow = CreateWindowA("STATIC", "", WS_POPUP | WS_DISABLED, 0, 0, 1, 1, NULL, NULL, GetModuleHandle(NULL), NULL); - ShowWindow(myWindow, SW_HIDE); - myDeviceContext = GetDC(myWindow); + m_window = CreateWindowA("STATIC", "", WS_POPUP | WS_DISABLED, 0, 0, 1, 1, NULL, NULL, GetModuleHandle(NULL), NULL); + ShowWindow(m_window, SW_HIDE); + m_deviceContext = GetDC(m_window); // Create the context - if (myDeviceContext) + if (m_deviceContext) CreateContext(shared, VideoMode::GetDesktopMode().BitsPerPixel, ContextSettings()); } //////////////////////////////////////////////////////////// WglContext::WglContext(WglContext* shared, const ContextSettings& settings, const WindowImpl* owner, unsigned int bitsPerPixel) : -myWindow (NULL), -myDeviceContext(NULL), -myContext (NULL), -myOwnsWindow (false) +m_window (NULL), +m_deviceContext(NULL), +m_context (NULL), +m_ownsWindow (false) { // Get the owner window and its device context - myWindow = owner->GetSystemHandle(); - myDeviceContext = GetDC(myWindow); + m_window = owner->GetSystemHandle(); + m_deviceContext = GetDC(m_window); // Create the context - if (myDeviceContext) + if (m_deviceContext) CreateContext(shared, bitsPerPixel, settings); } //////////////////////////////////////////////////////////// WglContext::WglContext(WglContext* shared, const ContextSettings& settings, unsigned int width, unsigned int height) : -myWindow (NULL), -myDeviceContext(NULL), -myContext (NULL), -myOwnsWindow (true) +m_window (NULL), +m_deviceContext(NULL), +m_context (NULL), +m_ownsWindow (true) { // The target of the context is a hidden window. // We can't create a memory DC (the resulting context wouldn't be compatible @@ -89,12 +89,12 @@ myOwnsWindow (true) // we can still support them in the future if this solution is not good enough. // Create the hidden window - myWindow = CreateWindowA("STATIC", "", WS_POPUP | WS_DISABLED, 0, 0, width, height, NULL, NULL, GetModuleHandle(NULL), NULL); - ShowWindow(myWindow, SW_HIDE); - myDeviceContext = GetDC(myWindow); + m_window = CreateWindowA("STATIC", "", WS_POPUP | WS_DISABLED, 0, 0, width, height, NULL, NULL, GetModuleHandle(NULL), NULL); + ShowWindow(m_window, SW_HIDE); + m_deviceContext = GetDC(m_window); // Create the context - if (myDeviceContext) + if (m_deviceContext) CreateContext(shared, VideoMode::GetDesktopMode().BitsPerPixel, settings); } @@ -103,35 +103,35 @@ myOwnsWindow (true) WglContext::~WglContext() { // Destroy the OpenGL context - if (myContext) + if (m_context) { - if (wglGetCurrentContext() == myContext) + if (wglGetCurrentContext() == m_context) wglMakeCurrent(NULL, NULL); - wglDeleteContext(myContext); + wglDeleteContext(m_context); } // Destroy the device context - if (myDeviceContext) - ReleaseDC(myWindow, myDeviceContext); + if (m_deviceContext) + ReleaseDC(m_window, m_deviceContext); // Destroy the window if we own it - if (myWindow && myOwnsWindow) - DestroyWindow(myWindow); + if (m_window && m_ownsWindow) + DestroyWindow(m_window); } //////////////////////////////////////////////////////////// bool WglContext::MakeCurrent() { - return myDeviceContext && myContext && wglMakeCurrent(myDeviceContext, myContext); + return m_deviceContext && m_context && wglMakeCurrent(m_deviceContext, m_context); } //////////////////////////////////////////////////////////// void WglContext::Display() { - if (myDeviceContext && myContext) - SwapBuffers(myDeviceContext); + if (m_deviceContext && m_context) + SwapBuffers(m_deviceContext); } @@ -148,11 +148,11 @@ void WglContext::SetVerticalSyncEnabled(bool enabled) void WglContext::CreateContext(WglContext* shared, unsigned int bitsPerPixel, const ContextSettings& settings) { // Save the creation settings - mySettings = settings; + m_settings = settings; // Let's find a suitable pixel format -- first try with antialiasing int bestFormat = 0; - if (mySettings.AntialiasingLevel > 0) + if (m_settings.AntialiasingLevel > 0) { // Get the wglChoosePixelFormatARB function (it is an extension) PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = reinterpret_cast(wglGetProcAddress("wglChoosePixelFormatARB")); @@ -165,8 +165,8 @@ void WglContext::CreateContext(WglContext* shared, unsigned int bitsPerPixel, co WGL_SUPPORT_OPENGL_ARB, GL_TRUE, WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB, WGL_DOUBLE_BUFFER_ARB, GL_TRUE, - WGL_SAMPLE_BUFFERS_ARB, (mySettings.AntialiasingLevel ? GL_TRUE : GL_FALSE), - WGL_SAMPLES_ARB, mySettings.AntialiasingLevel, + WGL_SAMPLE_BUFFERS_ARB, (m_settings.AntialiasingLevel ? GL_TRUE : GL_FALSE), + WGL_SAMPLES_ARB, m_settings.AntialiasingLevel, 0, 0 }; @@ -174,13 +174,13 @@ void WglContext::CreateContext(WglContext* shared, unsigned int bitsPerPixel, co int formats[128]; UINT nbFormats; float floatAttributes[] = {0, 0}; - bool isValid = wglChoosePixelFormatARB(myDeviceContext, intAttributes, floatAttributes, sizeof(formats) / sizeof(*formats), formats, &nbFormats) != 0; - while ((!isValid || (nbFormats == 0)) && mySettings.AntialiasingLevel > 0) + bool isValid = wglChoosePixelFormatARB(m_deviceContext, intAttributes, floatAttributes, sizeof(formats) / sizeof(*formats), formats, &nbFormats) != 0; + while ((!isValid || (nbFormats == 0)) && m_settings.AntialiasingLevel > 0) { // Decrease the antialiasing level until we find a valid one - mySettings.AntialiasingLevel--; - intAttributes[11] = mySettings.AntialiasingLevel; - isValid = wglChoosePixelFormatARB(myDeviceContext, intAttributes, floatAttributes, sizeof(formats) / sizeof(*formats), formats, &nbFormats) != 0; + m_settings.AntialiasingLevel--; + intAttributes[11] = m_settings.AntialiasingLevel; + isValid = wglChoosePixelFormatARB(m_deviceContext, intAttributes, floatAttributes, sizeof(formats) / sizeof(*formats), formats, &nbFormats) != 0; } // Get the best format among the returned ones @@ -193,11 +193,11 @@ void WglContext::CreateContext(WglContext* shared, unsigned int bitsPerPixel, co PIXELFORMATDESCRIPTOR attributes; attributes.nSize = sizeof(attributes); attributes.nVersion = 1; - DescribePixelFormat(myDeviceContext, formats[i], sizeof(attributes), &attributes); + DescribePixelFormat(m_deviceContext, formats[i], sizeof(attributes), &attributes); // Evaluate the current configuration int color = attributes.cRedBits + attributes.cGreenBits + attributes.cBlueBits + attributes.cAlphaBits; - int score = EvaluateFormat(bitsPerPixel, mySettings, color, attributes.cDepthBits, attributes.cStencilBits, mySettings.AntialiasingLevel); + int score = EvaluateFormat(bitsPerPixel, m_settings, color, attributes.cDepthBits, attributes.cStencilBits, m_settings.AntialiasingLevel); // Keep it if it's better than the current best if (score < bestScore) @@ -212,7 +212,7 @@ void WglContext::CreateContext(WglContext* shared, unsigned int bitsPerPixel, co { // wglChoosePixelFormatARB not supported ; disabling antialiasing Err() << "Antialiasing is not supported ; it will be disabled" << std::endl; - mySettings.AntialiasingLevel = 0; + m_settings.AntialiasingLevel = 0; } } @@ -228,12 +228,12 @@ void WglContext::CreateContext(WglContext* shared, unsigned int bitsPerPixel, co descriptor.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; descriptor.iPixelType = PFD_TYPE_RGBA; descriptor.cColorBits = static_cast(bitsPerPixel); - descriptor.cDepthBits = static_cast(mySettings.DepthBits); - descriptor.cStencilBits = static_cast(mySettings.StencilBits); + descriptor.cDepthBits = static_cast(m_settings.DepthBits); + descriptor.cStencilBits = static_cast(m_settings.StencilBits); descriptor.cAlphaBits = bitsPerPixel == 32 ? 8 : 0; // Get the pixel format that best matches our requirements - bestFormat = ChoosePixelFormat(myDeviceContext, &descriptor); + bestFormat = ChoosePixelFormat(m_deviceContext, &descriptor); if (bestFormat == 0) { Err() << "Failed to find a suitable pixel format for device context -- cannot create OpenGL context" << std::endl; @@ -245,63 +245,63 @@ void WglContext::CreateContext(WglContext* shared, unsigned int bitsPerPixel, co PIXELFORMATDESCRIPTOR actualFormat; actualFormat.nSize = sizeof(actualFormat); actualFormat.nVersion = 1; - DescribePixelFormat(myDeviceContext, bestFormat, sizeof(actualFormat), &actualFormat); - mySettings.DepthBits = actualFormat.cDepthBits; - mySettings.StencilBits = actualFormat.cStencilBits; + DescribePixelFormat(m_deviceContext, bestFormat, sizeof(actualFormat), &actualFormat); + m_settings.DepthBits = actualFormat.cDepthBits; + m_settings.StencilBits = actualFormat.cStencilBits; // Set the chosen pixel format - if (!SetPixelFormat(myDeviceContext, bestFormat, &actualFormat)) + if (!SetPixelFormat(m_deviceContext, bestFormat, &actualFormat)) { Err() << "Failed to set pixel format for device context -- cannot create OpenGL context" << std::endl; return; } // Get the context to share display lists with - HGLRC sharedContext = shared ? shared->myContext : NULL; + HGLRC sharedContext = shared ? shared->m_context : NULL; // Create the OpenGL context -- first try context versions >= 3.0 if it is requested (they require special code) - while (!myContext && (mySettings.MajorVersion >= 3)) + while (!m_context && (m_settings.MajorVersion >= 3)) { PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB = reinterpret_cast(wglGetProcAddress("wglCreateContextAttribsARB")); if (wglCreateContextAttribsARB) { int attributes[] = { - WGL_CONTEXT_MAJOR_VERSION_ARB, mySettings.MajorVersion, - WGL_CONTEXT_MINOR_VERSION_ARB, mySettings.MinorVersion, + WGL_CONTEXT_MAJOR_VERSION_ARB, m_settings.MajorVersion, + WGL_CONTEXT_MINOR_VERSION_ARB, m_settings.MinorVersion, WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB, 0, 0 }; - myContext = wglCreateContextAttribsARB(myDeviceContext, sharedContext, attributes); + m_context = wglCreateContextAttribsARB(m_deviceContext, sharedContext, attributes); } // If we couldn't create the context, lower the version number and try again -- stop at 3.0 // Invalid version numbers will be generated by this algorithm (like 3.9), but we really don't care - if (!myContext) + if (!m_context) { - if (mySettings.MinorVersion > 0) + if (m_settings.MinorVersion > 0) { // If the minor version is not 0, we decrease it and try again - mySettings.MinorVersion--; + m_settings.MinorVersion--; } else { // If the minor version is 0, we decrease the major version - mySettings.MajorVersion--; - mySettings.MinorVersion = 9; + m_settings.MajorVersion--; + m_settings.MinorVersion = 9; } } } // If the OpenGL >= 3.0 context failed or if we don't want one, create a regular OpenGL 1.x/2.x context - if (!myContext) + if (!m_context) { // set the context version to 2.0 (arbitrary) - mySettings.MajorVersion = 2; - mySettings.MinorVersion = 0; + m_settings.MajorVersion = 2; + m_settings.MinorVersion = 0; - myContext = wglCreateContext(myDeviceContext); - if (!myContext) + m_context = wglCreateContext(m_deviceContext); + if (!m_context) { Err() << "Failed to create an OpenGL context for this window" << std::endl; return; @@ -314,7 +314,7 @@ void WglContext::CreateContext(WglContext* shared, unsigned int bitsPerPixel, co static Mutex mutex; Lock lock(mutex); - if (!wglShareLists(sharedContext, myContext)) + if (!wglShareLists(sharedContext, m_context)) Err() << "Failed to share the OpenGL context" << std::endl; } } diff --git a/src/SFML/Window/Win32/WglContext.hpp b/src/SFML/Window/Win32/WglContext.hpp index f9cf8feb..ecb0473b 100644 --- a/src/SFML/Window/Win32/WglContext.hpp +++ b/src/SFML/Window/Win32/WglContext.hpp @@ -124,10 +124,10 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - HWND myWindow; ///< Window to which the context is attached - HDC myDeviceContext; ///< Device context associated to the context - HGLRC myContext; ///< OpenGL context - bool myOwnsWindow; ///< Do we own the target window? + HWND m_window; ///< Window to which the context is attached + HDC m_deviceContext; ///< Device context associated to the context + HGLRC m_context; ///< OpenGL context + bool m_ownsWindow; ///< Do we own the target window? }; } // namespace priv diff --git a/src/SFML/Window/Win32/WindowImplWin32.cpp b/src/SFML/Window/Win32/WindowImplWin32.cpp index 6370f5d9..8d8d6a01 100644 --- a/src/SFML/Window/Win32/WindowImplWin32.cpp +++ b/src/SFML/Window/Win32/WindowImplWin32.cpp @@ -61,30 +61,30 @@ namespace priv { //////////////////////////////////////////////////////////// WindowImplWin32::WindowImplWin32(WindowHandle handle) : -myHandle (handle), -myCallback (0), -myCursor (NULL), -myIcon (NULL), -myKeyRepeatEnabled(true), -myIsCursorIn (false) +m_handle (handle), +m_callback (0), +m_cursor (NULL), +m_icon (NULL), +m_keyRepeatEnabled(true), +m_isCursorIn (false) { - if (myHandle) + if (m_handle) { // We change the event procedure of the control (it is important to save the old one) - SetWindowLongPtr(myHandle, GWLP_USERDATA, reinterpret_cast(this)); - myCallback = SetWindowLongPtr(myHandle, GWLP_WNDPROC, reinterpret_cast(&WindowImplWin32::GlobalOnEvent)); + SetWindowLongPtr(m_handle, GWLP_USERDATA, reinterpret_cast(this)); + m_callback = SetWindowLongPtr(m_handle, GWLP_WNDPROC, reinterpret_cast(&WindowImplWin32::GlobalOnEvent)); } } //////////////////////////////////////////////////////////// WindowImplWin32::WindowImplWin32(VideoMode mode, const std::string& title, Uint32 style) : -myHandle (NULL), -myCallback (0), -myCursor (NULL), -myIcon (NULL), -myKeyRepeatEnabled(true), -myIsCursorIn (false) +m_handle (NULL), +m_callback (0), +m_cursor (NULL), +m_icon (NULL), +m_keyRepeatEnabled(true), +m_isCursorIn (false) { // Register the window class at first call if (WindowCount == 0) @@ -127,11 +127,11 @@ myIsCursorIn (false) wchar_t wTitle[256]; int count = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, title.c_str(), static_cast(title.size()), wTitle, sizeof(wTitle) / sizeof(*wTitle)); wTitle[count] = L'\0'; - myHandle = CreateWindowW(ClassNameW, wTitle, win32Style, left, top, width, height, NULL, NULL, GetModuleHandle(NULL), this); + m_handle = CreateWindowW(ClassNameW, wTitle, win32Style, left, top, width, height, NULL, NULL, GetModuleHandle(NULL), this); } else { - myHandle = CreateWindowA(ClassNameA, title.c_str(), win32Style, left, top, width, height, NULL, NULL, GetModuleHandle(NULL), this); + m_handle = CreateWindowA(ClassNameA, title.c_str(), win32Style, left, top, width, height, NULL, NULL, GetModuleHandle(NULL), this); } // Switch to fullscreen if requested @@ -147,14 +147,14 @@ myIsCursorIn (false) WindowImplWin32::~WindowImplWin32() { // Destroy the custom icon, if any - if (myIcon) - DestroyIcon(myIcon); + if (m_icon) + DestroyIcon(m_icon); - if (!myCallback) + if (!m_callback) { // Destroy the window - if (myHandle) - DestroyWindow(myHandle); + if (m_handle) + DestroyWindow(m_handle); // Decrement the window count WindowCount--; @@ -175,7 +175,7 @@ WindowImplWin32::~WindowImplWin32() else { // The window is external : remove the hook on its message callback - SetWindowLongPtr(myHandle, GWLP_WNDPROC, myCallback); + SetWindowLongPtr(m_handle, GWLP_WNDPROC, m_callback); } } @@ -183,7 +183,7 @@ WindowImplWin32::~WindowImplWin32() //////////////////////////////////////////////////////////// WindowHandle WindowImplWin32::GetSystemHandle() const { - return myHandle; + return m_handle; } @@ -191,10 +191,10 @@ WindowHandle WindowImplWin32::GetSystemHandle() const void WindowImplWin32::ProcessEvents() { // We process the window events only if we own it - if (!myCallback) + if (!m_callback) { MSG message; - while (PeekMessage(&message, myHandle, 0, 0, PM_REMOVE)) + while (PeekMessage(&message, m_handle, 0, 0, PM_REMOVE)) { TranslateMessage(&message); DispatchMessage(&message); @@ -207,7 +207,7 @@ void WindowImplWin32::ProcessEvents() Vector2i WindowImplWin32::GetPosition() const { RECT rect; - GetWindowRect(myHandle, &rect); + GetWindowRect(m_handle, &rect); return Vector2i(rect.left, rect.top); } @@ -216,7 +216,7 @@ Vector2i WindowImplWin32::GetPosition() const //////////////////////////////////////////////////////////// void WindowImplWin32::SetPosition(const Vector2i& position) { - SetWindowPos(myHandle, NULL, position.x, position.y, 0, 0, SWP_NOSIZE | SWP_NOZORDER); + SetWindowPos(m_handle, NULL, position.x, position.y, 0, 0, SWP_NOSIZE | SWP_NOZORDER); } @@ -224,7 +224,7 @@ void WindowImplWin32::SetPosition(const Vector2i& position) Vector2u WindowImplWin32::GetSize() const { RECT rect; - GetClientRect(myHandle, &rect); + GetClientRect(m_handle, &rect); return Vector2u(rect.right - rect.left, rect.bottom - rect.top); } @@ -236,18 +236,18 @@ void WindowImplWin32::SetSize(const Vector2u& size) // SetWindowPos wants the total size of the window (including title bar and borders), // so we have to compute it RECT rectangle = {0, 0, size.x, size.y}; - AdjustWindowRect(&rectangle, GetWindowLong(myHandle, GWL_STYLE), false); + AdjustWindowRect(&rectangle, GetWindowLong(m_handle, GWL_STYLE), false); int width = rectangle.right - rectangle.left; int height = rectangle.bottom - rectangle.top; - SetWindowPos(myHandle, NULL, 0, 0, width, height, SWP_NOMOVE | SWP_NOZORDER); + SetWindowPos(m_handle, NULL, 0, 0, width, height, SWP_NOMOVE | SWP_NOZORDER); } //////////////////////////////////////////////////////////// void WindowImplWin32::SetTitle(const std::string& title) { - SetWindowText(myHandle, title.c_str()); + SetWindowText(m_handle, title.c_str()); } @@ -255,8 +255,8 @@ void WindowImplWin32::SetTitle(const std::string& title) void WindowImplWin32::SetIcon(unsigned int width, unsigned int height, const Uint8* pixels) { // First destroy the previous one - if (myIcon) - DestroyIcon(myIcon); + if (m_icon) + DestroyIcon(m_icon); // Windows wants BGRA pixels: swap red and blue channels std::vector iconPixels(width * height * 4); @@ -269,13 +269,13 @@ void WindowImplWin32::SetIcon(unsigned int width, unsigned int height, const Uin } // Create the icon from the pixel array - myIcon = CreateIcon(GetModuleHandle(NULL), width, height, 1, 32, NULL, &iconPixels[0]); + m_icon = CreateIcon(GetModuleHandle(NULL), width, height, 1, 32, NULL, &iconPixels[0]); // Set it as both big and small icon of the window - if (myIcon) + if (m_icon) { - SendMessage(myHandle, WM_SETICON, ICON_BIG, (LPARAM)myIcon); - SendMessage(myHandle, WM_SETICON, ICON_SMALL, (LPARAM)myIcon); + SendMessage(m_handle, WM_SETICON, ICON_BIG, (LPARAM)m_icon); + SendMessage(m_handle, WM_SETICON, ICON_SMALL, (LPARAM)m_icon); } else { @@ -287,7 +287,7 @@ void WindowImplWin32::SetIcon(unsigned int width, unsigned int height, const Uin //////////////////////////////////////////////////////////// void WindowImplWin32::SetVisible(bool visible) { - ShowWindow(myHandle, visible ? SW_SHOW : SW_HIDE); + ShowWindow(m_handle, visible ? SW_SHOW : SW_HIDE); } @@ -295,18 +295,18 @@ void WindowImplWin32::SetVisible(bool visible) void WindowImplWin32::SetMouseCursorVisible(bool visible) { if (visible) - myCursor = LoadCursor(NULL, IDC_ARROW); + m_cursor = LoadCursor(NULL, IDC_ARROW); else - myCursor = NULL; + m_cursor = NULL; - SetCursor(myCursor); + SetCursor(m_cursor); } //////////////////////////////////////////////////////////// void WindowImplWin32::SetKeyRepeatEnabled(bool enabled) { - myKeyRepeatEnabled = enabled; + m_keyRepeatEnabled = enabled; } @@ -364,12 +364,12 @@ void WindowImplWin32::SwitchToFullscreen(const VideoMode& mode) } // Make the window flags compatible with fullscreen mode - SetWindowLong(myHandle, GWL_STYLE, WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS); - SetWindowLong(myHandle, GWL_EXSTYLE, WS_EX_APPWINDOW); + SetWindowLong(m_handle, GWL_STYLE, WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS); + SetWindowLong(m_handle, GWL_EXSTYLE, WS_EX_APPWINDOW); // Resize the window so that it fits the entire screen - SetWindowPos(myHandle, HWND_TOP, 0, 0, mode.Width, mode.Height, SWP_FRAMECHANGED); - ShowWindow(myHandle, SW_SHOW); + SetWindowPos(m_handle, HWND_TOP, 0, 0, mode.Width, mode.Height, SWP_FRAMECHANGED); + ShowWindow(m_handle, SW_SHOW); // Set "this" as the current fullscreen window FullscreenWindow = this; @@ -395,7 +395,7 @@ void WindowImplWin32::Cleanup() void WindowImplWin32::ProcessEvent(UINT message, WPARAM wParam, LPARAM lParam) { // Don't process any message until window is created - if (myHandle == NULL) + if (m_handle == NULL) return; switch (message) @@ -413,7 +413,7 @@ void WindowImplWin32::ProcessEvent(UINT message, WPARAM wParam, LPARAM lParam) { // The mouse has moved, if the cursor is in our window we must refresh the cursor if (LOWORD(lParam) == HTCLIENT) - SetCursor(myCursor); + SetCursor(m_cursor); break; } @@ -435,7 +435,7 @@ void WindowImplWin32::ProcessEvent(UINT message, WPARAM wParam, LPARAM lParam) { // Get the new size RECT rectangle; - GetClientRect(myHandle, &rectangle); + GetClientRect(m_handle, &rectangle); Event event; event.Type = Event::Resized; @@ -467,7 +467,7 @@ void WindowImplWin32::ProcessEvent(UINT message, WPARAM wParam, LPARAM lParam) // Text event case WM_CHAR : { - if (myKeyRepeatEnabled || ((lParam & (1 << 30)) == 0)) + if (m_keyRepeatEnabled || ((lParam & (1 << 30)) == 0)) { Event event; event.Type = Event::TextEntered; @@ -481,7 +481,7 @@ void WindowImplWin32::ProcessEvent(UINT message, WPARAM wParam, LPARAM lParam) case WM_KEYDOWN : case WM_SYSKEYDOWN : { - if (myKeyRepeatEnabled || ((HIWORD(lParam) & KF_REPEAT) == 0)) + if (m_keyRepeatEnabled || ((HIWORD(lParam) & KF_REPEAT) == 0)) { Event event; event.Type = Event::KeyPressed; @@ -517,7 +517,7 @@ void WindowImplWin32::ProcessEvent(UINT message, WPARAM wParam, LPARAM lParam) POINT position; position.x = static_cast(LOWORD(lParam)); position.y = static_cast(HIWORD(lParam)); - ScreenToClient(myHandle, &position); + ScreenToClient(m_handle, &position); Event event; event.Type = Event::MouseWheelMoved; @@ -628,15 +628,15 @@ void WindowImplWin32::ProcessEvent(UINT message, WPARAM wParam, LPARAM lParam) case WM_MOUSEMOVE : { // Check if we need to generate a MouseEntered event - if (!myIsCursorIn) + if (!m_isCursorIn) { TRACKMOUSEEVENT mouseEvent; mouseEvent.cbSize = sizeof(TRACKMOUSEEVENT); - mouseEvent.hwndTrack = myHandle; + mouseEvent.hwndTrack = m_handle; mouseEvent.dwFlags = TME_LEAVE; TrackMouseEvent(&mouseEvent); - myIsCursorIn = true; + m_isCursorIn = true; Event event; event.Type = Event::MouseEntered; @@ -654,7 +654,7 @@ void WindowImplWin32::ProcessEvent(UINT message, WPARAM wParam, LPARAM lParam) // Mouse leave event case WM_MOUSELEAVE : { - myIsCursorIn = false; + m_isCursorIn = false; Event event; event.Type = Event::MouseLeft; @@ -825,8 +825,8 @@ LRESULT CALLBACK WindowImplWin32::GlobalOnEvent(HWND handle, UINT message, WPARA { window->ProcessEvent(message, wParam, lParam); - if (window->myCallback) - return CallWindowProc(reinterpret_cast(window->myCallback), handle, message, wParam, lParam); + if (window->m_callback) + return CallWindowProc(reinterpret_cast(window->m_callback), handle, message, wParam, lParam); } // We don't forward the WM_CLOSE message to prevent the OS from automatically destroying the window diff --git a/src/SFML/Window/Win32/WindowImplWin32.hpp b/src/SFML/Window/Win32/WindowImplWin32.hpp index b690ec29..d6a1a40b 100644 --- a/src/SFML/Window/Win32/WindowImplWin32.hpp +++ b/src/SFML/Window/Win32/WindowImplWin32.hpp @@ -230,12 +230,12 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - HWND myHandle; ///< Win32 handle of the window - LONG_PTR myCallback; ///< Stores the original event callback function of the control - HCURSOR myCursor; ///< The system cursor to display into the window - HICON myIcon; ///< Custom icon assigned to the window - bool myKeyRepeatEnabled; ///< Automatic key-repeat state for keydown events - bool myIsCursorIn; ///< Is the mouse cursor in the window's area ? + HWND m_handle; ///< Win32 handle of the window + LONG_PTR m_callback; ///< Stores the original event callback function of the control + HCURSOR m_cursor; ///< The system cursor to display into the window + HICON m_icon; ///< Custom icon assigned to the window + bool m_keyRepeatEnabled; ///< Automatic key-repeat state for keydown events + bool m_isCursorIn; ///< Is the mouse cursor in the window's area ? }; } // namespace priv diff --git a/src/SFML/Window/Window.cpp b/src/SFML/Window/Window.cpp index 722d7000..a063a5b8 100644 --- a/src/SFML/Window/Window.cpp +++ b/src/SFML/Window/Window.cpp @@ -42,9 +42,9 @@ namespace sf { //////////////////////////////////////////////////////////// Window::Window() : -myImpl (NULL), -myContext (NULL), -myFrameTimeLimit(Time::Zero) +m_impl (NULL), +m_context (NULL), +m_frameTimeLimit(Time::Zero) { } @@ -52,9 +52,9 @@ myFrameTimeLimit(Time::Zero) //////////////////////////////////////////////////////////// Window::Window(VideoMode mode, const std::string& title, Uint32 style, const ContextSettings& settings) : -myImpl (NULL), -myContext (NULL), -myFrameTimeLimit(Time::Zero) +m_impl (NULL), +m_context (NULL), +m_frameTimeLimit(Time::Zero) { Create(mode, title, style, settings); } @@ -62,9 +62,9 @@ myFrameTimeLimit(Time::Zero) //////////////////////////////////////////////////////////// Window::Window(WindowHandle handle, const ContextSettings& settings) : -myImpl (NULL), -myContext (NULL), -myFrameTimeLimit(Time::Zero) +m_impl (NULL), +m_context (NULL), +m_frameTimeLimit(Time::Zero) { Create(handle, settings); } @@ -111,10 +111,10 @@ void Window::Create(VideoMode mode, const std::string& title, Uint32 style, cons style |= Style::Titlebar; // Recreate the window implementation - myImpl = priv::WindowImpl::Create(mode, title, style); + m_impl = priv::WindowImpl::Create(mode, title, style); // Recreate the context - myContext = priv::GlContext::Create(settings, myImpl, mode.BitsPerPixel); + m_context = priv::GlContext::Create(settings, m_impl, mode.BitsPerPixel); // Perform common initializations Initialize(); @@ -128,10 +128,10 @@ void Window::Create(WindowHandle handle, const ContextSettings& settings) Close(); // Recreate the window implementation - myImpl = priv::WindowImpl::Create(handle); + m_impl = priv::WindowImpl::Create(handle); // Recreate the context - myContext = priv::GlContext::Create(settings, myImpl, VideoMode::GetDesktopMode().BitsPerPixel); + m_context = priv::GlContext::Create(settings, m_impl, VideoMode::GetDesktopMode().BitsPerPixel); // Perform common initializations Initialize(); @@ -141,18 +141,18 @@ void Window::Create(WindowHandle handle, const ContextSettings& settings) //////////////////////////////////////////////////////////// void Window::Close() { - if (myContext) + if (m_context) { // Delete the context - delete myContext; - myContext = NULL; + delete m_context; + m_context = NULL; } - if (myImpl) + if (m_impl) { // Delete the window implementation - delete myImpl; - myImpl = NULL; + delete m_impl; + m_impl = NULL; } // Update the fullscreen window @@ -164,7 +164,7 @@ void Window::Close() //////////////////////////////////////////////////////////// bool Window::IsOpen() const { - return myImpl != NULL; + return m_impl != NULL; } @@ -173,14 +173,14 @@ const ContextSettings& Window::GetSettings() const { static const ContextSettings empty(0, 0, 0); - return myContext ? myContext->GetSettings() : empty; + return m_context ? m_context->GetSettings() : empty; } //////////////////////////////////////////////////////////// bool Window::PollEvent(Event& event) { - if (myImpl && myImpl->PopEvent(event, false)) + if (m_impl && m_impl->PopEvent(event, false)) { return FilterEvent(event); } @@ -194,7 +194,7 @@ bool Window::PollEvent(Event& event) //////////////////////////////////////////////////////////// bool Window::WaitEvent(Event& event) { - if (myImpl && myImpl->PopEvent(event, true)) + if (m_impl && m_impl->PopEvent(event, true)) { return FilterEvent(event); } @@ -208,54 +208,54 @@ bool Window::WaitEvent(Event& event) //////////////////////////////////////////////////////////// Vector2i Window::GetPosition() const { - return myImpl ? myImpl->GetPosition() : Vector2i(); + return m_impl ? m_impl->GetPosition() : Vector2i(); } //////////////////////////////////////////////////////////// void Window::SetPosition(const Vector2i& position) { - if (myImpl) - myImpl->SetPosition(position); + if (m_impl) + m_impl->SetPosition(position); } //////////////////////////////////////////////////////////// Vector2u Window::GetSize() const { - return myImpl ? myImpl->GetSize() : Vector2u(); + return m_impl ? m_impl->GetSize() : Vector2u(); } //////////////////////////////////////////////////////////// void Window::SetSize(const Vector2u size) { - if (myImpl) - myImpl->SetSize(size); + if (m_impl) + m_impl->SetSize(size); } //////////////////////////////////////////////////////////// void Window::SetTitle(const std::string& title) { - if (myImpl) - myImpl->SetTitle(title); + if (m_impl) + m_impl->SetTitle(title); } //////////////////////////////////////////////////////////// void Window::SetIcon(unsigned int width, unsigned int height, const Uint8* pixels) { - if (myImpl) - myImpl->SetIcon(width, height, pixels); + if (m_impl) + m_impl->SetIcon(width, height, pixels); } //////////////////////////////////////////////////////////// void Window::SetVisible(bool visible) { - if (myImpl) - myImpl->SetVisible(visible); + if (m_impl) + m_impl->SetVisible(visible); } @@ -263,23 +263,23 @@ void Window::SetVisible(bool visible) void Window::SetVerticalSyncEnabled(bool enabled) { if (SetActive()) - myContext->SetVerticalSyncEnabled(enabled); + m_context->SetVerticalSyncEnabled(enabled); } //////////////////////////////////////////////////////////// void Window::SetMouseCursorVisible(bool visible) { - if (myImpl) - myImpl->SetMouseCursorVisible(visible); + if (m_impl) + m_impl->SetMouseCursorVisible(visible); } //////////////////////////////////////////////////////////// void Window::SetKeyRepeatEnabled(bool enabled) { - if (myImpl) - myImpl->SetKeyRepeatEnabled(enabled); + if (m_impl) + m_impl->SetKeyRepeatEnabled(enabled); } @@ -287,26 +287,26 @@ void Window::SetKeyRepeatEnabled(bool enabled) void Window::SetFramerateLimit(unsigned int limit) { if (limit > 0) - myFrameTimeLimit = Seconds(1.f / limit); + m_frameTimeLimit = Seconds(1.f / limit); else - myFrameTimeLimit = Time::Zero; + m_frameTimeLimit = Time::Zero; } //////////////////////////////////////////////////////////// void Window::SetJoystickThreshold(float threshold) { - if (myImpl) - myImpl->SetJoystickThreshold(threshold); + if (m_impl) + m_impl->SetJoystickThreshold(threshold); } //////////////////////////////////////////////////////////// bool Window::SetActive(bool active) const { - if (myContext) + if (m_context) { - if (myContext->SetActive(active)) + if (m_context->SetActive(active)) { return true; } @@ -328,13 +328,13 @@ void Window::Display() { // Display the backbuffer on screen if (SetActive()) - myContext->Display(); + m_context->Display(); // Limit the framerate if needed - if (myFrameTimeLimit != Time::Zero) + if (m_frameTimeLimit != Time::Zero) { - Sleep(myFrameTimeLimit - myClock.GetElapsedTime()); - myClock.Restart(); + Sleep(m_frameTimeLimit - m_clock.GetElapsedTime()); + m_clock.Restart(); } } @@ -342,7 +342,7 @@ void Window::Display() //////////////////////////////////////////////////////////// WindowHandle Window::GetSystemHandle() const { - return myImpl ? myImpl->GetSystemHandle() : 0; + return m_impl ? m_impl->GetSystemHandle() : 0; } @@ -381,7 +381,7 @@ void Window::Initialize() SetKeyRepeatEnabled(true); // Reset frame time - myClock.Restart(); + m_clock.Restart(); // Activate the window SetActive(); diff --git a/src/SFML/Window/WindowImpl.cpp b/src/SFML/Window/WindowImpl.cpp index 9c7dd5f2..f61656d7 100644 --- a/src/SFML/Window/WindowImpl.cpp +++ b/src/SFML/Window/WindowImpl.cpp @@ -70,12 +70,12 @@ WindowImpl* WindowImpl::Create(WindowHandle handle) //////////////////////////////////////////////////////////// WindowImpl::WindowImpl() : -myJoyThreshold(0.1f) +m_joyThreshold(0.1f) { // Get the initial joystick states JoystickManager::GetInstance().Update(); for (unsigned int i = 0; i < Joystick::Count; ++i) - myJoyStates[i] = JoystickManager::GetInstance().GetState(i); + m_joyStates[i] = JoystickManager::GetInstance().GetState(i); } @@ -89,7 +89,7 @@ WindowImpl::~WindowImpl() //////////////////////////////////////////////////////////// void WindowImpl::SetJoystickThreshold(float threshold) { - myJoyThreshold = threshold; + m_joyThreshold = threshold; } @@ -97,7 +97,7 @@ void WindowImpl::SetJoystickThreshold(float threshold) bool WindowImpl::PopEvent(Event& event, bool block) { // If the event queue is empty, let's first check if new events are available from the OS - if (myEvents.empty()) + if (m_events.empty()) { if (!block) { @@ -112,7 +112,7 @@ bool WindowImpl::PopEvent(Event& event, bool block) // Here we use a manual wait loop instead of the optimized // wait-event provided by the OS, so that we don't skip joystick // events (which require polling) - while (myEvents.empty()) + while (m_events.empty()) { ProcessJoystickEvents(); ProcessEvents(); @@ -122,10 +122,10 @@ bool WindowImpl::PopEvent(Event& event, bool block) } // Pop the first event of the queue, if it is not empty - if (!myEvents.empty()) + if (!m_events.empty()) { - event = myEvents.front(); - myEvents.pop(); + event = m_events.front(); + m_events.pop(); return true; } @@ -137,7 +137,7 @@ bool WindowImpl::PopEvent(Event& event, bool block) //////////////////////////////////////////////////////////// void WindowImpl::PushEvent(const Event& event) { - myEvents.push(event); + m_events.push(event); } @@ -150,12 +150,12 @@ void WindowImpl::ProcessJoystickEvents() for (unsigned int i = 0; i < Joystick::Count; ++i) { // Copy the previous state of the joystick and get the new one - JoystickState previousState = myJoyStates[i]; - myJoyStates[i] = JoystickManager::GetInstance().GetState(i); + JoystickState previousState = m_joyStates[i]; + m_joyStates[i] = JoystickManager::GetInstance().GetState(i); JoystickCaps caps = JoystickManager::GetInstance().GetCapabilities(i); // Connection state - bool connected = myJoyStates[i].Connected; + bool connected = m_joyStates[i].Connected; if (previousState.Connected ^ connected) { Event event; @@ -173,8 +173,8 @@ void WindowImpl::ProcessJoystickEvents() { Joystick::Axis axis = static_cast(j); float prevPos = previousState.Axes[axis]; - float currPos = myJoyStates[i].Axes[axis]; - if (fabs(currPos - prevPos) >= myJoyThreshold) + float currPos = m_joyStates[i].Axes[axis]; + if (fabs(currPos - prevPos) >= m_joyThreshold) { Event event; event.Type = Event::JoystickMoved; @@ -190,7 +190,7 @@ void WindowImpl::ProcessJoystickEvents() for (unsigned int j = 0; j < caps.ButtonCount; ++j) { bool prevPressed = previousState.Buttons[j]; - bool currPressed = myJoyStates[i].Buttons[j]; + bool currPressed = m_joyStates[i].Buttons[j]; if (prevPressed ^ currPressed) { diff --git a/src/SFML/Window/WindowImpl.hpp b/src/SFML/Window/WindowImpl.hpp index 0139d9fe..6a0e28ba 100644 --- a/src/SFML/Window/WindowImpl.hpp +++ b/src/SFML/Window/WindowImpl.hpp @@ -228,9 +228,9 @@ private : //////////////////////////////////////////////////////////// // Member data //////////////////////////////////////////////////////////// - std::queue myEvents; ///< Queue of available events - JoystickState myJoyStates[Joystick::Count]; ///< Previous state of the joysticks - float myJoyThreshold; ///< Joystick threshold (minimum motion for MOVE event to be generated) + std::queue m_events; ///< Queue of available events + JoystickState m_joyStates[Joystick::Count]; ///< Previous state of the joysticks + float m_joyThreshold; ///< Joystick threshold (minimum motion for MOVE event to be generated) }; } // namespace priv