mirrors/SFML
1
0
Fork 0
mirror of https://github.com/SFML/SFML.git synced 2024-11-25 04:41:05 +08:00
Code Issues Packages Projects Releases Wiki Activity

Replace sf::Uint32 with std::uint32_t

Browse Source
This commit is contained in:
Chris Thrasher 2022-09-12 14:17:27 -06:00 committed by Vittorio Romeo
parent 056f66a2b8
commit e294090c8e
53 changed files with 266 additions and 268 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
examples/vulkan/Vulkan.cpp
View File

@ -396,7 +396,7 @@ public:
vkWaitForFences(device, 1, &fence, VK_TRUE, std::numeric_limits<uint64_t>::max()); vkWaitForFences(device, 1, &fence, VK_TRUE, std::numeric_limits<uint64_t>::max());
if (commandBuffers.size()) if (commandBuffers.size())
vkFreeCommandBuffers(device, commandPool, static_cast<sf::Uint32>(commandBuffers.size()), commandBuffers.data()); vkFreeCommandBuffers(device, commandPool, static_cast<std::uint32_t>(commandBuffers.size()), commandBuffers.data());
commandBuffers.clear(); commandBuffers.clear();
@ -477,7 +477,7 @@ public:
} }
// Retrieve the available instance layers // Retrieve the available instance layers
uint32_t objectCount = 0; std::uint32_t objectCount = 0;
std::vector<VkLayerProperties> layers; std::vector<VkLayerProperties> layers;
@ -537,9 +537,9 @@ public:
VkInstanceCreateInfo instanceCreateInfo = VkInstanceCreateInfo(); VkInstanceCreateInfo instanceCreateInfo = VkInstanceCreateInfo();
instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instanceCreateInfo.pApplicationInfo = &applicationInfo; instanceCreateInfo.pApplicationInfo = &applicationInfo;
instanceCreateInfo.enabledLayerCount = static_cast<sf::Uint32>(validationLayers.size()); instanceCreateInfo.enabledLayerCount = static_cast<std::uint32_t>(validationLayers.size());
instanceCreateInfo.ppEnabledLayerNames = validationLayers.data(); instanceCreateInfo.ppEnabledLayerNames = validationLayers.data();
instanceCreateInfo.enabledExtensionCount = static_cast<sf::Uint32>(requiredExtentions.size()); instanceCreateInfo.enabledExtensionCount = static_cast<std::uint32_t>(requiredExtentions.size());
instanceCreateInfo.ppEnabledExtensionNames = requiredExtentions.data(); instanceCreateInfo.ppEnabledExtensionNames = requiredExtentions.data();
// Try to create a Vulkan instance with debug report enabled // Try to create a Vulkan instance with debug report enabled
@ -550,7 +550,7 @@ public:
{ {
requiredExtentions.pop_back(); requiredExtentions.pop_back();
instanceCreateInfo.enabledExtensionCount = static_cast<sf::Uint32>(requiredExtentions.size()); instanceCreateInfo.enabledExtensionCount = static_cast<std::uint32_t>(requiredExtentions.size());
instanceCreateInfo.ppEnabledExtensionNames = requiredExtentions.data(); instanceCreateInfo.ppEnabledExtensionNames = requiredExtentions.data();
result = vkCreateInstance(&instanceCreateInfo, 0, &instance); result = vkCreateInstance(&instanceCreateInfo, 0, &instance);
@ -607,7 +607,7 @@ public:
} }
// Retrieve list of GPUs // Retrieve list of GPUs
uint32_t objectCount = 0; std::uint32_t objectCount = 0;
std::vector<VkPhysicalDevice> devices; std::vector<VkPhysicalDevice> devices;
@ -720,7 +720,7 @@ public:
void setupLogicalDevice() void setupLogicalDevice()
{ {
// Select a queue family that supports graphics operations and surface presentation // Select a queue family that supports graphics operations and surface presentation
uint32_t objectCount = 0; std::uint32_t objectCount = 0;
std::vector<VkQueueFamilyProperties> queueFamilyProperties; std::vector<VkQueueFamilyProperties> queueFamilyProperties;
@ -734,7 +734,7 @@ public:
{ {
VkBool32 surfaceSupported = VK_FALSE; VkBool32 surfaceSupported = VK_FALSE;
vkGetPhysicalDeviceSurfaceSupportKHR(gpu, static_cast<sf::Uint32>(i), surface, &surfaceSupported); vkGetPhysicalDeviceSurfaceSupportKHR(gpu, static_cast<std::uint32_t>(i), surface, &surfaceSupported);
if ((queueFamilyProperties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) && (surfaceSupported == VK_TRUE)) if ((queueFamilyProperties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) && (surfaceSupported == VK_TRUE))
{ {
@ -754,7 +754,7 @@ public:
VkDeviceQueueCreateInfo deviceQueueCreateInfo = VkDeviceQueueCreateInfo(); VkDeviceQueueCreateInfo deviceQueueCreateInfo = VkDeviceQueueCreateInfo();
deviceQueueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; deviceQueueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
deviceQueueCreateInfo.queueCount = 1; deviceQueueCreateInfo.queueCount = 1;
deviceQueueCreateInfo.queueFamilyIndex = static_cast<uint32_t>(queueFamilyIndex); deviceQueueCreateInfo.queueFamilyIndex = static_cast<std::uint32_t>(queueFamilyIndex);
deviceQueueCreateInfo.pQueuePriorities = &queuePriority; deviceQueueCreateInfo.pQueuePriorities = &queuePriority;
// Enable the swapchain extension // Enable the swapchain extension
@ -780,14 +780,14 @@ public:
} }
// Retrieve a handle to the logical device command queue // Retrieve a handle to the logical device command queue
vkGetDeviceQueue(device, static_cast<uint32_t>(queueFamilyIndex), 0, &queue); vkGetDeviceQueue(device, static_cast<std::uint32_t>(queueFamilyIndex), 0, &queue);
} }
// Query surface formats and set up swapchain // Query surface formats and set up swapchain
void setupSwapchain() void setupSwapchain()
{ {
// Select a surface format that supports RGBA color format // Select a surface format that supports RGBA color format
uint32_t objectCount = 0; std::uint32_t objectCount = 0;
std::vector<VkSurfaceFormatKHR> surfaceFormats; std::vector<VkSurfaceFormatKHR> surfaceFormats;
@ -871,14 +871,14 @@ public:
return; return;
} }
swapchainExtent.width = clamp<uint32_t>(window.getSize().x, swapchainExtent.width = clamp<std::uint32_t>(window.getSize().x,
surfaceCapabilities.minImageExtent.width, surfaceCapabilities.minImageExtent.width,
surfaceCapabilities.maxImageExtent.width); surfaceCapabilities.maxImageExtent.width);
swapchainExtent.height = clamp<uint32_t>(window.getSize().y, swapchainExtent.height = clamp<std::uint32_t>(window.getSize().y,
surfaceCapabilities.minImageExtent.height, surfaceCapabilities.minImageExtent.height,
surfaceCapabilities.maxImageExtent.height); surfaceCapabilities.maxImageExtent.height);
auto imageCount = clamp<uint32_t>(2, surfaceCapabilities.minImageCount, surfaceCapabilities.maxImageCount); auto imageCount = clamp<std::uint32_t>(2, surfaceCapabilities.minImageCount, surfaceCapabilities.maxImageCount);
VkSwapchainCreateInfoKHR swapchainCreateInfo = VkSwapchainCreateInfoKHR(); VkSwapchainCreateInfoKHR swapchainCreateInfo = VkSwapchainCreateInfoKHR();
swapchainCreateInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; swapchainCreateInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
@ -908,7 +908,7 @@ public:
void setupSwapchainImages() void setupSwapchainImages()
{ {
// Retrieve swapchain images // Retrieve swapchain images
uint32_t objectCount = 0; std::uint32_t objectCount = 0;
if (vkGetSwapchainImagesKHR(device, swapchain, &objectCount, 0) != VK_SUCCESS) if (vkGetSwapchainImagesKHR(device, swapchain, &objectCount, 0) != VK_SUCCESS)
{ {
@ -968,7 +968,7 @@ public:
return; return;
} }
std::vector<uint32_t> buffer(static_cast<std::size_t>(file.getSize()) / sizeof(uint32_t)); std::vector<std::uint32_t> buffer(static_cast<std::size_t>(file.getSize()) / sizeof(std::uint32_t));
if (file.read(buffer.data(), file.getSize()) != file.getSize()) if (file.read(buffer.data(), file.getSize()) != file.getSize())
{ {
@ -976,7 +976,7 @@ public:
return; return;
} }
shaderModuleCreateInfo.codeSize = buffer.size() * sizeof(uint32_t); shaderModuleCreateInfo.codeSize = buffer.size() * sizeof(std::uint32_t);
shaderModuleCreateInfo.pCode = buffer.data(); shaderModuleCreateInfo.pCode = buffer.data();
if (vkCreateShaderModule(device, &shaderModuleCreateInfo, 0, &vertexShaderModule) != VK_SUCCESS) if (vkCreateShaderModule(device, &shaderModuleCreateInfo, 0, &vertexShaderModule) != VK_SUCCESS)
@ -996,7 +996,7 @@ public:
return; return;
} }
std::vector<uint32_t> buffer(static_cast<std::size_t>(file.getSize()) / sizeof(uint32_t)); std::vector<std::uint32_t> buffer(static_cast<std::size_t>(file.getSize()) / sizeof(std::uint32_t));
if (file.read(buffer.data(), file.getSize()) != file.getSize()) if (file.read(buffer.data(), file.getSize()) != file.getSize())
{ {
@ -1004,7 +1004,7 @@ public:
return; return;
} }
shaderModuleCreateInfo.codeSize = buffer.size() * sizeof(uint32_t); shaderModuleCreateInfo.codeSize = buffer.size() * sizeof(std::uint32_t);
shaderModuleCreateInfo.pCode = buffer.data(); shaderModuleCreateInfo.pCode = buffer.data();
if (vkCreateShaderModule(device, &shaderModuleCreateInfo, 0, &fragmentShaderModule) != VK_SUCCESS) if (vkCreateShaderModule(device, &shaderModuleCreateInfo, 0, &fragmentShaderModule) != VK_SUCCESS)
@ -1314,7 +1314,7 @@ public:
// We want to be able to reset command buffers after submitting them // We want to be able to reset command buffers after submitting them
VkCommandPoolCreateInfo commandPoolCreateInfo = VkCommandPoolCreateInfo(); VkCommandPoolCreateInfo commandPoolCreateInfo = VkCommandPoolCreateInfo();
commandPoolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; commandPoolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
commandPoolCreateInfo.queueFamilyIndex = static_cast<uint32_t>(queueFamilyIndex); commandPoolCreateInfo.queueFamilyIndex = static_cast<std::uint32_t>(queueFamilyIndex);
commandPoolCreateInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; commandPoolCreateInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
// Create our command pool // Create our command pool
@ -1351,7 +1351,7 @@ public:
VkPhysicalDeviceMemoryProperties memoryProperties = VkPhysicalDeviceMemoryProperties(); VkPhysicalDeviceMemoryProperties memoryProperties = VkPhysicalDeviceMemoryProperties();
vkGetPhysicalDeviceMemoryProperties(gpu, &memoryProperties); vkGetPhysicalDeviceMemoryProperties(gpu, &memoryProperties);
uint32_t memoryType = 0; std::uint32_t memoryType = 0;
for (; memoryType < memoryProperties.memoryTypeCount; ++memoryType) for (; memoryType < memoryProperties.memoryTypeCount; ++memoryType)
{ {
@ -1637,8 +1637,8 @@ public:
} }
// Helper to create a generic image with the specified size, format, usage and memory flags // Helper to create a generic image with the specified size, format, usage and memory flags
bool createImage(uint32_t width, bool createImage(std::uint32_t width,
uint32_t height, std::uint32_t height,
VkFormat format, VkFormat format,
VkImageTiling tiling, VkImageTiling tiling,
VkImageUsageFlags usage, VkImageUsageFlags usage,
@ -1674,7 +1674,7 @@ public:
VkPhysicalDeviceMemoryProperties memoryProperties = VkPhysicalDeviceMemoryProperties(); VkPhysicalDeviceMemoryProperties memoryProperties = VkPhysicalDeviceMemoryProperties();
vkGetPhysicalDeviceMemoryProperties(gpu, &memoryProperties); vkGetPhysicalDeviceMemoryProperties(gpu, &memoryProperties);
uint32_t memoryType = 0; std::uint32_t memoryType = 0;
for (; memoryType < memoryProperties.memoryTypeCount; ++memoryType) for (; memoryType < memoryProperties.memoryTypeCount; ++memoryType)
{ {
@ -2179,17 +2179,17 @@ public:
descriptorPoolSizes[0] = VkDescriptorPoolSize(); descriptorPoolSizes[0] = VkDescriptorPoolSize();
descriptorPoolSizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; descriptorPoolSizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
descriptorPoolSizes[0].descriptorCount = static_cast<uint32_t>(swapchainImages.size()); descriptorPoolSizes[0].descriptorCount = static_cast<std::uint32_t>(swapchainImages.size());
descriptorPoolSizes[1] = VkDescriptorPoolSize(); descriptorPoolSizes[1] = VkDescriptorPoolSize();
descriptorPoolSizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; descriptorPoolSizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
descriptorPoolSizes[1].descriptorCount = static_cast<uint32_t>(swapchainImages.size()); descriptorPoolSizes[1].descriptorCount = static_cast<std::uint32_t>(swapchainImages.size());
VkDescriptorPoolCreateInfo descriptorPoolCreateInfo = VkDescriptorPoolCreateInfo(); VkDescriptorPoolCreateInfo descriptorPoolCreateInfo = VkDescriptorPoolCreateInfo();
descriptorPoolCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; descriptorPoolCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
descriptorPoolCreateInfo.poolSizeCount = 2; descriptorPoolCreateInfo.poolSizeCount = 2;
descriptorPoolCreateInfo.pPoolSizes = descriptorPoolSizes; descriptorPoolCreateInfo.pPoolSizes = descriptorPoolSizes;
descriptorPoolCreateInfo.maxSets = static_cast<uint32_t>(swapchainImages.size()); descriptorPoolCreateInfo.maxSets = static_cast<std::uint32_t>(swapchainImages.size());
// Create the descriptor pool // Create the descriptor pool
if (vkCreateDescriptorPool(device, &descriptorPoolCreateInfo, 0, &descriptorPool) != VK_SUCCESS) if (vkCreateDescriptorPool(device, &descriptorPoolCreateInfo, 0, &descriptorPool) != VK_SUCCESS)
@ -2208,7 +2208,7 @@ public:
VkDescriptorSetAllocateInfo descriptorSetAllocateInfo = VkDescriptorSetAllocateInfo(); VkDescriptorSetAllocateInfo descriptorSetAllocateInfo = VkDescriptorSetAllocateInfo();
descriptorSetAllocateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; descriptorSetAllocateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
descriptorSetAllocateInfo.descriptorPool = descriptorPool; descriptorSetAllocateInfo.descriptorPool = descriptorPool;
descriptorSetAllocateInfo.descriptorSetCount = static_cast<uint32_t>(swapchainImages.size()); descriptorSetAllocateInfo.descriptorSetCount = static_cast<std::uint32_t>(swapchainImages.size());
descriptorSetAllocateInfo.pSetLayouts = descriptorSetLayouts.data(); descriptorSetAllocateInfo.pSetLayouts = descriptorSetLayouts.data();
descriptorSets.resize(swapchainImages.size()); descriptorSets.resize(swapchainImages.size());
@ -2272,7 +2272,7 @@ public:
commandBufferAllocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; commandBufferAllocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
commandBufferAllocateInfo.commandPool = commandPool; commandBufferAllocateInfo.commandPool = commandPool;
commandBufferAllocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; commandBufferAllocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
commandBufferAllocateInfo.commandBufferCount = static_cast<uint32_t>(commandBuffers.size()); commandBufferAllocateInfo.commandBufferCount = static_cast<std::uint32_t>(commandBuffers.size());
// Allocate the command buffers from our command pool // Allocate the command buffers from our command pool
if (vkAllocateCommandBuffers(device, &commandBufferAllocateInfo, commandBuffers.data()) != VK_SUCCESS) if (vkAllocateCommandBuffers(device, &commandBufferAllocateInfo, commandBuffers.data()) != VK_SUCCESS)
@ -2480,7 +2480,7 @@ public:
void draw() void draw()
{ {
uint32_t imageIndex = 0; std::uint32_t imageIndex = 0;
// If the objects we need to submit this frame are still pending, wait here // If the objects we need to submit this frame are still pending, wait here
vkWaitForFences(device, 1, &fences[currentFrame], VK_TRUE, std::numeric_limits<uint64_t>::max()); vkWaitForFences(device, 1, &fences[currentFrame], VK_TRUE, std::numeric_limits<uint64_t>::max());

3
include/SFML/Config.hpp
View File

@ -167,9 +167,6 @@
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
namespace sf namespace sf
{ {
// 32 bits integer types
using Uint32 = std::uint32_t;
// 64 bits integer types // 64 bits integer types
using Int64 = std::int64_t; using Int64 = std::int64_t;
using Uint64 = std::uint64_t; using Uint64 = std::uint64_t;

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

@ -66,7 +66,7 @@ public:
/// \param color Number containing the RGBA components (in that order) /// \param color Number containing the RGBA components (in that order)
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
constexpr explicit Color(Uint32 color); constexpr explicit Color(std::uint32_t color);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Retrieve the color as a 32-bit unsigned integer /// \brief Retrieve the color as a 32-bit unsigned integer
@ -74,7 +74,7 @@ public:
/// \return Color represented as a 32-bit unsigned integer /// \return Color represented as a 32-bit unsigned integer
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
constexpr Uint32 toInteger() const; constexpr std::uint32_t toInteger() const;
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
// Static member data // Static member data

6
include/SFML/Graphics/Color.inl
View File

@ -40,7 +40,7 @@ a(alpha)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
constexpr Color::Color(Uint32 color) : constexpr Color::Color(std::uint32_t color) :
r(static_cast<std::uint8_t>((color & 0xff000000) >> 24)), r(static_cast<std::uint8_t>((color & 0xff000000) >> 24)),
g(static_cast<std::uint8_t>((color & 0x00ff0000) >> 16)), g(static_cast<std::uint8_t>((color & 0x00ff0000) >> 16)),
b(static_cast<std::uint8_t>((color & 0x0000ff00) >> 8)), b(static_cast<std::uint8_t>((color & 0x0000ff00) >> 8)),
@ -50,9 +50,9 @@ a(static_cast<std::uint8_t>(color & 0x000000ff))
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
constexpr Uint32 Color::toInteger() const constexpr std::uint32_t Color::toInteger() const
{ {
return static_cast<Uint32>((r << 24) | (g << 16) | (b << 8) | a); return static_cast<std::uint32_t>((r << 24) | (g << 16) | (b << 8) | a);
} }

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

@ -199,7 +199,7 @@ public:
/// \return The glyph corresponding to \a codePoint and \a characterSize /// \return The glyph corresponding to \a codePoint and \a characterSize
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
const Glyph& getGlyph(Uint32 codePoint, unsigned int characterSize, bool bold, float outlineThickness = 0) const; const Glyph& getGlyph(std::uint32_t codePoint, unsigned int characterSize, bool bold, float outlineThickness = 0) const;
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Determine if this font has a glyph representing the requested code point /// \brief Determine if this font has a glyph representing the requested code point
@ -217,7 +217,7 @@ public:
/// \return True if the codepoint has a glyph representation, false otherwise /// \return True if the codepoint has a glyph representation, false otherwise
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
bool hasGlyph(Uint32 codePoint) const; bool hasGlyph(std::uint32_t codePoint) const;
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Get the kerning offset of two glyphs /// \brief Get the kerning offset of two glyphs
@ -235,7 +235,7 @@ public:
/// \return Kerning value for \a first and \a second, in pixels /// \return Kerning value for \a first and \a second, in pixels
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
float getKerning(Uint32 first, Uint32 second, unsigned int characterSize, bool bold = false) const; float getKerning(std::uint32_t first, std::uint32_t second, unsigned int characterSize, bool bold = false) const;
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Get the line spacing /// \brief Get the line spacing
@ -391,7 +391,7 @@ private:
/// \return The glyph corresponding to \a codePoint and \a characterSize /// \return The glyph corresponding to \a codePoint and \a characterSize
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
Glyph loadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold, float outlineThickness) const; Glyph loadGlyph(std::uint32_t codePoint, unsigned int characterSize, bool bold, float outlineThickness) const;
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Find a suitable rectangle within the texture for a glyph /// \brief Find a suitable rectangle within the texture for a glyph

2
include/SFML/Graphics/RenderWindow.hpp
View File

@ -73,7 +73,7 @@ public:
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
RenderWindow(VideoMode mode, RenderWindow(VideoMode mode,
const String& title, const String& title,
Uint32 style = Style::Default, std::uint32_t style = Style::Default,
const ContextSettings& settings = ContextSettings()); const ContextSettings& settings = ContextSettings());
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////

6
include/SFML/Graphics/Text.hpp
View File

@ -215,7 +215,7 @@ public:
/// \see getStyle /// \see getStyle
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void setStyle(Uint32 style); void setStyle(std::uint32_t style);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Set the fill color of the text /// \brief Set the fill color of the text
@ -329,7 +329,7 @@ public:
/// \see setStyle /// \see setStyle
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
Uint32 getStyle() const; std::uint32_t getStyle() const;
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Get the fill color of the text /// \brief Get the fill color of the text
@ -433,7 +433,7 @@ private:
unsigned int m_characterSize; //!< Base size of characters, in pixels unsigned int m_characterSize; //!< Base size of characters, in pixels
float m_letterSpacingFactor; //!< Spacing factor between letters float m_letterSpacingFactor; //!< Spacing factor between letters
float m_lineSpacingFactor; //!< Spacing factor between lines float m_lineSpacingFactor; //!< Spacing factor between lines
Uint32 m_style; //!< Text style (see Style enum) std::uint32_t m_style; //!< Text style (see Style enum)
Color m_fillColor; //!< Text fill color Color m_fillColor; //!< Text fill color
Color m_outlineColor; //!< Text outline color Color m_outlineColor; //!< Text outline color
float m_outlineThickness; //!< Thickness of the text's outline float m_outlineThickness; //!< Thickness of the text's outline

6
include/SFML/Network/IpAddress.hpp
View File

@ -86,7 +86,7 @@ public:
/// \see toInteger /// \see toInteger
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
explicit IpAddress(Uint32 address); explicit IpAddress(std::uint32_t address);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Get a string representation of the address /// \brief Get a string representation of the address
@ -116,7 +116,7 @@ public:
/// \see toString /// \see toString
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
Uint32 toInteger() const; std::uint32_t toInteger() const;
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Get the computer's local address /// \brief Get the computer's local address
@ -171,7 +171,7 @@ private:
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
// Member data // Member data
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
Uint32 m_address; //!< Address stored as an unsigned 32 bits integer std::uint32_t m_address; //!< Address stored as an unsigned 32 bits integer
}; };
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////

8
include/SFML/Network/Packet.hpp
View File

@ -238,7 +238,7 @@ public:
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \overload /// \overload
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
Packet& operator>>(Uint32& data); Packet& operator>>(std::uint32_t& data);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \overload /// \overload
@ -319,7 +319,7 @@ public:
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \overload /// \overload
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
Packet& operator<<(Uint32 data); Packet& operator<<(std::uint32_t data);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \overload /// \overload
@ -468,7 +468,7 @@ private:
/// ///
/// Usage example: /// Usage example:
/// \code /// \code
/// sf::Uint32 x = 24; /// std::uint32_t x = 24;
/// std::string s = "hello"; /// std::string s = "hello";
/// double d = 5.89; /// double d = 5.89;
/// ///
@ -486,7 +486,7 @@ private:
/// socket.receive(packet); /// socket.receive(packet);
/// ///
/// // Extract the variables contained in the packet /// // Extract the variables contained in the packet
/// sf::Uint32 x; /// std::uint32_t x;
/// std::string s; /// std::string s;
/// double d; /// double d;
/// if (packet >> x >> s >> d) /// if (packet >> x >> s >> d)

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

@ -221,7 +221,7 @@ private:
{ {
PendingPacket(); PendingPacket();
Uint32 Size; //!< Data of packet size std::uint32_t Size; //!< Data of packet size
std::size_t SizeReceived; //!< Number of size bytes received so far std::size_t SizeReceived; //!< Number of size bytes received so far
std::vector<char> Data; //!< Data of the packet std::vector<char> Data; //!< Data of the packet
}; };

24
include/SFML/System/String.hpp
View File

@ -50,8 +50,8 @@ public:
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
// Types // Types
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
using Iterator = std::basic_string<Uint32>::iterator; //!< Iterator type using Iterator = std::basic_string<std::uint32_t>::iterator; //!< Iterator type
using ConstIterator = std::basic_string<Uint32>::const_iterator; //!< Read-only iterator type using ConstIterator = std::basic_string<std::uint32_t>::const_iterator; //!< Read-only iterator type
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
// Static member data // Static member data
@ -92,7 +92,7 @@ public:
/// \param utf32Char UTF-32 character to convert /// \param utf32Char UTF-32 character to convert
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
String(Uint32 utf32Char); String(std::uint32_t utf32Char);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Construct from a null-terminated C-style ANSI string and a locale /// \brief Construct from a null-terminated C-style ANSI string and a locale
@ -140,7 +140,7 @@ public:
/// \param utf32String UTF-32 string to assign /// \param utf32String UTF-32 string to assign
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
String(const Uint32* utf32String); String(const std::uint32_t* utf32String);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Construct from an UTF-32 string /// \brief Construct from an UTF-32 string
@ -148,7 +148,7 @@ public:
/// \param utf32String UTF-32 string to assign /// \param utf32String UTF-32 string to assign
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
String(const std::basic_string<Uint32>& utf32String); String(const std::basic_string<std::uint32_t>& utf32String);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Copy constructor /// \brief Copy constructor
@ -202,8 +202,8 @@ public:
/// \brief Create a new sf::String from a UTF-32 encoded string /// \brief Create a new sf::String from a UTF-32 encoded string
/// ///
/// This function is provided for consistency, it is equivalent to /// This function is provided for consistency, it is equivalent to
/// using the constructors that takes a const sf::Uint32* or /// using the constructors that takes a const std::uint32_t* or
/// a std::basic_string<sf::Uint32>. /// a std::basic_string<std::uint32_t>.
/// ///
/// \param begin Forward iterator to the beginning of the UTF-32 sequence /// \param begin Forward iterator to the beginning of the UTF-32 sequence
/// \param end Forward iterator to the end of the UTF-32 sequence /// \param end Forward iterator to the end of the UTF-32 sequence
@ -309,7 +309,7 @@ public:
/// \see toUtf8, toUtf16 /// \see toUtf8, toUtf16
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
std::basic_string<Uint32> toUtf32() const; std::basic_string<std::uint32_t> toUtf32() const;
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Overload of assignment operator /// \brief Overload of assignment operator
@ -342,7 +342,7 @@ public:
/// \return Character at position \a index /// \return Character at position \a index
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
Uint32 operator[](std::size_t index) const; std::uint32_t operator[](std::size_t index) const;
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Overload of [] operator to access a character by its position /// \brief Overload of [] operator to access a character by its position
@ -355,7 +355,7 @@ public:
/// \return Reference to the character at position \a index /// \return Reference to the character at position \a index
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
Uint32& operator[](std::size_t index); std::uint32_t& operator[](std::size_t index);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Clear the string /// \brief Clear the string
@ -479,7 +479,7 @@ public:
/// \return Read-only pointer to the array of characters /// \return Read-only pointer to the array of characters
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
const Uint32* getData() const; const std::uint32_t* getData() const;
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Return an iterator to the beginning of the string /// \brief Return an iterator to the beginning of the string
@ -536,7 +536,7 @@ private:
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
// Member data // Member data
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
std::basic_string<Uint32> m_string; //!< Internal string of UTF-32 characters std::basic_string<std::uint32_t> m_string; //!< Internal string of UTF-32 characters
}; };
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////

20
include/SFML/System/Utf.hpp
View File

@ -70,7 +70,7 @@ public:
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
template <typename In> template <typename In>
static In decode(In begin, In end, Uint32& output, Uint32 replacement = 0); static In decode(In begin, In end, std::uint32_t& output, std::uint32_t replacement = 0);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Encode a single UTF-8 character /// \brief Encode a single UTF-8 character
@ -86,7 +86,7 @@ public:
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
template <typename Out> template <typename Out>
static Out encode(Uint32 input, Out output, std::uint8_t replacement = 0); static Out encode(std::uint32_t input, Out output, std::uint8_t replacement = 0);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Advance to the next UTF-8 character /// \brief Advance to the next UTF-8 character
@ -276,7 +276,7 @@ public:
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
template <typename In> template <typename In>
static In decode(In begin, In end, Uint32& output, Uint32 replacement = 0); static In decode(In begin, In end, std::uint32_t& output, std::uint32_t replacement = 0);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Encode a single UTF-16 character /// \brief Encode a single UTF-16 character
@ -292,7 +292,7 @@ public:
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
template <typename Out> template <typename Out>
static Out encode(Uint32 input, Out output, std::uint16_t replacement = 0); static Out encode(std::uint32_t input, Out output, std::uint16_t replacement = 0);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Advance to the next UTF-16 character /// \brief Advance to the next UTF-16 character
@ -483,7 +483,7 @@ public:
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
template <typename In> template <typename In>
static In decode(In begin, In end, Uint32& output, Uint32 replacement = 0); static In decode(In begin, In end, std::uint32_t& output, std::uint32_t replacement = 0);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Encode a single UTF-32 character /// \brief Encode a single UTF-32 character
@ -500,7 +500,7 @@ public:
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
template <typename Out> template <typename Out>
static Out encode(Uint32 input, Out output, Uint32 replacement = 0); static Out encode(std::uint32_t input, Out output, std::uint32_t replacement = 0);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Advance to the next UTF-32 character /// \brief Advance to the next UTF-32 character
@ -679,7 +679,7 @@ public:
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
template <typename In> template <typename In>
static Uint32 decodeAnsi(In input, const std::locale& locale = std::locale()); static std::uint32_t decodeAnsi(In input, const std::locale& locale = std::locale());
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Decode a single wide character to UTF-32 /// \brief Decode a single wide character to UTF-32
@ -694,7 +694,7 @@ public:
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
template <typename In> template <typename In>
static Uint32 decodeWide(In input); static std::uint32_t decodeWide(In input);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Encode a single UTF-32 character to ANSI /// \brief Encode a single UTF-32 character to ANSI
@ -712,7 +712,7 @@ public:
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
template <typename Out> template <typename Out>
static Out encodeAnsi(Uint32 codepoint, Out output, char replacement = 0, const std::locale& locale = std::locale()); static Out encodeAnsi(std::uint32_t codepoint, Out output, char replacement = 0, const std::locale& locale = std::locale());
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Encode a single UTF-32 character to wide /// \brief Encode a single UTF-32 character to wide
@ -729,7 +729,7 @@ public:
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
template <typename Out> template <typename Out>
static Out encodeWide(Uint32 codepoint, Out output, wchar_t replacement = 0); static Out encodeWide(std::uint32_t codepoint, Out output, wchar_t replacement = 0);
}; };
#include <SFML/System/Utf.inl> #include <SFML/System/Utf.inl>

68
include/SFML/System/Utf.inl
View File

@ -45,7 +45,7 @@ OutputIt priv::copy(InputIt first, InputIt last, OutputIt d_first)
} }
template <typename In> template <typename In>
In Utf<8>::decode(In begin, In end, Uint32& output, Uint32 replacement) In Utf<8>::decode(In begin, In end, std::uint32_t& output, std::uint32_t replacement)
{ {
// clang-format off // clang-format off
// Some useful precomputed data // Some useful precomputed data
@ -61,7 +61,7 @@ In Utf<8>::decode(In begin, In end, Uint32& output, Uint32 replacement)
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5
}; };
static constexpr Uint32 offsets[6] = static constexpr std::uint32_t offsets[6] =
{ {
0x00000000, 0x00003080, 0x000E2080, 0x03C82080, 0xFA082080, 0x82082080 0x00000000, 0x00003080, 0x000E2080, 0x03C82080, 0xFA082080, 0x82082080
}; };
@ -100,7 +100,7 @@ In Utf<8>::decode(In begin, In end, Uint32& output, Uint32 replacement)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
template <typename Out> template <typename Out>
Out Utf<8>::encode(Uint32 input, Out output, std::uint8_t replacement) Out Utf<8>::encode(std::uint32_t input, Out output, std::uint8_t replacement)
{ {
// Some useful precomputed data // Some useful precomputed data
static constexpr std::uint8_t firstBytes[7] = {0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC}; static constexpr std::uint8_t firstBytes[7] = {0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC};
@ -151,7 +151,7 @@ Out Utf<8>::encode(Uint32 input, Out output, std::uint8_t replacement)
template <typename In> template <typename In>
In Utf<8>::next(In begin, In end) In Utf<8>::next(In begin, In end)
{ {
Uint32 codepoint; std::uint32_t codepoint;
return decode(begin, end, codepoint); return decode(begin, end, codepoint);
} }
@ -177,8 +177,8 @@ Out Utf<8>::fromAnsi(In begin, In end, Out output, const std::locale& locale)
{ {
while (begin < end) while (begin < end)
{ {
Uint32 codepoint = Utf<32>::decodeAnsi(*begin++, locale); std::uint32_t codepoint = Utf<32>::decodeAnsi(*begin++, locale);
output = encode(codepoint, output); output = encode(codepoint, output);
} }
return output; return output;
@ -191,8 +191,8 @@ Out Utf<8>::fromWide(In begin, In end, Out output)
{ {
while (begin < end) while (begin < end)
{ {
Uint32 codepoint = Utf<32>::decodeWide(*begin++); std::uint32_t codepoint = Utf<32>::decodeWide(*begin++);
output = encode(codepoint, output); output = encode(codepoint, output);
} }
return output; return output;
@ -218,7 +218,7 @@ Out Utf<8>::toAnsi(In begin, In end, Out output, char replacement, const std::lo
{ {
while (begin < end) while (begin < end)
{ {
Uint32 codepoint; std::uint32_t codepoint;
begin = decode(begin, end, codepoint); begin = decode(begin, end, codepoint);
output = Utf<32>::encodeAnsi(codepoint, output, replacement, locale); output = Utf<32>::encodeAnsi(codepoint, output, replacement, locale);
} }
@ -233,7 +233,7 @@ Out Utf<8>::toWide(In begin, In end, Out output, wchar_t replacement)
{ {
while (begin < end) while (begin < end)
{ {
Uint32 codepoint; std::uint32_t codepoint;
begin = decode(begin, end, codepoint); begin = decode(begin, end, codepoint);
output = Utf<32>::encodeWide(codepoint, output, replacement); output = Utf<32>::encodeWide(codepoint, output, replacement);
} }
@ -250,7 +250,7 @@ Out Utf<8>::toLatin1(In begin, In end, Out output, char replacement)
// and can thus be treated as (a sub-range of) UTF-32 // and can thus be treated as (a sub-range of) UTF-32
while (begin < end) while (begin < end)
{ {
Uint32 codepoint; std::uint32_t codepoint;
begin = decode(begin, end, codepoint); begin = decode(begin, end, codepoint);
*output++ = codepoint < 256 ? static_cast<char>(codepoint) : replacement; *output++ = codepoint < 256 ? static_cast<char>(codepoint) : replacement;
} }
@ -273,7 +273,7 @@ Out Utf<8>::toUtf16(In begin, In end, Out output)
{ {
while (begin < end) while (begin < end)
{ {
Uint32 codepoint; std::uint32_t codepoint;
begin = decode(begin, end, codepoint); begin = decode(begin, end, codepoint);
output = Utf<16>::encode(codepoint, output); output = Utf<16>::encode(codepoint, output);
} }
@ -288,7 +288,7 @@ Out Utf<8>::toUtf32(In begin, In end, Out output)
{ {
while (begin < end) while (begin < end)
{ {
Uint32 codepoint; std::uint32_t codepoint;
begin = decode(begin, end, codepoint); begin = decode(begin, end, codepoint);
*output++ = codepoint; *output++ = codepoint;
} }
@ -299,7 +299,7 @@ Out Utf<8>::toUtf32(In begin, In end, Out output)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
template <typename In> template <typename In>
In Utf<16>::decode(In begin, In end, Uint32& output, Uint32 replacement) In Utf<16>::decode(In begin, In end, std::uint32_t& output, std::uint32_t replacement)
{ {
std::uint16_t first = *begin++; std::uint16_t first = *begin++;
@ -308,7 +308,7 @@ In Utf<16>::decode(In begin, In end, Uint32& output, Uint32 replacement)
{ {
if (begin < end) if (begin < end)
{ {
Uint32 second = *begin++; std::uint32_t second = *begin++;
if ((second >= 0xDC00) && (second <= 0xDFFF)) if ((second >= 0xDC00) && (second <= 0xDFFF))
{ {
// The second element is valid: convert the two elements to a UTF-32 character // The second element is valid: convert the two elements to a UTF-32 character
@ -339,7 +339,7 @@ In Utf<16>::decode(In begin, In end, Uint32& output, Uint32 replacement)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
template <typename Out> template <typename Out>
Out Utf<16>::encode(Uint32 input, Out output, std::uint16_t replacement) Out Utf<16>::encode(std::uint32_t input, Out output, std::uint16_t replacement)
{ {
if (input <= 0xFFFF) if (input <= 0xFFFF)
{ {
@ -378,7 +378,7 @@ Out Utf<16>::encode(Uint32 input, Out output, std::uint16_t replacement)
template <typename In> template <typename In>
In Utf<16>::next(In begin, In end) In Utf<16>::next(In begin, In end)
{ {
Uint32 codepoint; std::uint32_t codepoint;
return decode(begin, end, codepoint); return decode(begin, end, codepoint);
} }
@ -404,8 +404,8 @@ Out Utf<16>::fromAnsi(In begin, In end, Out output, const std::locale& locale)
{ {
while (begin < end) while (begin < end)
{ {
Uint32 codepoint = Utf<32>::decodeAnsi(*begin++, locale); std::uint32_t codepoint = Utf<32>::decodeAnsi(*begin++, locale);
output = encode(codepoint, output); output = encode(codepoint, output);
} }
return output; return output;
@ -418,8 +418,8 @@ Out Utf<16>::fromWide(In begin, In end, Out output)
{ {
while (begin < end) while (begin < end)
{ {
Uint32 codepoint = Utf<32>::decodeWide(*begin++); std::uint32_t codepoint = Utf<32>::decodeWide(*begin++);
output = encode(codepoint, output); output = encode(codepoint, output);
} }
return output; return output;
@ -442,7 +442,7 @@ Out Utf<16>::toAnsi(In begin, In end, Out output, char replacement, const std::l
{ {
while (begin < end) while (begin < end)
{ {
Uint32 codepoint; std::uint32_t codepoint;
begin = decode(begin, end, codepoint); begin = decode(begin, end, codepoint);
output = Utf<32>::encodeAnsi(codepoint, output, replacement, locale); output = Utf<32>::encodeAnsi(codepoint, output, replacement, locale);
} }
@ -457,7 +457,7 @@ Out Utf<16>::toWide(In begin, In end, Out output, wchar_t replacement)
{ {
while (begin < end) while (begin < end)
{ {
Uint32 codepoint; std::uint32_t codepoint;
begin = decode(begin, end, codepoint); begin = decode(begin, end, codepoint);
output = Utf<32>::encodeWide(codepoint, output, replacement); output = Utf<32>::encodeWide(codepoint, output, replacement);
} }
@ -488,7 +488,7 @@ Out Utf<16>::toUtf8(In begin, In end, Out output)
{ {
while (begin < end) while (begin < end)
{ {
Uint32 codepoint; std::uint32_t codepoint;
begin = decode(begin, end, codepoint); begin = decode(begin, end, codepoint);
output = Utf<8>::encode(codepoint, output); output = Utf<8>::encode(codepoint, output);
} }
@ -511,7 +511,7 @@ Out Utf<16>::toUtf32(In begin, In end, Out output)
{ {
while (begin < end) while (begin < end)
{ {
Uint32 codepoint; std::uint32_t codepoint;
begin = decode(begin, end, codepoint); begin = decode(begin, end, codepoint);
*output++ = codepoint; *output++ = codepoint;
} }
@ -522,7 +522,7 @@ Out Utf<16>::toUtf32(In begin, In end, Out output)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
template <typename In> template <typename In>
In Utf<32>::decode(In begin, In /*end*/, Uint32& output, Uint32 /*replacement*/) In Utf<32>::decode(In begin, In /*end*/, std::uint32_t& output, std::uint32_t /*replacement*/)
{ {
output = *begin++; output = *begin++;
return begin; return begin;
@ -531,7 +531,7 @@ In Utf<32>::decode(In begin, In /*end*/, Uint32& output, Uint32 /*replacement*/)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
template <typename Out> template <typename Out>
Out Utf<32>::encode(Uint32 input, Out output, Uint32 /*replacement*/) Out Utf<32>::encode(std::uint32_t input, Out output, std::uint32_t /*replacement*/)
{ {
*output++ = input; *output++ = input;
return output; return output;
@ -655,7 +655,7 @@ Out Utf<32>::toUtf32(In begin, In end, Out output)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
template <typename In> template <typename In>
Uint32 Utf<32>::decodeAnsi(In input, [[maybe_unused]] const std::locale& locale) std::uint32_t Utf<32>::decodeAnsi(In input, [[maybe_unused]] const std::locale& locale)
{ {
// On Windows, GCC's standard library (glibc++) has almost // On Windows, GCC's standard library (glibc++) has almost
// no support for Unicode stuff. As a consequence, in this // no support for Unicode stuff. As a consequence, in this
@ -668,7 +668,7 @@ Uint32 Utf<32>::decodeAnsi(In input, [[maybe_unused]] const std::locale& locale)
wchar_t character = 0; wchar_t character = 0;
mbtowc(&character, &input, 1); mbtowc(&character, &input, 1);
return static_cast<Uint32>(character); return static_cast<std::uint32_t>(character);
#else #else
@ -676,7 +676,7 @@ Uint32 Utf<32>::decodeAnsi(In input, [[maybe_unused]] const std::locale& locale)
const auto& facet = std::use_facet<std::ctype<wchar_t>>(locale); const auto& facet = std::use_facet<std::ctype<wchar_t>>(locale);
// Use the facet to convert each character of the input string // Use the facet to convert each character of the input string
return static_cast<Uint32>(facet.widen(input)); return static_cast<std::uint32_t>(facet.widen(input));
#endif #endif
} }
@ -684,7 +684,7 @@ Uint32 Utf<32>::decodeAnsi(In input, [[maybe_unused]] const std::locale& locale)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
template <typename In> template <typename In>
Uint32 Utf<32>::decodeWide(In input) std::uint32_t Utf<32>::decodeWide(In input)
{ {
// The encoding of wide characters is not well defined and is left to the system; // The encoding of wide characters is not well defined and is left to the system;
// however we can safely assume that it is UCS-2 on Windows and // however we can safely assume that it is UCS-2 on Windows and
@ -692,13 +692,13 @@ Uint32 Utf<32>::decodeWide(In input)
// In both cases, a simple copy is enough (UCS-2 is a subset of UCS-4, // In both cases, a simple copy is enough (UCS-2 is a subset of UCS-4,
// and UCS-4 *is* UTF-32). // and UCS-4 *is* UTF-32).
return static_cast<Uint32>(input); return static_cast<std::uint32_t>(input);
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
template <typename Out> template <typename Out>
Out Utf<32>::encodeAnsi(Uint32 codepoint, Out output, char replacement, [[maybe_unused]] const std::locale& locale) Out Utf<32>::encodeAnsi(std::uint32_t codepoint, Out output, char replacement, [[maybe_unused]] const std::locale& locale)
{ {
// On Windows, gcc's standard library (glibc++) has almost // On Windows, gcc's standard library (glibc++) has almost
// no support for Unicode stuff. As a consequence, in this // no support for Unicode stuff. As a consequence, in this
@ -733,7 +733,7 @@ Out Utf<32>::encodeAnsi(Uint32 codepoint, Out output, char replacement, [[maybe_
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
template <typename Out> template <typename Out>
Out Utf<32>::encodeWide(Uint32 codepoint, Out output, wchar_t replacement) Out Utf<32>::encodeWide(std::uint32_t codepoint, Out output, wchar_t replacement)
{ {
// The encoding of wide characters is not well defined and is left to the system; // The encoding of wide characters is not well defined and is left to the system;
// however we can safely assume that it is UCS-2 on Windows and // however we can safely assume that it is UCS-2 on Windows and

14
include/SFML/Window/ContextSettings.hpp
View File

@ -80,13 +80,13 @@ struct ContextSettings
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
// Member data // Member data
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
unsigned int depthBits; //!< Bits of the depth buffer unsigned int depthBits; //!< Bits of the depth buffer
unsigned int stencilBits; //!< Bits of the stencil buffer unsigned int stencilBits; //!< Bits of the stencil buffer
unsigned int antialiasingLevel; //!< Level of antialiasing unsigned int antialiasingLevel; //!< Level of antialiasing
unsigned int majorVersion; //!< Major number of the context version to create unsigned int majorVersion; //!< Major number of the context version to create
unsigned int minorVersion; //!< Minor number of the context version to create unsigned int minorVersion; //!< Minor number of the context version to create
Uint32 attributeFlags; //!< The attribute flags to create the context with std::uint32_t attributeFlags; //!< The attribute flags to create the context with
bool sRgbCapable; //!< Whether the context framebuffer is sRGB capable bool sRgbCapable; //!< Whether the context framebuffer is sRGB capable
}; };
} // namespace sf } // namespace sf

2
include/SFML/Window/Event.hpp
View File

@ -74,7 +74,7 @@ public:
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
struct TextEvent struct TextEvent
{ {
Uint32 unicode; //!< UTF-32 Unicode value of the character std::uint32_t unicode; //!< UTF-32 Unicode value of the character
}; };
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////

6
include/SFML/Window/Window.hpp
View File

@ -83,7 +83,7 @@ public:
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
Window(VideoMode mode, Window(VideoMode mode,
const String& title, const String& title,
Uint32 style = Style::Default, std::uint32_t style = Style::Default,
const ContextSettings& settings = ContextSettings()); const ContextSettings& settings = ContextSettings());
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
@ -122,7 +122,7 @@ public:
/// \param style %Window style, a bitwise OR combination of sf::Style enumerators /// \param style %Window style, a bitwise OR combination of sf::Style enumerators
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void create(VideoMode mode, const String& title, Uint32 style = Style::Default) override; void create(VideoMode mode, const String& title, std::uint32_t style = Style::Default) override;
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Create (or recreate) the window /// \brief Create (or recreate) the window
@ -141,7 +141,7 @@ public:
/// \param settings Additional settings for the underlying OpenGL context /// \param settings Additional settings for the underlying OpenGL context
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
virtual void create(VideoMode mode, const String& title, Uint32 style, const ContextSettings& settings); virtual void create(VideoMode mode, const String& title, std::uint32_t style, const ContextSettings& settings);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Create (or recreate) the window from an existing control /// \brief Create (or recreate) the window from an existing control

4
include/SFML/Window/WindowBase.hpp
View File

@ -81,7 +81,7 @@ public:
/// \param style %Window style, a bitwise OR combination of sf::Style enumerators /// \param style %Window style, a bitwise OR combination of sf::Style enumerators
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
WindowBase(VideoMode mode, const String& title, Uint32 style = Style::Default); WindowBase(VideoMode mode, const String& title, std::uint32_t style = Style::Default);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Construct the window from an existing control /// \brief Construct the window from an existing control
@ -123,7 +123,7 @@ public:
/// \param style %Window style, a bitwise OR combination of sf::Style enumerators /// \param style %Window style, a bitwise OR combination of sf::Style enumerators
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
virtual void create(VideoMode mode, const String& title, Uint32 style = Style::Default); virtual void create(VideoMode mode, const String& title, std::uint32_t style = Style::Default);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Create (or recreate) the window from an existing control /// \brief Create (or recreate) the window from an existing control

20
src/SFML/Audio/SoundFileReaderWav.cpp
View File

@ -68,24 +68,24 @@ bool decode(sf::InputStream& stream, std::uint16_t& value)
return true; return true;
} }
bool decode24bit(sf::InputStream& stream, sf::Uint32& value) bool decode24bit(sf::InputStream& stream, std::uint32_t& value)
{ {
unsigned char bytes[3]; unsigned char bytes[3];
if (static_cast<std::size_t>(stream.read(bytes, static_cast<sf::Int64>(sizeof(bytes)))) != sizeof(bytes)) if (static_cast<std::size_t>(stream.read(bytes, static_cast<sf::Int64>(sizeof(bytes)))) != sizeof(bytes))
return false; return false;
value = static_cast<sf::Uint32>(bytes[0] | (bytes[1] << 8) | (bytes[2] << 16)); value = static_cast<std::uint32_t>(bytes[0] | (bytes[1] << 8) | (bytes[2] << 16));
return true; return true;
} }
bool decode(sf::InputStream& stream, sf::Uint32& value) bool decode(sf::InputStream& stream, std::uint32_t& value)
{ {
unsigned char bytes[sizeof(value)]; unsigned char bytes[sizeof(value)];
if (static_cast<std::size_t>(stream.read(bytes, static_cast<sf::Int64>(sizeof(bytes)))) != sizeof(bytes)) if (static_cast<std::size_t>(stream.read(bytes, static_cast<sf::Int64>(sizeof(bytes)))) != sizeof(bytes))
return false; return false;
value = static_cast<sf::Uint32>(bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24)); value = static_cast<std::uint32_t>(bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24));
return true; return true;
} }
@ -184,7 +184,7 @@ Uint64 SoundFileReaderWav::read(std::int16_t* samples, Uint64 maxCount)
case 3: case 3:
{ {
Uint32 sample = 0; std::uint32_t sample = 0;
if (decode24bit(*m_stream, sample)) if (decode24bit(*m_stream, sample))
*samples++ = static_cast<std::int16_t>(sample >> 8); *samples++ = static_cast<std::int16_t>(sample >> 8);
else else
@ -194,7 +194,7 @@ Uint64 SoundFileReaderWav::read(std::int16_t* samples, Uint64 maxCount)
case 4: case 4:
{ {
Uint32 sample = 0; std::uint32_t sample = 0;
if (decode(*m_stream, sample)) if (decode(*m_stream, sample))
*samples++ = static_cast<std::int16_t>(sample >> 16); *samples++ = static_cast<std::int16_t>(sample >> 16);
else else
@ -236,7 +236,7 @@ bool SoundFileReaderWav::parseHeader(Info& info)
if (static_cast<std::size_t>(m_stream->read(subChunkId, static_cast<Int64>(sizeof(subChunkId)))) != if (static_cast<std::size_t>(m_stream->read(subChunkId, static_cast<Int64>(sizeof(subChunkId)))) !=
sizeof(subChunkId)) sizeof(subChunkId))
return false; return false;
Uint32 subChunkSize = 0; std::uint32_t subChunkSize = 0;
if (!decode(*m_stream, subChunkSize)) if (!decode(*m_stream, subChunkSize))
return false; return false;
Int64 subChunkStart = m_stream->tell(); Int64 subChunkStart = m_stream->tell();
@ -262,13 +262,13 @@ bool SoundFileReaderWav::parseHeader(Info& info)
info.channelCount = channelCount; info.channelCount = channelCount;
// Sample rate // Sample rate
Uint32 sampleRate = 0; std::uint32_t sampleRate = 0;
if (!decode(*m_stream, sampleRate)) if (!decode(*m_stream, sampleRate))
return false; return false;
info.sampleRate = sampleRate; info.sampleRate = sampleRate;
// Byte rate // Byte rate
Uint32 byteRate = 0; std::uint32_t byteRate = 0;
if (!decode(*m_stream, byteRate)) if (!decode(*m_stream, byteRate))
return false; return false;
@ -302,7 +302,7 @@ bool SoundFileReaderWav::parseHeader(Info& info)
return false; return false;
// Channel mask // Channel mask
Uint32 channelMask = 0; std::uint32_t channelMask = 0;
if (!decode(*m_stream, channelMask)) if (!decode(*m_stream, channelMask))
return false; return false;

12
src/SFML/Audio/SoundFileWriterWav.cpp
View File

@ -50,7 +50,7 @@ void encode(std::ostream& stream, std::uint16_t value)
stream.write(reinterpret_cast<const char*>(bytes), sizeof(bytes)); stream.write(reinterpret_cast<const char*>(bytes), sizeof(bytes));
} }
void encode(std::ostream& stream, sf::Uint32 value) void encode(std::ostream& stream, std::uint32_t value)
{ {
unsigned char bytes[] = { unsigned char bytes[] = {
static_cast<unsigned char>(value & 0x000000FF), static_cast<unsigned char>(value & 0x000000FF),
@ -128,14 +128,14 @@ bool SoundFileWriterWav::writeHeader(unsigned int sampleRate, unsigned int chann
m_file.write(mainChunkId, sizeof(mainChunkId)); m_file.write(mainChunkId, sizeof(mainChunkId));
// Write the main chunk header // Write the main chunk header
encode(m_file, static_cast<Uint32>(0)); // 0 is a placeholder, will be written later encode(m_file, static_cast<std::uint32_t>(0)); // 0 is a placeholder, will be written later
char mainChunkFormat[4] = {'W', 'A', 'V', 'E'}; char mainChunkFormat[4] = {'W', 'A', 'V', 'E'};
m_file.write(mainChunkFormat, sizeof(mainChunkFormat)); m_file.write(mainChunkFormat, sizeof(mainChunkFormat));
// Write the sub-chunk 1 ("format") id and size // Write the sub-chunk 1 ("format") id and size
char fmtChunkId[4] = {'f', 'm', 't', ' '}; char fmtChunkId[4] = {'f', 'm', 't', ' '};
m_file.write(fmtChunkId, sizeof(fmtChunkId)); m_file.write(fmtChunkId, sizeof(fmtChunkId));
Uint32 fmtChunkSize = 16; std::uint32_t fmtChunkSize = 16;
encode(m_file, fmtChunkSize); encode(m_file, fmtChunkSize);
// Write the format (PCM) // Write the format (PCM)
@ -145,7 +145,7 @@ bool SoundFileWriterWav::writeHeader(unsigned int sampleRate, unsigned int chann
// Write the sound attributes // Write the sound attributes
encode(m_file, static_cast<std::uint16_t>(channelCount)); encode(m_file, static_cast<std::uint16_t>(channelCount));
encode(m_file, sampleRate); encode(m_file, sampleRate);
Uint32 byteRate = sampleRate * channelCount * 2; std::uint32_t byteRate = sampleRate * channelCount * 2;
encode(m_file, byteRate); encode(m_file, byteRate);
auto blockAlign = static_cast<std::uint16_t>(channelCount * 2); auto blockAlign = static_cast<std::uint16_t>(channelCount * 2);
encode(m_file, blockAlign); encode(m_file, blockAlign);
@ -155,7 +155,7 @@ bool SoundFileWriterWav::writeHeader(unsigned int sampleRate, unsigned int chann
// Write the sub-chunk 2 ("data") id and size // Write the sub-chunk 2 ("data") id and size
char dataChunkId[4] = {'d', 'a', 't', 'a'}; char dataChunkId[4] = {'d', 'a', 't', 'a'};
m_file.write(dataChunkId, sizeof(dataChunkId)); m_file.write(dataChunkId, sizeof(dataChunkId));
Uint32 dataChunkSize = 0; // placeholder, will be written later std::uint32_t dataChunkSize = 0; // placeholder, will be written later
encode(m_file, dataChunkSize); encode(m_file, dataChunkSize);
return true; return true;
@ -171,7 +171,7 @@ void SoundFileWriterWav::close()
m_file.flush(); m_file.flush();
// Update the main chunk size and data sub-chunk size // Update the main chunk size and data sub-chunk size
Uint32 fileSize = static_cast<Uint32>(m_file.tellp()); std::uint32_t fileSize = static_cast<std::uint32_t>(m_file.tellp());
m_file.seekp(4); m_file.seekp(4);
encode(m_file, fileSize - 8); // 8 bytes RIFF header encode(m_file, fileSize - 8); // 8 bytes RIFF header
m_file.seekp(40); m_file.seekp(40);

2
src/SFML/Audio/SoundStream.cpp
View File

@ -425,7 +425,7 @@ bool SoundStream::fillAndPushBuffer(unsigned int bufferNum, bool immediateLoop)
// Acquire audio data, also address EOF and error cases if they occur // Acquire audio data, also address EOF and error cases if they occur
Chunk data = {nullptr, 0}; Chunk data = {nullptr, 0};
for (Uint32 retryCount = 0; !onGetData(data) && (retryCount < BufferRetries); ++retryCount) for (std::uint32_t retryCount = 0; !onGetData(data) && (retryCount < BufferRetries); ++retryCount)
{ {
// Check if the stream must loop or stop // Check if the stream must loop or stop
if (!m_loop) if (!m_loop)

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

@ -79,9 +79,9 @@ inline T reinterpret(const U& input)
} }
// Combine outline thickness, boldness and font glyph index into a single 64-bit key // Combine outline thickness, boldness and font glyph index into a single 64-bit key
sf::Uint64 combine(float outlineThickness, bool bold, sf::Uint32 index) sf::Uint64 combine(float outlineThickness, bool bold, std::uint32_t index)
{ {
return (static_cast<sf::Uint64>(reinterpret<sf::Uint32>(outlineThickness)) << 32) | return (static_cast<sf::Uint64>(reinterpret<std::uint32_t>(outlineThickness)) << 32) |
(static_cast<sf::Uint64>(bold) << 31) | index; (static_cast<sf::Uint64>(bold) << 31) | index;
} }
} // namespace } // namespace
@ -350,7 +350,7 @@ const Font::Info& Font::getInfo() const
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
const Glyph& Font::getGlyph(Uint32 codePoint, unsigned int characterSize, bool bold, float outlineThickness) const const Glyph& Font::getGlyph(std::uint32_t codePoint, unsigned int characterSize, bool bold, float outlineThickness) const
{ {
// Get the page corresponding to the character size // Get the page corresponding to the character size
GlyphTable& glyphs = loadPage(characterSize).glyphs; GlyphTable& glyphs = loadPage(characterSize).glyphs;
@ -376,14 +376,14 @@ const Glyph& Font::getGlyph(Uint32 codePoint, unsigned int characterSize, bool b
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
bool Font::hasGlyph(Uint32 codePoint) const bool Font::hasGlyph(std::uint32_t codePoint) const
{ {
return FT_Get_Char_Index(m_fontHandles ? m_fontHandles->face.get() : nullptr, codePoint) != 0; return FT_Get_Char_Index(m_fontHandles ? m_fontHandles->face.get() : nullptr, codePoint) != 0;
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
float Font::getKerning(Uint32 first, Uint32 second, unsigned int characterSize, bool bold) const float Font::getKerning(std::uint32_t first, std::uint32_t second, unsigned int characterSize, bool bold) const
{ {
// Special case where first or second is 0 (null character) // Special case where first or second is 0 (null character)
if (first == 0 || second == 0) if (first == 0 || second == 0)
@ -548,7 +548,7 @@ Font::Page& Font::loadPage(unsigned int characterSize) const
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
Glyph Font::loadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold, float outlineThickness) const Glyph Font::loadGlyph(std::uint32_t codePoint, unsigned int characterSize, bool bold, float outlineThickness) const
{ {
// The glyph to return // The glyph to return
Glyph glyph; Glyph glyph;

4
src/SFML/Graphics/RenderTarget.cpp
View File

@ -79,7 +79,7 @@ bool isActive(sf::Uint64 id)
} }
// Convert an sf::BlendMode::Factor constant to the corresponding OpenGL constant. // Convert an sf::BlendMode::Factor constant to the corresponding OpenGL constant.
sf::Uint32 factorToGlConstant(sf::BlendMode::Factor blendFactor) std::uint32_t factorToGlConstant(sf::BlendMode::Factor blendFactor)
{ {
// clang-format off // clang-format off
switch (blendFactor) switch (blendFactor)
@ -104,7 +104,7 @@ sf::Uint32 factorToGlConstant(sf::BlendMode::Factor blendFactor)
// Convert an sf::BlendMode::BlendEquation constant to the corresponding OpenGL constant. // Convert an sf::BlendMode::BlendEquation constant to the corresponding OpenGL constant.
sf::Uint32 equationToGlConstant(sf::BlendMode::Equation blendEquation) std::uint32_t equationToGlConstant(sf::BlendMode::Equation blendEquation)
{ {
switch (blendEquation) switch (blendEquation)
{ {

2
src/SFML/Graphics/RenderWindow.cpp
View File

@ -42,7 +42,7 @@ RenderWindow::RenderWindow() : m_defaultFrameBuffer(0)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
RenderWindow::RenderWindow(VideoMode mode, const String& title, Uint32 style, const ContextSettings& settings) : RenderWindow::RenderWindow(VideoMode mode, const String& title, std::uint32_t style, const ContextSettings& settings) :
m_defaultFrameBuffer(0) m_defaultFrameBuffer(0)
{ {
// Don't call the base class constructor because it contains virtual function calls // Don't call the base class constructor because it contains virtual function calls

22
src/SFML/Graphics/Text.cpp
View File

@ -205,7 +205,7 @@ void Text::setLineSpacing(float spacingFactor)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void Text::setStyle(Uint32 style) void Text::setStyle(std::uint32_t style)
{ {
if (m_style != style) if (m_style != style)
{ {
@ -298,7 +298,7 @@ float Text::getLineSpacing() const
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
Uint32 Text::getStyle() const std::uint32_t Text::getStyle() const
{ {
return m_style; return m_style;
} }
@ -344,11 +344,11 @@ Vector2f Text::findCharacterPos(std::size_t index) const
float lineSpacing = m_font->getLineSpacing(m_characterSize) * m_lineSpacingFactor; float lineSpacing = m_font->getLineSpacing(m_characterSize) * m_lineSpacingFactor;
// Compute the position // Compute the position
Vector2f position; Vector2f position;
Uint32 prevChar = 0; std::uint32_t prevChar = 0;
for (std::size_t i = 0; i < index; ++i) for (std::size_t i = 0; i < index; ++i)
{ {
Uint32 curChar = m_string[i]; std::uint32_t curChar = m_string[i];
// Apply the kerning offset // Apply the kerning offset
position.x += m_font->getKerning(prevChar, curChar, m_characterSize, isBold); position.x += m_font->getKerning(prevChar, curChar, m_characterSize, isBold);
@ -465,14 +465,14 @@ void Text::ensureGeometryUpdate() const
auto y = static_cast<float>(m_characterSize); auto y = static_cast<float>(m_characterSize);
// Create one quad for each character // Create one quad for each character
auto minX = static_cast<float>(m_characterSize); auto minX = static_cast<float>(m_characterSize);
auto minY = static_cast<float>(m_characterSize); auto minY = static_cast<float>(m_characterSize);
float maxX = 0.f; float maxX = 0.f;
float maxY = 0.f; float maxY = 0.f;
Uint32 prevChar = 0; std::uint32_t prevChar = 0;
for (std::size_t i = 0; i < m_string.getSize(); ++i) for (std::size_t i = 0; i < m_string.getSize(); ++i)
{ {
Uint32 curChar = m_string[i]; std::uint32_t curChar = m_string[i];
// Skip the \r char to avoid weird graphical issues // Skip the \r char to avoid weird graphical issues
if (curChar == U'\r') if (curChar == U'\r')

8
src/SFML/Network/IpAddress.cpp
View File

@ -62,7 +62,7 @@ std::optional<IpAddress> IpAddress::resolve(std::string_view address)
return Any; return Any;
// Try to convert the address as a byte representation ("xxx.xxx.xxx.xxx") // Try to convert the address as a byte representation ("xxx.xxx.xxx.xxx")
if (const Uint32 ip = inet_addr(address.data()); ip != INADDR_NONE) if (const std::uint32_t ip = inet_addr(address.data()); ip != INADDR_NONE)
return IpAddress(ntohl(ip)); return IpAddress(ntohl(ip));
// Not a valid address, try to convert it as a host name // Not a valid address, try to convert it as a host name
@ -75,7 +75,7 @@ std::optional<IpAddress> IpAddress::resolve(std::string_view address)
sockaddr_in sin; sockaddr_in sin;
std::memcpy(&sin, result->ai_addr, sizeof(*result->ai_addr)); std::memcpy(&sin, result->ai_addr, sizeof(*result->ai_addr));
const Uint32 ip = sin.sin_addr.s_addr; const std::uint32_t ip = sin.sin_addr.s_addr;
freeaddrinfo(result); freeaddrinfo(result);
return IpAddress(ntohl(ip)); return IpAddress(ntohl(ip));
@ -93,7 +93,7 @@ m_address(htonl(static_cast<std::uint32_t>((byte0 << 24) | (byte1 << 16) | (byte
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
IpAddress::IpAddress(Uint32 address) : m_address(htonl(address)) IpAddress::IpAddress(std::uint32_t address) : m_address(htonl(address))
{ {
} }
@ -109,7 +109,7 @@ std::string IpAddress::toString() const
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
Uint32 IpAddress::toInteger() const std::uint32_t IpAddress::toInteger() const
{ {
return ntohl(m_address); return ntohl(m_address);
} }

52
src/SFML/Network/Packet.cpp
View File

@ -188,7 +188,7 @@ Packet& Packet::operator>>(std::int32_t& data)
if (checkSize(sizeof(data))) if (checkSize(sizeof(data)))
{ {
std::memcpy(&data, &m_data[m_readPos], sizeof(data)); std::memcpy(&data, &m_data[m_readPos], sizeof(data));
data = static_cast<std::int32_t>(ntohl(static_cast<uint32_t>(data))); data = static_cast<std::int32_t>(ntohl(static_cast<std::uint32_t>(data)));
m_readPos += sizeof(data); m_readPos += sizeof(data);
} }
@ -197,7 +197,7 @@ Packet& Packet::operator>>(std::int32_t& data)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
Packet& Packet::operator>>(Uint32& data) Packet& Packet::operator>>(std::uint32_t& data)
{ {
if (checkSize(sizeof(data))) if (checkSize(sizeof(data)))
{ {
@ -284,7 +284,7 @@ Packet& Packet::operator>>(double& data)
Packet& Packet::operator>>(char* data) Packet& Packet::operator>>(char* data)
{ {
// First extract string length // First extract string length
Uint32 length = 0; std::uint32_t length = 0;
*this >> length; *this >> length;
if ((length > 0) && checkSize(length)) if ((length > 0) && checkSize(length))
@ -305,7 +305,7 @@ Packet& Packet::operator>>(char* data)
Packet& Packet::operator>>(std::string& data) Packet& Packet::operator>>(std::string& data)
{ {
// First extract string length // First extract string length
Uint32 length = 0; std::uint32_t length = 0;
*this >> length; *this >> length;
data.clear(); data.clear();
@ -326,15 +326,15 @@ Packet& Packet::operator>>(std::string& data)
Packet& Packet::operator>>(wchar_t* data) Packet& Packet::operator>>(wchar_t* data)
{ {
// First extract string length // First extract string length
Uint32 length = 0; std::uint32_t length = 0;
*this >> length; *this >> length;
if ((length > 0) && checkSize(length * sizeof(Uint32))) if ((length > 0) && checkSize(length * sizeof(std::uint32_t)))
{ {
// Then extract characters // Then extract characters
for (Uint32 i = 0; i < length; ++i) for (std::uint32_t i = 0; i < length; ++i)
{ {
Uint32 character = 0; std::uint32_t character = 0;
*this >> character; *this >> character;
data[i] = static_cast<wchar_t>(character); data[i] = static_cast<wchar_t>(character);
} }
@ -349,16 +349,16 @@ Packet& Packet::operator>>(wchar_t* data)
Packet& Packet::operator>>(std::wstring& data) Packet& Packet::operator>>(std::wstring& data)
{ {
// First extract string length // First extract string length
Uint32 length = 0; std::uint32_t length = 0;
*this >> length; *this >> length;
data.clear(); data.clear();
if ((length > 0) && checkSize(length * sizeof(Uint32))) if ((length > 0) && checkSize(length * sizeof(std::uint32_t)))
{ {
// Then extract characters // Then extract characters
for (Uint32 i = 0; i < length; ++i) for (std::uint32_t i = 0; i < length; ++i)
{ {
Uint32 character = 0; std::uint32_t character = 0;
*this >> character; *this >> character;
data += static_cast<wchar_t>(character); data += static_cast<wchar_t>(character);
} }
@ -372,16 +372,16 @@ Packet& Packet::operator>>(std::wstring& data)
Packet& Packet::operator>>(String& data) Packet& Packet::operator>>(String& data)
{ {
// First extract the string length // First extract the string length
Uint32 length = 0; std::uint32_t length = 0;
*this >> length; *this >> length;
data.clear(); data.clear();
if ((length > 0) && checkSize(length * sizeof(Uint32))) if ((length > 0) && checkSize(length * sizeof(std::uint32_t)))
{ {
// Then extract characters // Then extract characters
for (Uint32 i = 0; i < length; ++i) for (std::uint32_t i = 0; i < length; ++i)
{ {
Uint32 character = 0; std::uint32_t character = 0;
*this >> character; *this >> character;
data += character; data += character;
} }
@ -436,16 +436,16 @@ Packet& Packet::operator<<(std::uint16_t data)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
Packet& Packet::operator<<(std::int32_t data) Packet& Packet::operator<<(std::int32_t data)
{ {
std::int32_t toWrite = static_cast<std::int32_t>(htonl(static_cast<uint32_t>(data))); std::int32_t toWrite = static_cast<std::int32_t>(htonl(static_cast<std::uint32_t>(data)));
append(&toWrite, sizeof(toWrite)); append(&toWrite, sizeof(toWrite));
return *this; return *this;
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
Packet& Packet::operator<<(Uint32 data) Packet& Packet::operator<<(std::uint32_t data)
{ {
Uint32 toWrite = htonl(data); std::uint32_t toWrite = htonl(data);
append(&toWrite, sizeof(toWrite)); append(&toWrite, sizeof(toWrite));
return *this; return *this;
} }
@ -511,7 +511,7 @@ Packet& Packet::operator<<(double data)
Packet& Packet::operator<<(const char* data) Packet& Packet::operator<<(const char* data)
{ {
// First insert string length // First insert string length
auto length = static_cast<Uint32>(std::strlen(data)); auto length = static_cast<std::uint32_t>(std::strlen(data));
*this << length; *this << length;
// Then insert characters // Then insert characters
@ -525,7 +525,7 @@ Packet& Packet::operator<<(const char* data)
Packet& Packet::operator<<(const std::string& data) Packet& Packet::operator<<(const std::string& data)
{ {
// First insert string length // First insert string length
auto length = static_cast<Uint32>(data.size()); auto length = static_cast<std::uint32_t>(data.size());
*this << length; *this << length;
// Then insert characters // Then insert characters
@ -540,12 +540,12 @@ Packet& Packet::operator<<(const std::string& data)
Packet& Packet::operator<<(const wchar_t* data) Packet& Packet::operator<<(const wchar_t* data)
{ {
// First insert string length // First insert string length
auto length = static_cast<Uint32>(std::wcslen(data)); auto length = static_cast<std::uint32_t>(std::wcslen(data));
*this << length; *this << length;
// Then insert characters // Then insert characters
for (const wchar_t* c = data; *c != L'\0'; ++c) for (const wchar_t* c = data; *c != L'\0'; ++c)
*this << static_cast<Uint32>(*c); *this << static_cast<std::uint32_t>(*c);
return *this; return *this;
} }
@ -555,14 +555,14 @@ Packet& Packet::operator<<(const wchar_t* data)
Packet& Packet::operator<<(const std::wstring& data) Packet& Packet::operator<<(const std::wstring& data)
{ {
// First insert string length // First insert string length
auto length = static_cast<Uint32>(data.size()); auto length = static_cast<std::uint32_t>(data.size());
*this << length; *this << length;
// Then insert characters // Then insert characters
if (length > 0) if (length > 0)
{ {
for (wchar_t c : data) for (wchar_t c : data)
*this << static_cast<Uint32>(c); *this << static_cast<std::uint32_t>(c);
} }
return *this; return *this;
@ -573,7 +573,7 @@ Packet& Packet::operator<<(const std::wstring& data)
Packet& Packet::operator<<(const String& data) Packet& Packet::operator<<(const String& data)
{ {
// First insert the string length // First insert the string length
auto length = static_cast<Uint32>(data.getSize()); auto length = static_cast<std::uint32_t>(data.getSize());
*this << length; *this << length;
// Then insert characters // Then insert characters

6
src/SFML/Network/TcpSocket.cpp
View File

@ -322,7 +322,7 @@ Socket::Status TcpSocket::send(Packet& packet)
const void* data = packet.onSend(size); const void* data = packet.onSend(size);
// First convert the packet size to network byte order // First convert the packet size to network byte order
Uint32 packetSize = htonl(static_cast<Uint32>(size)); std::uint32_t packetSize = htonl(static_cast<std::uint32_t>(size));
// Allocate memory for the data block to send // Allocate memory for the data block to send
m_blockToSendBuffer.resize(sizeof(packetSize) + size); m_blockToSendBuffer.resize(sizeof(packetSize) + size);
@ -371,8 +371,8 @@ Socket::Status TcpSocket::receive(Packet& packet)
packet.clear(); packet.clear();
// We start by getting the size of the incoming packet // We start by getting the size of the incoming packet
Uint32 packetSize = 0; std::uint32_t packetSize = 0;
std::size_t received = 0; std::size_t received = 0;
if (m_pendingPacket.SizeReceived < sizeof(m_pendingPacket.Size)) if (m_pendingPacket.SizeReceived < sizeof(m_pendingPacket.Size))
{ {
// Loop until we've received the entire size of the packet // Loop until we've received the entire size of the packet

2
src/SFML/Network/Unix/SocketImpl.cpp
View File

@ -39,7 +39,7 @@ namespace sf
namespace priv namespace priv
{ {
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
sockaddr_in SocketImpl::createAddress(Uint32 address, unsigned short port) sockaddr_in SocketImpl::createAddress(std::uint32_t address, unsigned short port)
{ {
sockaddr_in addr; sockaddr_in addr;
std::memset(&addr, 0, sizeof(addr)); std::memset(&addr, 0, sizeof(addr));

2
src/SFML/Network/Unix/SocketImpl.hpp
View File

@ -66,7 +66,7 @@ public:
/// \return sockaddr_in ready to be used by socket functions /// \return sockaddr_in ready to be used by socket functions
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
static sockaddr_in createAddress(Uint32 address, unsigned short port); static sockaddr_in createAddress(std::uint32_t address, unsigned short port);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Return the value of the invalid socket /// \brief Return the value of the invalid socket

2
src/SFML/Network/Win32/SocketImpl.cpp
View File

@ -35,7 +35,7 @@ namespace sf
namespace priv namespace priv
{ {
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
sockaddr_in SocketImpl::createAddress(Uint32 address, unsigned short port) sockaddr_in SocketImpl::createAddress(std::uint32_t address, unsigned short port)
{ {
sockaddr_in addr; sockaddr_in addr;
std::memset(&addr, 0, sizeof(addr)); std::memset(&addr, 0, sizeof(addr));

2
src/SFML/Network/Win32/SocketImpl.hpp
View File

@ -62,7 +62,7 @@ public:
/// \return sockaddr_in ready to be used by socket functions /// \return sockaddr_in ready to be used by socket functions
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
static sockaddr_in createAddress(Uint32 address, unsigned short port); static sockaddr_in createAddress(std::uint32_t address, unsigned short port);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Return the value of the invalid socket /// \brief Return the value of the invalid socket

16
src/SFML/System/String.cpp
View File

@ -35,7 +35,7 @@
namespace sf namespace sf
{ {
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
const std::size_t String::InvalidPos = std::basic_string<Uint32>::npos; const std::size_t String::InvalidPos = std::basic_string<std::uint32_t>::npos;
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
@ -59,7 +59,7 @@ String::String(wchar_t wideChar)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
String::String(Uint32 utf32Char) String::String(std::uint32_t utf32Char)
{ {
m_string += utf32Char; m_string += utf32Char;
} }
@ -112,7 +112,7 @@ String::String(const std::wstring& wideString)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
String::String(const Uint32* utf32String) String::String(const std::uint32_t* utf32String)
{ {
if (utf32String) if (utf32String)
m_string = utf32String; m_string = utf32String;
@ -120,7 +120,7 @@ String::String(const Uint32* utf32String)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
String::String(const std::basic_string<Uint32>& utf32String) : m_string(utf32String) String::String(const std::basic_string<std::uint32_t>& utf32String) : m_string(utf32String)
{ {
} }
@ -210,7 +210,7 @@ std::basic_string<std::uint16_t> String::toUtf16() const
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
std::basic_string<Uint32> String::toUtf32() const std::basic_string<std::uint32_t> String::toUtf32() const
{ {
return m_string; return m_string;
} }
@ -233,14 +233,14 @@ String& String::operator+=(const String& right)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
Uint32 String::operator[](std::size_t index) const std::uint32_t String::operator[](std::size_t index) const
{ {
return m_string[index]; return m_string[index];
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
Uint32& String::operator[](std::size_t index) std::uint32_t& String::operator[](std::size_t index)
{ {
return m_string[index]; return m_string[index];
} }
@ -319,7 +319,7 @@ String String::substring(std::size_t position, std::size_t length) const
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
const Uint32* String::getData() const const std::uint32_t* String::getData() const
{ {
return m_string.c_str(); return m_string.c_str();
} }

14
src/SFML/Window/Android/WindowImplAndroid.cpp
View File

@ -425,10 +425,10 @@ int WindowImplAndroid::processKeyEvent(AInputEvent* _event, ActivityStates& /* s
event.type = Event::KeyReleased; event.type = Event::KeyReleased;
forwardEvent(event); forwardEvent(event);
if (Uint32 unicode = static_cast<Uint32>(getUnicode(_event))) if (std::uint32_t unicode = static_cast<std::uint32_t>(getUnicode(_event)))
{ {
event.type = Event::TextEntered; event.type = Event::TextEntered;
event.text.unicode = static_cast<Uint32>(unicode); event.text.unicode = static_cast<std::uint32_t>(unicode);
forwardEvent(event); forwardEvent(event);
} }
return 1; return 1;
@ -448,10 +448,10 @@ int WindowImplAndroid::processKeyEvent(AInputEvent* _event, ActivityStates& /* s
// https://code.google.com/p/android/issues/detail?id=33998 // https://code.google.com/p/android/issues/detail?id=33998
return 0; return 0;
} }
else if (Uint32 unicode = static_cast<Uint32>(getUnicode(_event))) // This is a repeated sequence else if (std::uint32_t unicode = static_cast<std::uint32_t>(getUnicode(_event))) // This is a repeated sequence
{ {
event.type = Event::TextEntered; event.type = Event::TextEntered;
event.text.unicode = static_cast<Uint32>(unicode); event.text.unicode = static_cast<std::uint32_t>(unicode);
std::int32_t repeats = AKeyEvent_getRepeatCount(_event); std::int32_t repeats = AKeyEvent_getRepeatCount(_event);
for (std::int32_t i = 0; i < repeats; ++i) for (std::int32_t i = 0; i < repeats; ++i)
@ -473,7 +473,7 @@ int WindowImplAndroid::processMotionEvent(AInputEvent* _event, ActivityStates& s
if (device == AINPUT_SOURCE_MOUSE) if (device == AINPUT_SOURCE_MOUSE)
event.type = Event::MouseMoved; event.type = Event::MouseMoved;
else if (static_cast<Uint32>(device) & AINPUT_SOURCE_TOUCHSCREEN) else if (static_cast<std::uint32_t>(device) & AINPUT_SOURCE_TOUCHSCREEN)
event.type = Event::TouchMoved; event.type = Event::TouchMoved;
std::size_t pointerCount = AMotionEvent_getPointerCount(_event); std::size_t pointerCount = AMotionEvent_getPointerCount(_event);
@ -492,7 +492,7 @@ int WindowImplAndroid::processMotionEvent(AInputEvent* _event, ActivityStates& s
states.mousePosition = Vector2i(event.mouseMove.x, event.mouseMove.y); states.mousePosition = Vector2i(event.mouseMove.x, event.mouseMove.y);
} }
else if (static_cast<Uint32>(device) & AINPUT_SOURCE_TOUCHSCREEN) else if (static_cast<std::uint32_t>(device) & AINPUT_SOURCE_TOUCHSCREEN)
{ {
if (states.touchEvents[id].x == x && states.touchEvents[id].y == y) if (states.touchEvents[id].x == x && states.touchEvents[id].y == y)
continue; continue;
@ -558,7 +558,7 @@ int WindowImplAndroid::processPointerEvent(bool isDown, AInputEvent* _event, Act
if (id >= 0 && id < Mouse::ButtonCount) if (id >= 0 && id < Mouse::ButtonCount)
states.isButtonPressed[id] = false; states.isButtonPressed[id] = false;
} }
else if (static_cast<Uint32>(device) & AINPUT_SOURCE_TOUCHSCREEN) else if (static_cast<std::uint32_t>(device) & AINPUT_SOURCE_TOUCHSCREEN)
{ {
event.type = Event::TouchEnded; event.type = Event::TouchEnded;
event.touch.finger = static_cast<unsigned int>(id); event.touch.finger = static_cast<unsigned int>(id);

2
src/SFML/Window/DRM/DRMContext.cpp
View File

@ -421,7 +421,7 @@ void DRMContext::createContext(DRMContext* shared)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void DRMContext::createSurface(const Vector2u& size, unsigned int /*bpp*/, bool scanout) void DRMContext::createSurface(const Vector2u& size, unsigned int /*bpp*/, bool scanout)
{ {
sf::Uint32 flags = GBM_BO_USE_RENDERING; std::uint32_t flags = GBM_BO_USE_RENDERING;
m_scanOut = scanout; m_scanOut = scanout;
if (m_scanOut) if (m_scanOut)

2
src/SFML/Window/GlContext.cpp
View File

@ -866,7 +866,7 @@ void GlContext::initialize(const ContextSettings& requestedSettings)
if (std::strstr(extensionString, "GL_ARB_compatibility")) if (std::strstr(extensionString, "GL_ARB_compatibility"))
{ {
m_settings.attributeFlags &= ~static_cast<Uint32>(ContextSettings::Core); m_settings.attributeFlags &= ~static_cast<std::uint32_t>(ContextSettings::Core);
break; break;
} }
} }

4
src/SFML/Window/OSX/cpp_objc_conversion.mm
View File

@ -45,8 +45,8 @@ NSString* stringToNSString(const std::string& string)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
NSString* sfStringToNSString(const sf::String& string) NSString* sfStringToNSString(const sf::String& string)
{ {
sf::Uint32 length = static_cast<sf::Uint32>(string.getSize() * sizeof(sf::Uint32)); std::uint32_t length = static_cast<std::uint32_t>(string.getSize() * sizeof(std::uint32_t));
const void* data = reinterpret_cast<const void*>(string.getData()); const void* data = reinterpret_cast<const void*>(string.getData());
NSStringEncoding encoding; NSStringEncoding encoding;
if (NSHostByteOrder() == NS_LittleEndian) if (NSHostByteOrder() == NS_LittleEndian)

2
src/SFML/Window/Unix/CursorImpl.cpp
View File

@ -80,7 +80,7 @@ bool CursorImpl::loadFromPixelsARGB(const std::uint8_t* pixels, Vector2u size, V
const std::size_t numPixels = static_cast<std::size_t>(size.x) * static_cast<std::size_t>(size.y); const std::size_t numPixels = static_cast<std::size_t>(size.x) * static_cast<std::size_t>(size.y);
for (std::size_t pixelIndex = 0; pixelIndex < numPixels; ++pixelIndex) for (std::size_t pixelIndex = 0; pixelIndex < numPixels; ++pixelIndex)
{ {
cursorImage->pixels[pixelIndex] = static_cast<Uint32>( cursorImage->pixels[pixelIndex] = static_cast<std::uint32_t>(
pixels[pixelIndex * 4 + 2] + (pixels[pixelIndex * 4 + 1] << 8) + (pixels[pixelIndex * 4 + 0] << 16) + pixels[pixelIndex * 4 + 2] + (pixels[pixelIndex * 4 + 1] << 8) + (pixels[pixelIndex * 4 + 0] << 16) +
(pixels[pixelIndex * 4 + 3] << 24)); (pixels[pixelIndex * 4 + 3] << 24));
} }

2
src/SFML/Window/Unix/VulkanImplX11.cpp
View File

@ -135,7 +135,7 @@ bool VulkanImplX11::isAvailable(bool requireGraphics)
// Retrieve the available instance extensions // Retrieve the available instance extensions
std::vector<VkExtensionProperties> extensionProperties; std::vector<VkExtensionProperties> extensionProperties;
uint32_t extensionCount = 0; std::uint32_t extensionCount = 0;
wrapper.vkEnumerateInstanceExtensionProperties(0, &extensionCount, nullptr); wrapper.vkEnumerateInstanceExtensionProperties(0, &extensionCount, nullptr);

4
src/SFML/Window/Unix/WindowImplX11.cpp
View File

@ -1940,7 +1940,7 @@ bool WindowImplX11::processEvent(XEvent& windowEvent)
{ {
// There might be more than 1 characters in this event, // There might be more than 1 characters in this event,
// so we must iterate it // so we must iterate it
Uint32 unicode = 0; std::uint32_t unicode = 0;
std::uint8_t* iter = keyBuffer; std::uint8_t* iter = keyBuffer;
while (iter < keyBuffer + length) while (iter < keyBuffer + length)
{ {
@ -1964,7 +1964,7 @@ bool WindowImplX11::processEvent(XEvent& windowEvent)
{ {
Event textEvent; Event textEvent;
textEvent.type = Event::TextEntered; textEvent.type = Event::TextEntered;
textEvent.text.unicode = static_cast<Uint32>(keyBuffer[0]); textEvent.text.unicode = static_cast<std::uint32_t>(keyBuffer[0]);
pushEvent(textEvent); pushEvent(textEvent);
} }
} }

6
src/SFML/Window/Win32/CursorImpl.cpp
View File

@ -72,7 +72,7 @@ bool CursorImpl::loadFromPixels(const std::uint8_t* pixels, Vector2u size, Vecto
bitmapHeader.bV5BlueMask = 0x000000ff; bitmapHeader.bV5BlueMask = 0x000000ff;
bitmapHeader.bV5AlphaMask = 0xff000000; bitmapHeader.bV5AlphaMask = 0xff000000;
Uint32* bitmapData = nullptr; std::uint32_t* bitmapData = nullptr;
HDC screenDC = GetDC(nullptr); HDC screenDC = GetDC(nullptr);
HBITMAP color = CreateDIBSection(screenDC, HBITMAP color = CreateDIBSection(screenDC,
@ -91,10 +91,10 @@ bool CursorImpl::loadFromPixels(const std::uint8_t* pixels, Vector2u size, Vecto
// Fill our bitmap with the cursor color data // Fill our bitmap with the cursor color data
// We'll have to swap the red and blue channels here // We'll have to swap the red and blue channels here
Uint32* bitmapOffset = bitmapData; std::uint32_t* bitmapOffset = bitmapData;
for (std::size_t remaining = size.x * size.y; remaining > 0; --remaining, pixels += 4) for (std::size_t remaining = size.x * size.y; remaining > 0; --remaining, pixels += 4)
{ {
*bitmapOffset++ = static_cast<Uint32>((pixels[3] << 24) | (pixels[0] << 16) | (pixels[1] << 8) | pixels[2]); *bitmapOffset++ = static_cast<std::uint32_t>((pixels[3] << 24) | (pixels[0] << 16) | (pixels[1] << 8) | pixels[2]);
} }
// Create a dummy mask bitmap (it won't be used) // Create a dummy mask bitmap (it won't be used)

2
src/SFML/Window/Win32/VulkanImplWin32.cpp
View File

@ -134,7 +134,7 @@ bool VulkanImplWin32::isAvailable(bool requireGraphics)
// Retrieve the available instance extensions // Retrieve the available instance extensions
std::vector<VkExtensionProperties> extensionProperties; std::vector<VkExtensionProperties> extensionProperties;
uint32_t extensionCount = 0; std::uint32_t extensionCount = 0;
wrapper.vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr); wrapper.vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);

4
src/SFML/Window/Win32/WindowImplWin32.cpp
View File

@ -159,7 +159,7 @@ m_cursorGrabbed(false)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
WindowImplWin32::WindowImplWin32(VideoMode mode, const String& title, Uint32 style, const ContextSettings& /*settings*/) : WindowImplWin32::WindowImplWin32(VideoMode mode, const String& title, std::uint32_t style, const ContextSettings& /*settings*/) :
m_handle(nullptr), m_handle(nullptr),
m_callback(0), m_callback(0),
m_cursorVisible(true), // might need to call GetCursorInfo m_cursorVisible(true), // might need to call GetCursorInfo
@ -712,7 +712,7 @@ void WindowImplWin32::processEvent(UINT message, WPARAM wParam, LPARAM lParam)
if (m_keyRepeatEnabled || ((lParam & (1 << 30)) == 0)) if (m_keyRepeatEnabled || ((lParam & (1 << 30)) == 0))
{ {
// Get the code of the typed character // Get the code of the typed character
auto character = static_cast<Uint32>(wParam); auto character = static_cast<std::uint32_t>(wParam);
// Check if it is the first part of a surrogate pair, or a regular character // Check if it is the first part of a surrogate pair, or a regular character
if ((character >= 0xD800) && (character <= 0xDBFF)) if ((character >= 0xD800) && (character <= 0xDBFF))

2
src/SFML/Window/Win32/WindowImplWin32.hpp
View File

@ -63,7 +63,7 @@ public:
/// \param settings Additional settings for the underlying OpenGL context /// \param settings Additional settings for the underlying OpenGL context
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
WindowImplWin32(VideoMode mode, const String& title, Uint32 style, const ContextSettings& settings); WindowImplWin32(VideoMode mode, const String& title, std::uint32_t style, const ContextSettings& settings);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Destructor /// \brief Destructor

10
src/SFML/Window/Window.cpp
View File

@ -43,7 +43,7 @@ Window::Window() : m_context(), m_frameTimeLimit(Time::Zero)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
Window::Window(VideoMode mode, const String& title, Uint32 style, const ContextSettings& settings) : Window::Window(VideoMode mode, const String& title, std::uint32_t style, const ContextSettings& settings) :
m_context(), m_context(),
m_frameTimeLimit(Time::Zero) m_frameTimeLimit(Time::Zero)
{ {
@ -66,14 +66,14 @@ Window::~Window()
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void Window::create(VideoMode mode, const String& title, Uint32 style) void Window::create(VideoMode mode, const String& title, std::uint32_t style)
{ {
Window::create(mode, title, style, ContextSettings()); Window::create(mode, title, style, ContextSettings());
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void Window::create(VideoMode mode, const String& title, Uint32 style, const ContextSettings& settings) void Window::create(VideoMode mode, const String& title, std::uint32_t style, const ContextSettings& settings)
{ {
// Destroy the previous window implementation // Destroy the previous window implementation
close(); close();
@ -85,7 +85,7 @@ void Window::create(VideoMode mode, const String& title, Uint32 style, const Con
if (getFullscreenWindow()) if (getFullscreenWindow())
{ {
err() << "Creating two fullscreen windows is not allowed, switching to windowed mode" << std::endl; err() << "Creating two fullscreen windows is not allowed, switching to windowed mode" << std::endl;
style &= ~static_cast<Uint32>(Style::Fullscreen); style &= ~static_cast<std::uint32_t>(Style::Fullscreen);
} }
else else
{ {
@ -104,7 +104,7 @@ void Window::create(VideoMode mode, const String& title, Uint32 style, const Con
// Check validity of style according to the underlying platform // Check validity of style according to the underlying platform
#if defined(SFML_SYSTEM_IOS) || defined(SFML_SYSTEM_ANDROID) #if defined(SFML_SYSTEM_IOS) || defined(SFML_SYSTEM_ANDROID)
if (style & Style::Fullscreen) if (style & Style::Fullscreen)
style &= ~static_cast<Uint32>(Style::Titlebar); style &= ~static_cast<std::uint32_t>(Style::Titlebar);
else else
style |= Style::Titlebar; style |= Style::Titlebar;
#else #else

8
src/SFML/Window/WindowBase.cpp
View File

@ -52,7 +52,7 @@ WindowBase::WindowBase() : m_impl(), m_size(0, 0)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
WindowBase::WindowBase(VideoMode mode, const String& title, Uint32 style) : m_impl(), m_size(0, 0) WindowBase::WindowBase(VideoMode mode, const String& title, std::uint32_t style) : m_impl(), m_size(0, 0)
{ {
WindowBase::create(mode, title, style); WindowBase::create(mode, title, style);
} }
@ -73,7 +73,7 @@ WindowBase::~WindowBase()
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void WindowBase::create(VideoMode mode, const String& title, Uint32 style) void WindowBase::create(VideoMode mode, const String& title, std::uint32_t style)
{ {
// Destroy the previous window implementation // Destroy the previous window implementation
close(); close();
@ -85,7 +85,7 @@ void WindowBase::create(VideoMode mode, const String& title, Uint32 style)
if (getFullscreenWindow()) if (getFullscreenWindow())
{ {
err() << "Creating two fullscreen windows is not allowed, switching to windowed mode" << std::endl; err() << "Creating two fullscreen windows is not allowed, switching to windowed mode" << std::endl;
style &= ~static_cast<Uint32>(Style::Fullscreen); style &= ~static_cast<std::uint32_t>(Style::Fullscreen);
} }
else else
{ {
@ -104,7 +104,7 @@ void WindowBase::create(VideoMode mode, const String& title, Uint32 style)
// Check validity of style according to the underlying platform // Check validity of style according to the underlying platform
#if defined(SFML_SYSTEM_IOS) || defined(SFML_SYSTEM_ANDROID) #if defined(SFML_SYSTEM_IOS) || defined(SFML_SYSTEM_ANDROID)
if (style & Style::Fullscreen) if (style & Style::Fullscreen)
style &= ~static_cast<Uint32>(Style::Titlebar); style &= ~static_cast<std::uint32_t>(Style::Titlebar);
else else
style |= Style::Titlebar; style |= Style::Titlebar;
#else #else

2
src/SFML/Window/WindowImpl.cpp
View File

@ -101,7 +101,7 @@ struct WindowImpl::JoystickStatesImpl
}; };
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
std::unique_ptr<WindowImpl> WindowImpl::create(VideoMode mode, const String& title, Uint32 style, const ContextSettings& settings) std::unique_ptr<WindowImpl> WindowImpl::create(VideoMode mode, const String& title, std::uint32_t style, const ContextSettings& settings)
{ {
return std::make_unique<WindowImplType>(mode, title, style, settings); return std::make_unique<WindowImplType>(mode, title, style, settings);
} }

5
src/SFML/Window/WindowImpl.hpp
View File

@ -69,7 +69,10 @@ public:
/// \return Pointer to the created window /// \return Pointer to the created window
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
static std::unique_ptr<WindowImpl> create(VideoMode mode, const String& title, Uint32 style, const ContextSettings& settings); static std::unique_ptr<WindowImpl> create(VideoMode mode,
const String& title,
std::uint32_t style,
const ContextSettings& settings);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Create a new window depending on to the current OS /// \brief Create a new window depending on to the current OS

2
src/SFML/Window/iOS/SFAppDelegate.hpp
View File

@ -99,7 +99,7 @@
/// \param character The typed character /// \param character The typed character
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
- (void)notifyCharacter:(sf::Uint32)character; - (void)notifyCharacter:(std::uint32_t)character;
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Tells if the dimensions of the current window must be flipped when switching to a given orientation /// \brief Tells if the dimensions of the current window must be flipped when switching to a given orientation

2
src/SFML/Window/iOS/SFAppDelegate.mm
View File

@ -324,7 +324,7 @@ std::vector<sf::Vector2i> touchPositions;
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
- (void)notifyCharacter:(sf::Uint32)character - (void)notifyCharacter:(std::uint32_t)character
{ {
if (self.sfWindow) if (self.sfWindow)
{ {

2
src/SFML/Window/iOS/SFView.mm
View File

@ -77,7 +77,7 @@
const char* end = utf8 + std::strlen(utf8); const char* end = utf8 + std::strlen(utf8);
while (utf8 < end) while (utf8 < end)
{ {
sf::Uint32 character; std::uint32_t character;
utf8 = sf::Utf8::decode(utf8, end, character); utf8 = sf::Utf8::decode(utf8, end, character);
[[SFAppDelegate getInstance] notifyCharacter:character]; [[SFAppDelegate getInstance] notifyCharacter:character];
} }

40
test/Graphics/Image.cpp
View File

@ -23,9 +23,9 @@ TEST_CASE("sf::Image - [graphics]")
CHECK(image.getSize() == sf::Vector2u(10, 10)); CHECK(image.getSize() == sf::Vector2u(10, 10));
CHECK(image.getPixelsPtr() != nullptr); CHECK(image.getPixelsPtr() != nullptr);
for (sf::Uint32 i = 0; i < 10; ++i) for (std::uint32_t i = 0; i < 10; ++i)
{ {
for (sf::Uint32 j = 0; j < 10; ++j) for (std::uint32_t j = 0; j < 10; ++j)
{ {
CHECK(image.getPixel(sf::Vector2u(i, j)) == sf::Color(0, 0, 0)); CHECK(image.getPixel(sf::Vector2u(i, j)) == sf::Color(0, 0, 0));
} }
@ -40,9 +40,9 @@ TEST_CASE("sf::Image - [graphics]")
CHECK(image.getSize() == sf::Vector2u(10, 10)); CHECK(image.getSize() == sf::Vector2u(10, 10));
CHECK(image.getPixelsPtr() != nullptr); CHECK(image.getPixelsPtr() != nullptr);
for (sf::Uint32 i = 0; i < 10; ++i) for (std::uint32_t i = 0; i < 10; ++i)
{ {
for (sf::Uint32 j = 0; j < 10; ++j) for (std::uint32_t j = 0; j < 10; ++j)
{ {
CHECK(image.getPixel(sf::Vector2u(i, j)) == sf::Color::Red); CHECK(image.getPixel(sf::Vector2u(i, j)) == sf::Color::Red);
} }
@ -67,9 +67,9 @@ TEST_CASE("sf::Image - [graphics]")
CHECK(image.getSize() == sf::Vector2u(10, 10)); CHECK(image.getSize() == sf::Vector2u(10, 10));
CHECK(image.getPixelsPtr() != nullptr); CHECK(image.getPixelsPtr() != nullptr);
for (sf::Uint32 i = 0; i < 10; ++i) for (std::uint32_t i = 0; i < 10; ++i)
{ {
for (sf::Uint32 j = 0; j < 10; ++j) for (std::uint32_t j = 0; j < 10; ++j)
{ {
CHECK(image.getPixel(sf::Vector2u(i, j)) == sf::Color::Red); CHECK(image.getPixel(sf::Vector2u(i, j)) == sf::Color::Red);
} }
@ -99,9 +99,9 @@ TEST_CASE("sf::Image - [graphics]")
image2.create(sf::Vector2u(10, 10)); image2.create(sf::Vector2u(10, 10));
CHECK(image2.copy(image1, sf::Vector2u(0, 0))); CHECK(image2.copy(image1, sf::Vector2u(0, 0)));
for (sf::Uint32 i = 0; i < 10; ++i) for (std::uint32_t i = 0; i < 10; ++i)
{ {
for (sf::Uint32 j = 0; j < 10; ++j) for (std::uint32_t j = 0; j < 10; ++j)
{ {
CHECK(image1.getPixel(sf::Vector2u(i, j)) == image2.getPixel(sf::Vector2u(i, j))); CHECK(image1.getPixel(sf::Vector2u(i, j)) == image2.getPixel(sf::Vector2u(i, j)));
} }
@ -117,9 +117,9 @@ TEST_CASE("sf::Image - [graphics]")
image2.create(sf::Vector2u(10, 10)); image2.create(sf::Vector2u(10, 10));
CHECK(image2.copy(image1, sf::Vector2u(0, 0), sf::IntRect(sf::Vector2i(0, 0), sf::Vector2i(5, 5)))); CHECK(image2.copy(image1, sf::Vector2u(0, 0), sf::IntRect(sf::Vector2i(0, 0), sf::Vector2i(5, 5))));
for (sf::Uint32 i = 0; i < 10; ++i) for (std::uint32_t i = 0; i < 10; ++i)
{ {
for (sf::Uint32 j = 0; j < 10; ++j) for (std::uint32_t j = 0; j < 10; ++j)
{ {
if (i <= 4 && j <= 4) if (i <= 4 && j <= 4)
CHECK(image2.getPixel(sf::Vector2u(i, j)) == sf::Color::Blue); CHECK(image2.getPixel(sf::Vector2u(i, j)) == sf::Color::Blue);
@ -151,9 +151,9 @@ TEST_CASE("sf::Image - [graphics]")
image2.create(sf::Vector2u(10, 10), source); image2.create(sf::Vector2u(10, 10), source);
CHECK(image1.copy(image2, sf::Vector2u(0, 0), sf::IntRect(sf::Vector2i(0, 0), sf::Vector2i(10, 10)), true)); CHECK(image1.copy(image2, sf::Vector2u(0, 0), sf::IntRect(sf::Vector2i(0, 0), sf::Vector2i(10, 10)), true));
for (sf::Uint32 i = 0; i < 10; ++i) for (std::uint32_t i = 0; i < 10; ++i)
{ {
for (sf::Uint32 j = 0; j < 10; ++j) for (std::uint32_t j = 0; j < 10; ++j)
{ {
CHECK(image1.getPixel(sf::Vector2u(i, j)) == composite); CHECK(image1.getPixel(sf::Vector2u(i, j)) == composite);
} }
@ -168,9 +168,9 @@ TEST_CASE("sf::Image - [graphics]")
image2.create(sf::Vector2u(10, 10), sf::Color::Red); image2.create(sf::Vector2u(10, 10), sf::Color::Red);
CHECK(!image2.copy(image1, sf::Vector2u(0, 0), sf::IntRect(sf::Vector2i(0, 0), sf::Vector2i(9, 9)))); CHECK(!image2.copy(image1, sf::Vector2u(0, 0), sf::IntRect(sf::Vector2i(0, 0), sf::Vector2i(9, 9))));
for (sf::Uint32 i = 0; i < 10; ++i) for (std::uint32_t i = 0; i < 10; ++i)
{ {
for (sf::Uint32 j = 0; j < 10; ++j) for (std::uint32_t j = 0; j < 10; ++j)
{ {
CHECK(image2.getPixel(sf::Vector2u(i, j)) == sf::Color::Red); CHECK(image2.getPixel(sf::Vector2u(i, j)) == sf::Color::Red);
} }
@ -187,9 +187,9 @@ TEST_CASE("sf::Image - [graphics]")
image2.create(sf::Vector2u(10, 10), sf::Color::Red); image2.create(sf::Vector2u(10, 10), sf::Color::Red);
CHECK(!image2.copy(image1, sf::Vector2u(0, 0), sf::IntRect(sf::Vector2i(5, 5), sf::Vector2i(9, 9)))); CHECK(!image2.copy(image1, sf::Vector2u(0, 0), sf::IntRect(sf::Vector2i(5, 5), sf::Vector2i(9, 9))));
for (sf::Uint32 i = 0; i < 10; ++i) for (std::uint32_t i = 0; i < 10; ++i)
{ {
for (sf::Uint32 j = 0; j < 10; ++j) for (std::uint32_t j = 0; j < 10; ++j)
{ {
CHECK(image2.getPixel(sf::Vector2u(i, j)) == sf::Color::Red); CHECK(image2.getPixel(sf::Vector2u(i, j)) == sf::Color::Red);
} }
@ -205,9 +205,9 @@ TEST_CASE("sf::Image - [graphics]")
image.create(sf::Vector2u(10, 10), sf::Color::Blue); image.create(sf::Vector2u(10, 10), sf::Color::Blue);
image.createMaskFromColor(sf::Color::Blue); image.createMaskFromColor(sf::Color::Blue);
for (sf::Uint32 i = 0; i < 10; ++i) for (std::uint32_t i = 0; i < 10; ++i)
{ {
for (sf::Uint32 j = 0; j < 10; ++j) for (std::uint32_t j = 0; j < 10; ++j)
{ {
CHECK(image.getPixel(sf::Vector2u(i, j)) == sf::Color(0, 0, 255, 0)); CHECK(image.getPixel(sf::Vector2u(i, j)) == sf::Color(0, 0, 255, 0));
} }
@ -220,9 +220,9 @@ TEST_CASE("sf::Image - [graphics]")
image.create(sf::Vector2u(10, 10), sf::Color::Blue); image.create(sf::Vector2u(10, 10), sf::Color::Blue);
image.createMaskFromColor(sf::Color::Blue, 100); image.createMaskFromColor(sf::Color::Blue, 100);
for (sf::Uint32 i = 0; i < 10; ++i) for (std::uint32_t i = 0; i < 10; ++i)
{ {
for (sf::Uint32 j = 0; j < 10; ++j) for (std::uint32_t j = 0; j < 10; ++j)
{ {
CHECK(image.getPixel(sf::Vector2u(i, j)) == sf::Color(0, 0, 255, 100)); CHECK(image.getPixel(sf::Vector2u(i, j)) == sf::Color(0, 0, 255, 100));
} }

2
test/Network/IpAddress.cpp
View File

@ -51,7 +51,7 @@ TEST_CASE("sf::IpAddress class - [network]")
CHECK(ipAddress.toInteger() == 0x8EFA45EE); CHECK(ipAddress.toInteger() == 0x8EFA45EE);
} }
SUBCASE("Uint32 constructor") SUBCASE("std::uint32_t constructor")
{ {
const sf::IpAddress ipAddress(0xDEADBEEF); const sf::IpAddress ipAddress(0xDEADBEEF);
CHECK(ipAddress.toString() == "222.173.190.239"s); CHECK(ipAddress.toString() == "222.173.190.239"s);

2
test/System/Config.cpp
View File

@ -14,8 +14,6 @@ TEST_CASE("SFML/Config.hpp")
SUBCASE("Fixed width types") SUBCASE("Fixed width types")
{ {
CHECK(sizeof(sf::Uint32) == 4);
CHECK(sizeof(sf::Int64) == 8); CHECK(sizeof(sf::Int64) == 8);
CHECK(sizeof(sf::Uint64) == 8); CHECK(sizeof(sf::Uint64) == 8);
} }