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

Replace sf::Uint64 with std::uint64_t

Browse Source
This commit is contained in:
Chris Thrasher 2022-09-12 15:54:03 -06:00 committed by Vittorio Romeo
parent 05690b963d
commit 3a3935d005
52 changed files with 183 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
examples/vulkan/Vulkan.cpp
View File

@ -188,7 +188,7 @@ GLADapiproc getVulkanFunction(const char* name)
VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(
VkDebugReportFlagsEXT,
VkDebugReportObjectTypeEXT,
uint64_t,
std::uint64_t,
std::size_t,
std::int32_t,
const char*,
@ -393,7 +393,7 @@ public:
{
// Swapchain teardown procedure
for (VkFence fence : fences)
vkWaitForFences(device, 1, &fence, VK_TRUE, std::numeric_limits<uint64_t>::max());
vkWaitForFences(device, 1, &fence, VK_TRUE, std::numeric_limits<std::uint64_t>::max());
if (commandBuffers.size())
vkFreeCommandBuffers(device, commandPool, static_cast<std::uint32_t>(commandBuffers.size()), commandBuffers.data());
@ -2483,13 +2483,13 @@ public:
std::uint32_t imageIndex = 0;
// 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<std::uint64_t>::max());
{
// Get the next image in the swapchain
VkResult result = vkAcquireNextImageKHR(device,
swapchain,
std::numeric_limits<uint64_t>::max(),
std::numeric_limits<std::uint64_t>::max(),
imageAvailableSemaphores[currentFrame],
VK_NULL_HANDLE,
&imageIndex);

14
include/SFML/Audio/InputSoundFile.hpp
View File

@ -124,7 +124,7 @@ public:
/// \return Number of samples
///
////////////////////////////////////////////////////////////
Uint64 getSampleCount() const;
std::uint64_t getSampleCount() const;
////////////////////////////////////////////////////////////
/// \brief Get the number of channels used by the sound
@ -167,7 +167,7 @@ public:
/// \return Sample position
///
////////////////////////////////////////////////////////////
Uint64 getSampleOffset() const;
std::uint64_t getSampleOffset() const;
////////////////////////////////////////////////////////////
/// \brief Change the current read position to the given sample offset
@ -186,7 +186,7 @@ public:
/// \param sampleOffset Index of the sample to jump to, relative to the beginning
///
////////////////////////////////////////////////////////////
void seek(Uint64 sampleOffset);
void seek(std::uint64_t sampleOffset);
////////////////////////////////////////////////////////////
/// \brief Change the current read position to the given time offset
@ -211,7 +211,7 @@ public:
/// \return Number of samples actually read (may be less than \a maxCount)
///
////////////////////////////////////////////////////////////
[[nodiscard]] Uint64 read(std::int16_t* samples, Uint64 maxCount);
[[nodiscard]] std::uint64_t read(std::int16_t* samples, std::uint64_t maxCount);
////////////////////////////////////////////////////////////
/// \brief Close the current file
@ -242,8 +242,8 @@ private:
////////////////////////////////////////////////////////////
std::unique_ptr<SoundFileReader> m_reader; //!< Reader that handles I/O on the file's format
std::unique_ptr<InputStream, StreamDeleter> m_stream; //!< Input stream used to access the file's data
Uint64 m_sampleOffset; //!< Sample Read Position
Uint64 m_sampleCount; //!< Total number of samples in the file
std::uint64_t m_sampleOffset; //!< Sample Read Position
std::uint64_t m_sampleCount; //!< Total number of samples in the file
unsigned int m_channelCount; //!< Number of channels of the sound
unsigned int m_sampleRate; //!< Number of samples per second
};
@ -280,7 +280,7 @@ private:
///
/// // Read and process batches of samples until the end of file is reached
/// std::int16_t samples[1024];
/// sf::Uint64 count;
/// std::uint64_t count;
/// do
/// {
/// count = file.read(samples, 1024);

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

@ -256,7 +256,7 @@ private:
/// \return The number of samples elapsed at the given time
///
////////////////////////////////////////////////////////////
Uint64 timeToSamples(Time position) const;
std::uint64_t timeToSamples(Time position) const;
////////////////////////////////////////////////////////////
/// \brief Helper to convert a sample position to an sf::Time
@ -266,7 +266,7 @@ private:
/// \return The Time position of the given sample
///
////////////////////////////////////////////////////////////
Time samplesToTime(Uint64 samples) const;
Time samplesToTime(std::uint64_t samples) const;
////////////////////////////////////////////////////////////
// Member data
@ -274,7 +274,7 @@ private:
InputSoundFile m_file; //!< The streamed music file
std::vector<std::int16_t> m_samples; //!< Temporary buffer of samples
std::recursive_mutex m_mutex; //!< Mutex protecting the data
Span<Uint64> m_loopSpan; //!< Loop Range Specifier
Span<std::uint64_t> m_loopSpan; //!< Loop Range Specifier
};
} // namespace sf

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

@ -93,7 +93,7 @@ public:
/// \param count Number of samples to write
///
////////////////////////////////////////////////////////////
void write(const std::int16_t* samples, Uint64 count);
void write(const std::int16_t* samples, std::uint64_t count);
////////////////////////////////////////////////////////////
/// \brief Close the current file

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

@ -134,7 +134,7 @@ public:
///
////////////////////////////////////////////////////////////
[[nodiscard]] bool loadFromSamples(const std::int16_t* samples,
Uint64 sampleCount,
std::uint64_t sampleCount,
unsigned int channelCount,
unsigned int sampleRate);
@ -178,7 +178,7 @@ public:
/// \see getSamples
///
////////////////////////////////////////////////////////////
Uint64 getSampleCount() const;
std::uint64_t getSampleCount() const;
////////////////////////////////////////////////////////////
/// \brief Get the sample rate of the sound

12
include/SFML/Audio/SoundFileReader.hpp
View File

@ -30,6 +30,8 @@
////////////////////////////////////////////////////////////
#include <SFML/Audio/Export.hpp>
#include <cstdint>
namespace sf
{
@ -48,7 +50,7 @@ public:
////////////////////////////////////////////////////////////
struct Info
{
Uint64 sampleCount; //!< Total number of samples in the file
std::uint64_t sampleCount; //!< Total number of samples in the file
unsigned int channelCount; //!< Number of channels of the sound
unsigned int sampleRate; //!< Samples rate of the sound, in samples per second
};
@ -89,7 +91,7 @@ public:
/// \param sampleOffset Index of the sample to jump to, relative to the beginning
///
////////////////////////////////////////////////////////////
virtual void seek(Uint64 sampleOffset) = 0;
virtual void seek(std::uint64_t sampleOffset) = 0;
////////////////////////////////////////////////////////////
/// \brief Read audio samples from the open file
@ -100,7 +102,7 @@ public:
/// \return Number of samples actually read (may be less than \a maxCount)
///
////////////////////////////////////////////////////////////
[[nodiscard]] virtual Uint64 read(std::int16_t* samples, Uint64 maxCount) = 0;
[[nodiscard]] virtual std::uint64_t read(std::int16_t* samples, std::uint64_t maxCount) = 0;
};
} // namespace sf
@ -143,13 +145,13 @@ public:
/// // return true on success
/// }
///
/// void seek(sf::Uint64 sampleOffset) override
/// void seek(std::uint64_t sampleOffset) override
/// {
/// // advance to the sampleOffset-th sample from the beginning of the
/// sound
/// }
///
/// sf::Uint64 read(std::int16_t* samples, sf::Uint64 maxCount) override
/// std::uint64_t read(std::int16_t* samples, std::uint64_t maxCount) override
/// {
/// // read up to 'maxCount' samples into the 'samples' array,
/// // convert them (for example from normalized float) if they are not stored

4
include/SFML/Audio/SoundFileWriter.hpp
View File

@ -72,7 +72,7 @@ public:
/// \param count Number of samples to write
///
////////////////////////////////////////////////////////////
virtual void write(const std::int16_t* samples, Uint64 count) = 0;
virtual void write(const std::int16_t* samples, std::uint64_t count) = 0;
};
} // namespace sf
@ -115,7 +115,7 @@ public:
/// // return true on success
/// }
///
/// void write(const std::int16_t* samples, sf::Uint64 count) override
/// void write(const std::int16_t* samples, std::uint64_t count) override
/// {
/// // write 'count' samples stored at address 'samples',
/// // convert them (for example to normalized float) if the format requires it

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

@ -346,7 +346,7 @@ private:
unsigned int m_sampleRate; //!< Frequency (samples / second)
std::int32_t m_format; //!< Format of the internal sound buffers
bool m_loop; //!< Loop flag (true to loop, false to play once)
Uint64 m_samplesProcessed; //!< Number of samples processed since beginning of the stream
std::uint64_t m_samplesProcessed; //!< Number of samples processed since beginning of the stream
std::int64_t m_bufferSeeks[BufferCount]; //!< If buffer is an "end buffer", holds next seek position, else NoLoop. For play offset calculation.
Time m_processingInterval; //!< Interval for checking and filling the internal sound buffers.
};

17
include/SFML/Config.hpp
View File

@ -26,12 +26,6 @@
#define SFML_CONFIG_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <cstdint>
////////////////////////////////////////////////////////////
// Define the SFML version
////////////////////////////////////////////////////////////
@ -162,15 +156,4 @@
#endif
////////////////////////////////////////////////////////////
// Define portable fixed-size types
////////////////////////////////////////////////////////////
namespace sf
{
// 64 bits integer types
using Uint64 = std::uint64_t;
} // namespace sf
#endif // SFML_CONFIG_HPP

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

@ -30,6 +30,8 @@
////////////////////////////////////////////////////////////
#include <SFML/Graphics/Export.hpp>
#include <cstdint>
namespace sf
{

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

@ -348,7 +348,7 @@ private:
////////////////////////////////////////////////////////////
// Types
////////////////////////////////////////////////////////////
using GlyphTable = std::unordered_map<Uint64, Glyph>; //!< Table mapping a codepoint to its glyph
using GlyphTable = std::unordered_map<std::uint64_t, Glyph>; //!< Table mapping a codepoint to its glyph
////////////////////////////////////////////////////////////
/// \brief Structure defining a page of glyphs

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

@ -489,7 +489,7 @@ private:
bool glStatesSet; //!< Are our internal GL states set yet?
bool viewChanged; //!< Has the current view changed since last draw?
BlendMode lastBlendMode; //!< Cached blending mode
Uint64 lastTextureId; //!< Cached texture
std::uint64_t lastTextureId; //!< Cached texture
bool texCoordsArrayEnabled; //!< Is GL_TEXTURE_COORD_ARRAY client state enabled?
bool useVertexCache; //!< Did we previously use the vertex cache?
Vertex vertexCache[VertexCacheSize]; //!< Pre-transformed vertices cache
@ -501,7 +501,7 @@ private:
View m_defaultView; //!< Default view
View m_view; //!< Current view
StatesCache m_cache; //!< Render states cache
Uint64 m_id; //!< Unique number that identifies the RenderTarget
std::uint64_t m_id; //!< Unique number that identifies the RenderTarget
};
} // namespace sf

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

@ -441,7 +441,7 @@ private:
mutable VertexArray m_outlineVertices; //!< Vertex array containing the outline geometry
mutable FloatRect m_bounds; //!< Bounding rectangle of the text (in local coordinates)
mutable bool m_geometryNeedUpdate; //!< Does the geometry need to be recomputed?
mutable Uint64 m_fontTextureId; //!< The font texture id
mutable std::uint64_t m_fontTextureId; //!< The font texture id
};
} // namespace sf

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

@ -620,7 +620,7 @@ private:
mutable bool m_pixelsFlipped; //!< To work around the inconsistency in Y orientation
bool m_fboAttachment; //!< Is this texture owned by a framebuffer object?
bool m_hasMipmap; //!< Has the mipmap been generated?
Uint64 m_cacheId; //!< Unique number that identifies the texture to the render target's cache
std::uint64_t m_cacheId; //!< Unique number that identifies the texture to the render target's cache
};
} // namespace sf

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

@ -248,7 +248,7 @@ public:
////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator>>(Uint64& data);
Packet& operator>>(std::uint64_t& data);
////////////////////////////////////////////////////////////
/// \overload
@ -329,7 +329,7 @@ public:
////////////////////////////////////////////////////////////
/// \overload
////////////////////////////////////////////////////////////
Packet& operator<<(Uint64 data);
Packet& operator<<(std::uint64_t data);
////////////////////////////////////////////////////////////
/// \overload

2
include/SFML/System/InputStream.hpp
View File

@ -32,6 +32,8 @@
#include <SFML/System/Export.hpp>
#include <cstdint>
namespace sf
{

3
include/SFML/Window/Context.hpp
View File

@ -33,6 +33,7 @@
#include <SFML/System/Vector2.hpp>
#include <SFML/Window/GlResource.hpp>
#include <cstdint>
#include <memory>
@ -145,7 +146,7 @@ public:
/// \return The active context's ID or 0 if no context is currently active
///
////////////////////////////////////////////////////////////
static Uint64 getActiveContextId();
static std::uint64_t getActiveContextId();
////////////////////////////////////////////////////////////
/// \brief Construct a in-memory context

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

@ -27,6 +27,8 @@
#include <SFML/Config.hpp>
#include <cstdint>
namespace sf
{
////////////////////////////////////////////////////////////

1
include/SFML/Window/Cursor.hpp
View File

@ -32,6 +32,7 @@
#include <SFML/System/Vector2.hpp>
#include <cstdint>
#include <memory>
namespace sf

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

@ -189,7 +189,7 @@ bool InputSoundFile::openFromStream(InputStream& stream)
////////////////////////////////////////////////////////////
Uint64 InputSoundFile::getSampleCount() const
std::uint64_t InputSoundFile::getSampleCount() const
{
return m_sampleCount;
}
@ -234,14 +234,14 @@ Time InputSoundFile::getTimeOffset() const
////////////////////////////////////////////////////////////
Uint64 InputSoundFile::getSampleOffset() const
std::uint64_t InputSoundFile::getSampleOffset() const
{
return m_sampleOffset;
}
////////////////////////////////////////////////////////////
void InputSoundFile::seek(Uint64 sampleOffset)
void InputSoundFile::seek(std::uint64_t sampleOffset)
{
if (m_reader && m_channelCount != 0)
{
@ -256,14 +256,14 @@ void InputSoundFile::seek(Uint64 sampleOffset)
////////////////////////////////////////////////////////////
void InputSoundFile::seek(Time timeOffset)
{
seek(static_cast<Uint64>(timeOffset.asSeconds() * static_cast<float>(m_sampleRate)) * m_channelCount);
seek(static_cast<std::uint64_t>(timeOffset.asSeconds() * static_cast<float>(m_sampleRate)) * m_channelCount);
}
////////////////////////////////////////////////////////////
Uint64 InputSoundFile::read(std::int16_t* samples, Uint64 maxCount)
std::uint64_t InputSoundFile::read(std::int16_t* samples, std::uint64_t maxCount)
{
Uint64 readSamples = 0;
std::uint64_t readSamples = 0;
if (m_reader && samples && maxCount)
readSamples = m_reader->read(samples, maxCount);
m_sampleOffset += readSamples;

14
src/SFML/Audio/Music.cpp
View File

@ -123,7 +123,7 @@ Music::TimeSpan Music::getLoopPoints() const
////////////////////////////////////////////////////////////
void Music::setLoopPoints(TimeSpan timePoints)
{
Span<Uint64> samplePoints(timeToSamples(timePoints.offset), timeToSamples(timePoints.length));
Span<std::uint64_t> samplePoints(timeToSamples(timePoints.offset), timeToSamples(timePoints.length));
// Check our state. This averts a divide-by-zero. GetChannelCount() is cheap enough to use often
if (getChannelCount() == 0 || m_file.getSampleCount() == 0)
@ -185,8 +185,8 @@ bool Music::onGetData(SoundStream::Chunk& data)
std::scoped_lock lock(m_mutex);
std::size_t toFill = m_samples.size();
Uint64 currentOffset = m_file.getSampleOffset();
Uint64 loopEnd = m_loopSpan.offset + m_loopSpan.length;
std::uint64_t currentOffset = m_file.getSampleOffset();
std::uint64_t loopEnd = m_loopSpan.offset + m_loopSpan.length;
// If the loop end is enabled and imminent, request less data.
// This will trip an "onLoop()" call from the underlying SoundStream,
@ -218,7 +218,7 @@ std::int64_t Music::onLoop()
{
// Called by underlying SoundStream so we can determine where to loop.
std::scoped_lock lock(m_mutex);
Uint64 currentOffset = m_file.getSampleOffset();
std::uint64_t currentOffset = m_file.getSampleOffset();
if (getLoop() && (m_loopSpan.length != 0) && (currentOffset == m_loopSpan.offset + m_loopSpan.length))
{
// Looping is enabled, and either we're at the loop end, or we're at the EOF
@ -251,18 +251,18 @@ void Music::initialize()
}
////////////////////////////////////////////////////////////
Uint64 Music::timeToSamples(Time position) const
std::uint64_t Music::timeToSamples(Time position) const
{
// Always ROUND, no unchecked truncation, hence the addition in the numerator.
// This avoids most precision errors arising from "samples => Time => samples" conversions
// Original rounding calculation is ((Micros * Freq * Channels) / 1000000) + 0.5
// We refactor it to keep std::int64_t as the data type throughout the whole operation.
return ((static_cast<Uint64>(position.asMicroseconds()) * getSampleRate() * getChannelCount()) + 500000) / 1000000;
return ((static_cast<std::uint64_t>(position.asMicroseconds()) * getSampleRate() * getChannelCount()) + 500000) / 1000000;
}
////////////////////////////////////////////////////////////
Time Music::samplesToTime(Uint64 samples) const
Time Music::samplesToTime(std::uint64_t samples) const
{
Time position = Time::Zero;

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

@ -69,7 +69,7 @@ bool OutputSoundFile::openFromFile(const std::filesystem::path& filename, unsign
////////////////////////////////////////////////////////////
void OutputSoundFile::write(const std::int16_t* samples, Uint64 count)
void OutputSoundFile::write(const std::int16_t* samples, std::uint64_t count)
{
if (m_writer && samples && count)
m_writer->write(samples, count);

9
src/SFML/Audio/SoundBuffer.cpp
View File

@ -120,7 +120,10 @@ bool SoundBuffer::loadFromStream(InputStream& stream)
////////////////////////////////////////////////////////////
bool SoundBuffer::loadFromSamples(const std::int16_t* samples, Uint64 sampleCount, unsigned int channelCount, unsigned int sampleRate)
bool SoundBuffer::loadFromSamples(const std::int16_t* samples,
std::uint64_t sampleCount,
unsigned int channelCount,
unsigned int sampleRate)
{
if (samples && sampleCount && channelCount && sampleRate)
{
@ -171,7 +174,7 @@ const std::int16_t* SoundBuffer::getSamples() const
////////////////////////////////////////////////////////////
Uint64 SoundBuffer::getSampleCount() const
std::uint64_t SoundBuffer::getSampleCount() const
{
return m_samples.size();
}
@ -222,7 +225,7 @@ SoundBuffer& SoundBuffer::operator=(const SoundBuffer& right)
bool SoundBuffer::initialize(InputSoundFile& file)
{
// Retrieve the sound parameters
Uint64 sampleCount = file.getSampleCount();
std::uint64_t sampleCount = file.getSampleCount();
unsigned int channelCount = file.getChannelCount();
unsigned int sampleRate = file.getSampleRate();

4
src/SFML/Audio/SoundFileReaderFlac.cpp
View File

@ -271,7 +271,7 @@ bool SoundFileReaderFlac::open(InputStream& stream, Info& info)
////////////////////////////////////////////////////////////
void SoundFileReaderFlac::seek(Uint64 sampleOffset)
void SoundFileReaderFlac::seek(std::uint64_t sampleOffset)
{
assert(m_decoder);
@ -300,7 +300,7 @@ void SoundFileReaderFlac::seek(Uint64 sampleOffset)
////////////////////////////////////////////////////////////
Uint64 SoundFileReaderFlac::read(std::int16_t* samples, Uint64 maxCount)
std::uint64_t SoundFileReaderFlac::read(std::int16_t* samples, std::uint64_t maxCount)
{
assert(m_decoder);

6
src/SFML/Audio/SoundFileReaderFlac.hpp
View File

@ -90,7 +90,7 @@ public:
/// \param sampleOffset Index of the sample to jump to, relative to the beginning
///
////////////////////////////////////////////////////////////
void seek(Uint64 sampleOffset) override;
void seek(std::uint64_t sampleOffset) override;
////////////////////////////////////////////////////////////
/// \brief Read audio samples from the open file
@ -101,7 +101,7 @@ public:
/// \return Number of samples actually read (may be less than \a maxCount)
///
////////////////////////////////////////////////////////////
[[nodiscard]] Uint64 read(std::int16_t* samples, Uint64 maxCount) override;
[[nodiscard]] std::uint64_t read(std::int16_t* samples, std::uint64_t maxCount) override;
public:
////////////////////////////////////////////////////////////
@ -113,7 +113,7 @@ public:
InputStream* stream;
SoundFileReader::Info info;
std::int16_t* buffer;
Uint64 remaining;
std::uint64_t remaining;
std::vector<std::int16_t> leftovers;
bool error;
};

8
src/SFML/Audio/SoundFileReaderMp3.cpp
View File

@ -136,7 +136,7 @@ bool SoundFileReaderMp3::open(InputStream& stream, Info& info)
////////////////////////////////////////////////////////////
void SoundFileReaderMp3::seek(Uint64 sampleOffset)
void SoundFileReaderMp3::seek(std::uint64_t sampleOffset)
{
m_position = std::min(sampleOffset, m_numSamples);
mp3dec_ex_seek(&m_decoder, m_position);
@ -144,10 +144,10 @@ void SoundFileReaderMp3::seek(Uint64 sampleOffset)
////////////////////////////////////////////////////////////
Uint64 SoundFileReaderMp3::read(std::int16_t* samples, Uint64 maxCount)
std::uint64_t SoundFileReaderMp3::read(std::int16_t* samples, std::uint64_t maxCount)
{
Uint64 toRead = std::min(maxCount, m_numSamples - m_position);
toRead = static_cast<Uint64>(mp3dec_ex_read(&m_decoder, samples, static_cast<std::size_t>(toRead)));
std::uint64_t toRead = std::min(maxCount, m_numSamples - m_position);
toRead = static_cast<std::uint64_t>(mp3dec_ex_read(&m_decoder, samples, static_cast<std::size_t>(toRead)));
m_position += toRead;
return toRead;
}

8
src/SFML/Audio/SoundFileReaderMp3.hpp
View File

@ -110,7 +110,7 @@ public:
/// \param sampleOffset Index of the sample to jump to, relative to the beginning
///
////////////////////////////////////////////////////////////
void seek(Uint64 sampleOffset) override;
void seek(std::uint64_t sampleOffset) override;
////////////////////////////////////////////////////////////
/// \brief Read audio samples from the open file
@ -121,7 +121,7 @@ public:
/// \return Number of samples actually read (may be less than \a maxCount)
///
////////////////////////////////////////////////////////////
[[nodiscard]] Uint64 read(std::int16_t* samples, Uint64 maxCount) override;
[[nodiscard]] std::uint64_t read(std::int16_t* samples, std::uint64_t maxCount) override;
private:
////////////////////////////////////////////////////////////
@ -129,8 +129,8 @@ private:
////////////////////////////////////////////////////////////
mp3dec_io_t m_io;
mp3dec_ex_t m_decoder;
Uint64 m_numSamples; // Decompressed audio storage size
Uint64 m_position; // Position in decompressed audio buffer
std::uint64_t m_numSamples; // Decompressed audio storage size
std::uint64_t m_position; // Position in decompressed audio buffer
};
} // namespace priv

8
src/SFML/Audio/SoundFileReaderOgg.cpp
View File

@ -126,7 +126,7 @@ bool SoundFileReaderOgg::open(InputStream& stream, Info& info)
////////////////////////////////////////////////////////////
void SoundFileReaderOgg::seek(Uint64 sampleOffset)
void SoundFileReaderOgg::seek(std::uint64_t sampleOffset)
{
assert(m_vorbis.datasource);
@ -135,12 +135,12 @@ void SoundFileReaderOgg::seek(Uint64 sampleOffset)
////////////////////////////////////////////////////////////
Uint64 SoundFileReaderOgg::read(std::int16_t* samples, Uint64 maxCount)
std::uint64_t SoundFileReaderOgg::read(std::int16_t* samples, std::uint64_t maxCount)
{
assert(m_vorbis.datasource);
// Try to read the requested number of samples, stop only on error or end of file
Uint64 count = 0;
std::uint64_t count = 0;
while (count < maxCount)
{
int bytesToRead = static_cast<int>(maxCount - count) * static_cast<int>(sizeof(std::int16_t));
@ -148,7 +148,7 @@ Uint64 SoundFileReaderOgg::read(std::int16_t* samples, Uint64 maxCount)
if (bytesRead > 0)
{
long samplesRead = bytesRead / static_cast<long>(sizeof(std::int16_t));
count += static_cast<Uint64>(samplesRead);
count += static_cast<std::uint64_t>(samplesRead);
samples += samplesRead;
}
else

4
src/SFML/Audio/SoundFileReaderOgg.hpp
View File

@ -91,7 +91,7 @@ public:
/// \param sampleOffset Index of the sample to jump to, relative to the beginning
///
////////////////////////////////////////////////////////////
void seek(Uint64 sampleOffset) override;
void seek(std::uint64_t sampleOffset) override;
////////////////////////////////////////////////////////////
/// \brief Read audio samples from the open file
@ -102,7 +102,7 @@ public:
/// \return Number of samples actually read (may be less than \a maxCount)
///
////////////////////////////////////////////////////////////
[[nodiscard]] Uint64 read(std::int16_t* samples, Uint64 maxCount) override;
[[nodiscard]] std::uint64_t read(std::int16_t* samples, std::uint64_t maxCount) override;
private:
////////////////////////////////////////////////////////////

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

@ -90,7 +90,7 @@ bool decode(sf::InputStream& stream, std::uint32_t& value)
return true;
}
const sf::Uint64 mainChunkSize = 12;
const std::uint64_t mainChunkSize = 12;
const std::uint16_t waveFormatPcm = 1;
@ -139,7 +139,7 @@ bool SoundFileReaderWav::open(InputStream& stream, Info& info)
////////////////////////////////////////////////////////////
void SoundFileReaderWav::seek(Uint64 sampleOffset)
void SoundFileReaderWav::seek(std::uint64_t sampleOffset)
{
assert(m_stream);
@ -149,12 +149,12 @@ void SoundFileReaderWav::seek(Uint64 sampleOffset)
////////////////////////////////////////////////////////////
Uint64 SoundFileReaderWav::read(std::int16_t* samples, Uint64 maxCount)
std::uint64_t SoundFileReaderWav::read(std::int16_t* samples, std::uint64_t maxCount)
{
assert(m_stream);
Uint64 count = 0;
auto startPos = static_cast<Uint64>(m_stream->tell());
std::uint64_t count = 0;
auto startPos = static_cast<std::uint64_t>(m_stream->tell());
// Tracking of m_dataEnd is important to prevent sf::Music from reading
// data until EOF, as WAV files may have metadata at the end.
@ -341,7 +341,7 @@ bool SoundFileReaderWav::parseHeader(Info& info)
info.sampleCount = subChunkSize / m_bytesPerSample;
// Store the start and end position of samples in the file
m_dataStart = static_cast<Uint64>(subChunkStart);
m_dataStart = static_cast<std::uint64_t>(subChunkStart);
m_dataEnd = m_dataStart + info.sampleCount * m_bytesPerSample;
dataChunkFound = true;

8
src/SFML/Audio/SoundFileReaderWav.hpp
View File

@ -81,7 +81,7 @@ public:
/// \param sampleOffset Index of the sample to jump to, relative to the beginning
///
////////////////////////////////////////////////////////////
void seek(Uint64 sampleOffset) override;
void seek(std::uint64_t sampleOffset) override;
////////////////////////////////////////////////////////////
/// \brief Read audio samples from the open file
@ -92,7 +92,7 @@ public:
/// \return Number of samples actually read (may be less than \a maxCount)
///
////////////////////////////////////////////////////////////
[[nodiscard]] Uint64 read(std::int16_t* samples, Uint64 maxCount) override;
[[nodiscard]] std::uint64_t read(std::int16_t* samples, std::uint64_t maxCount) override;
private:
////////////////////////////////////////////////////////////
@ -110,8 +110,8 @@ private:
////////////////////////////////////////////////////////////
InputStream* m_stream; //!< Source stream to read from
unsigned int m_bytesPerSample; //!< Size of a sample, in bytes
Uint64 m_dataStart; //!< Starting position of the audio data in the open file
Uint64 m_dataEnd; //!< Position one byte past the end of the audio data in the open file
std::uint64_t m_dataStart; //!< Starting position of the audio data in the open file
std::uint64_t m_dataEnd; //!< Position one byte past the end of the audio data in the open file
};
} // namespace priv

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

@ -93,7 +93,7 @@ bool SoundFileWriterFlac::open(const std::filesystem::path& filename, unsigned i
////////////////////////////////////////////////////////////
void SoundFileWriterFlac::write(const std::int16_t* samples, Uint64 count)
void SoundFileWriterFlac::write(const std::int16_t* samples, std::uint64_t count)
{
while (count > 0)
{

2
src/SFML/Audio/SoundFileWriterFlac.hpp
View File

@ -88,7 +88,7 @@ public:
/// \param count Number of samples to write
///
////////////////////////////////////////////////////////////
void write(const std::int16_t* samples, Uint64 count) override;
void write(const std::int16_t* samples, std::uint64_t count) override;
private:
////////////////////////////////////////////////////////////

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

@ -125,7 +125,7 @@ bool SoundFileWriterOgg::open(const std::filesystem::path& filename, unsigned in
////////////////////////////////////////////////////////////
void SoundFileWriterOgg::write(const std::int16_t* samples, Uint64 count)
void SoundFileWriterOgg::write(const std::int16_t* samples, std::uint64_t count)
{
// Vorbis has issues with buffers that are too large, so we ask for 64K
constexpr int bufferSize = 65536;

2
src/SFML/Audio/SoundFileWriterOgg.hpp
View File

@ -89,7 +89,7 @@ public:
/// \param count Number of samples to write
///
////////////////////////////////////////////////////////////
void write(const std::int16_t* samples, Uint64 count) override;
void write(const std::int16_t* samples, std::uint64_t count) override;
private:
////////////////////////////////////////////////////////////

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

@ -109,7 +109,7 @@ bool SoundFileWriterWav::open(const std::filesystem::path& filename, unsigned in
////////////////////////////////////////////////////////////
void SoundFileWriterWav::write(const std::int16_t* samples, Uint64 count)
void SoundFileWriterWav::write(const std::int16_t* samples, std::uint64_t count)
{
assert(m_file.good());

2
src/SFML/Audio/SoundFileWriterWav.hpp
View File

@ -87,7 +87,7 @@ public:
/// \param count Number of samples to write
///
////////////////////////////////////////////////////////////
void write(const std::int16_t* samples, Uint64 count) override;
void write(const std::int16_t* samples, std::uint64_t count) override;
private:
////////////////////////////////////////////////////////////

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

@ -218,7 +218,8 @@ void SoundStream::setPlayingOffset(Time timeOffset)
onSeek(timeOffset);
// Restart streaming
m_samplesProcessed = static_cast<Uint64>(timeOffset.asSeconds() * static_cast<float>(m_sampleRate)) * m_channelCount;
m_samplesProcessed = static_cast<std::uint64_t>(timeOffset.asSeconds() * static_cast<float>(m_sampleRate)) *
m_channelCount;
if (oldStatus == Stopped)
return;
@ -354,7 +355,7 @@ void SoundStream::streamData()
if (m_bufferSeeks[bufferNum] != NoLoop)
{
// This was the last buffer before EOF or Loop End: reset the sample count
m_samplesProcessed = static_cast<Uint64>(m_bufferSeeks[bufferNum]);
m_samplesProcessed = static_cast<std::uint64_t>(m_bufferSeeks[bufferNum]);
m_bufferSeeks[bufferNum] = NoLoop;
}
else
@ -377,7 +378,7 @@ void SoundStream::streamData()
}
else
{
m_samplesProcessed += static_cast<Uint64>(size / (bits / 8));
m_samplesProcessed += static_cast<std::uint64_t>(size / (bits / 8));
}
}
@ -449,7 +450,7 @@ bool SoundStream::fillAndPushBuffer(unsigned int bufferNum, bool immediateLoop)
if (immediateLoop && (m_bufferSeeks[bufferNum] != NoLoop))
{
// We just tried to begin preloading at EOF or Loop End: reset the sample count
m_samplesProcessed = static_cast<Uint64>(m_bufferSeeks[bufferNum]);
m_samplesProcessed = static_cast<std::uint64_t>(m_bufferSeeks[bufferNum]);
m_bufferSeeks[bufferNum] = NoLoop;
}

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

@ -80,10 +80,10 @@ inline T reinterpret(const U& input)
}
// Combine outline thickness, boldness and font glyph index into a single 64-bit key
sf::Uint64 combine(float outlineThickness, bool bold, std::uint32_t index)
std::uint64_t combine(float outlineThickness, bool bold, std::uint32_t index)
{
return (static_cast<sf::Uint64>(reinterpret<std::uint32_t>(outlineThickness)) << 32) |
(static_cast<sf::Uint64>(bold) << 31) | index;
return (static_cast<std::uint64_t>(reinterpret<std::uint32_t>(outlineThickness)) << 32) |
(static_cast<std::uint64_t>(bold) << 31) | index;
}
} // namespace
@ -357,7 +357,7 @@ const Glyph& Font::getGlyph(std::uint32_t codePoint, unsigned int characterSize,
GlyphTable& glyphs = loadPage(characterSize).glyphs;
// Build the key by combining the glyph index (based on code point), bold flag, and outline thickness
Uint64 key = combine(outlineThickness,
std::uint64_t key = combine(outlineThickness,
bold,
FT_Get_Char_Index(m_fontHandles ? m_fontHandles->face.get() : nullptr, codePoint));

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

@ -53,22 +53,22 @@ std::recursive_mutex mutex;
// Unique identifier, used for identifying RenderTargets when
// tracking the currently active RenderTarget within a given context
sf::Uint64 getUniqueId()
std::uint64_t getUniqueId()
{
std::scoped_lock lock(mutex);
static sf::Uint64 id = 1; // start at 1, zero is "no RenderTarget"
static std::uint64_t id = 1; // start at 1, zero is "no RenderTarget"
return id++;
}
// Map to help us detect whether a different RenderTarget
// has been activated within a single context
using ContextRenderTargetMap = std::unordered_map<sf::Uint64, sf::Uint64>;
using ContextRenderTargetMap = std::unordered_map<std::uint64_t, std::uint64_t>;
ContextRenderTargetMap contextRenderTargetMap;
// Check if a RenderTarget with the given ID is active in the current context
bool isActive(sf::Uint64 id)
bool isActive(std::uint64_t id)
{
auto it = contextRenderTargetMap.find(sf::Context::getActiveContextId());
@ -397,7 +397,7 @@ bool RenderTarget::setActive(bool active)
{
std::scoped_lock lock(RenderTargetImpl::mutex);
Uint64 contextId = Context::getActiveContextId();
std::uint64_t contextId = Context::getActiveContextId();
using RenderTargetImpl::contextRenderTargetMap;
auto it = contextRenderTargetMap.find(contextId);
@ -709,7 +709,7 @@ void RenderTarget::setupDraw(bool useVertexCache, const RenderStates& states)
}
else
{
Uint64 textureId = states.texture ? states.texture->m_cacheId : 0;
std::uint64_t textureId = states.texture ? states.texture->m_cacheId : 0;
if (textureId != m_cache.lastTextureId)
applyTexture(states.texture);
}

14
src/SFML/Graphics/RenderTextureImplFBO.cpp
View File

@ -45,7 +45,7 @@ namespace
// Set to track all active FBO mappings
// This is used to free active FBOs while their owning
// RenderTextureImplFBO is still alive
std::unordered_set<std::unordered_map<sf::Uint64, unsigned int>*> frameBuffers;
std::unordered_set<std::unordered_map<std::uint64_t, unsigned int>*> frameBuffers;
// Set to track all stale FBOs
// This is used to free stale FBOs after their owning
@ -53,7 +53,7 @@ std::unordered_set<std::unordered_map<sf::Uint64, unsigned int>*> frameBuffers;
// An FBO cannot be destroyed until it's containing context
// becomes active, so the destruction of the RenderTextureImplFBO
// has to be decoupled from the destruction of the FBOs themselves
std::set<std::pair<sf::Uint64, unsigned int>> staleFrameBuffers;
std::set<std::pair<std::uint64_t, unsigned int>> staleFrameBuffers;
// Mutex to protect both active and stale frame buffer sets
std::recursive_mutex mutex;
@ -63,7 +63,7 @@ std::recursive_mutex mutex;
// might trigger deletion of its contained stale FBOs
void destroyStaleFBOs()
{
sf::Uint64 contextId = sf::Context::getActiveContextId();
std::uint64_t contextId = sf::Context::getActiveContextId();
for (auto it = staleFrameBuffers.begin(); it != staleFrameBuffers.end();)
{
@ -86,7 +86,7 @@ void contextDestroyCallback(void* /*arg*/)
{
std::scoped_lock lock(mutex);
sf::Uint64 contextId = sf::Context::getActiveContextId();
std::uint64_t contextId = sf::Context::getActiveContextId();
// Destroy active frame buffer objects
for (auto* frameBuffer : frameBuffers)
@ -552,7 +552,7 @@ bool RenderTextureImplFBO::activate(bool active)
return true;
}
Uint64 contextId = Context::getActiveContextId();
std::uint64_t contextId = Context::getActiveContextId();
// In the odd case we have to activate and there is no active
// context yet, we have to create one
@ -582,7 +582,7 @@ bool RenderTextureImplFBO::activate(bool active)
{
std::scoped_lock lock(mutex);
std::unordered_map<Uint64, unsigned int>::iterator it;
std::unordered_map<std::uint64_t, unsigned int>::iterator it;
if (m_multisample)
{
@ -632,7 +632,7 @@ void RenderTextureImplFBO::updateTexture(unsigned int)
// are already available within the current context
if (m_multisample && m_size.x && m_size.y && activate(true))
{
Uint64 contextId = Context::getActiveContextId();
std::uint64_t contextId = Context::getActiveContextId();
std::scoped_lock lock(mutex);

4
src/SFML/Graphics/RenderTextureImplFBO.hpp
View File

@ -137,8 +137,8 @@ private:
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
std::unordered_map<Uint64, unsigned int> m_frameBuffers; //!< OpenGL frame buffer objects per context
std::unordered_map<Uint64, unsigned int> m_multisampleFrameBuffers; //!< Optional per-context OpenGL frame buffer objects with multisample attachments
std::unordered_map<std::uint64_t, unsigned int> m_frameBuffers; //!< OpenGL frame buffer objects per context
std::unordered_map<std::uint64_t, unsigned int> m_multisampleFrameBuffers; //!< Optional per-context OpenGL frame buffer objects with multisample attachments
unsigned int m_depthStencilBuffer; //!< Optional depth/stencil buffer attached to the frame buffer
unsigned int m_colorBuffer; //!< Optional multisample color buffer attached to the frame buffer
Vector2u m_size; //!< Width and height of the attachments

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

@ -50,11 +50,11 @@ std::recursive_mutex maximumSizeMutex;
// Thread-safe unique identifier generator,
// is used for states cache (see RenderTarget)
sf::Uint64 getUniqueId()
std::uint64_t getUniqueId()
{
std::scoped_lock lock(idMutex);
static sf::Uint64 id = 1; // start at 1, zero is "no texture"
static std::uint64_t id = 1; // start at 1, zero is "no texture"
return id++;
}

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

@ -233,7 +233,7 @@ Packet& Packet::operator>>(std::int64_t& data)
////////////////////////////////////////////////////////////
Packet& Packet::operator>>(Uint64& data)
Packet& Packet::operator>>(std::uint64_t& data)
{
if (checkSize(sizeof(data)))
{
@ -242,10 +242,10 @@ Packet& Packet::operator>>(Uint64& data)
std::uint8_t bytes[sizeof(data)];
std::memcpy(bytes, &m_data[m_readPos], sizeof(data));
data = (static_cast<Uint64>(bytes[0]) << 56) | (static_cast<Uint64>(bytes[1]) << 48) |
(static_cast<Uint64>(bytes[2]) << 40) | (static_cast<Uint64>(bytes[3]) << 32) |
(static_cast<Uint64>(bytes[4]) << 24) | (static_cast<Uint64>(bytes[5]) << 16) |
(static_cast<Uint64>(bytes[6]) << 8) | (static_cast<Uint64>(bytes[7]));
data = (static_cast<std::uint64_t>(bytes[0]) << 56) | (static_cast<std::uint64_t>(bytes[1]) << 48) |
(static_cast<std::uint64_t>(bytes[2]) << 40) | (static_cast<std::uint64_t>(bytes[3]) << 32) |
(static_cast<std::uint64_t>(bytes[4]) << 24) | (static_cast<std::uint64_t>(bytes[5]) << 16) |
(static_cast<std::uint64_t>(bytes[6]) << 8) | (static_cast<std::uint64_t>(bytes[7]));
m_readPos += sizeof(data);
}
@ -472,7 +472,7 @@ Packet& Packet::operator<<(std::int64_t data)
////////////////////////////////////////////////////////////
Packet& Packet::operator<<(Uint64 data)
Packet& Packet::operator<<(std::uint64_t data)
{
// Since htonll is not available everywhere, we have to convert
// to network byte order (big endian) manually

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

@ -31,6 +31,7 @@
#include <SFML/Network/Socket.hpp>
#include <arpa/inet.h>
#include <cstdint>
#include <netdb.h>
#include <netinet/in.h>
#include <netinet/tcp.h>

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

@ -31,6 +31,7 @@
#include <SFML/Network/Socket.hpp>
#include <SFML/System/Win32/WindowsHeader.hpp>
#include <cstdint>
#include <winsock2.h>
#include <ws2tcpip.h>

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

@ -97,7 +97,7 @@ const Context* Context::getActiveContext()
////////////////////////////////////////////////////////////
Uint64 Context::getActiveContextId()
std::uint64_t Context::getActiveContextId()
{
return priv::GlContext::getActiveContextId();
}

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

@ -180,7 +180,7 @@ thread_local sf::priv::GlContext* currentContext(nullptr);
std::unique_ptr<ContextType> sharedContext;
// Unique identifier, used for identifying contexts when managing unshareable OpenGL resources
sf::Uint64 id = 1; // start at 1, zero is "no context"
std::uint64_t id = 1; // start at 1, zero is "no context"
// Set containing callback functions to be called whenever a
// context is going to be destroyed
@ -601,7 +601,7 @@ const GlContext* GlContext::getActiveContext()
////////////////////////////////////////////////////////////
Uint64 GlContext::getActiveContextId()
std::uint64_t GlContext::getActiveContextId()
{
using GlContextImpl::currentContext;
return currentContext ? currentContext->m_id : 0;

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

@ -34,6 +34,7 @@
#include <SFML/Window/ContextSettings.hpp>
#include <SFML/Window/GlResource.hpp>
#include <cstdint>
#include <memory>
@ -174,7 +175,7 @@ public:
/// \return The active context's ID or 0 if no context is currently active
///
////////////////////////////////////////////////////////////
static Uint64 getActiveContextId();
static std::uint64_t getActiveContextId();
////////////////////////////////////////////////////////////
/// \brief Destructor
@ -319,7 +320,7 @@ private:
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
const Uint64 m_id; //!< Unique number that identifies the context
const std::uint64_t m_id; //!< Unique number that identifies the context
};
} // namespace priv

1
src/SFML/Window/OSX/NSImage+raw.h
View File

@ -29,6 +29,7 @@
#include <SFML/Config.hpp>
#import <AppKit/AppKit.h>
#include <cstdint>
////////////////////////////////////////////////////////////
/// Extends NSImage with a convenience method to load images

1
src/SFML/Window/OSX/WindowImplDelegateProtocol.h
View File

@ -31,6 +31,7 @@
#include <SFML/Window/WindowHandle.hpp>
#import <AppKit/AppKit.h>
#include <cstdint>
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

5
test/System/Config.cpp
View File

@ -11,9 +11,4 @@ TEST_CASE("SFML/Config.hpp")
CHECK(SFML_VERSION_PATCH == EXPECTED_SFML_VERSION_PATCH);
CHECK(SFML_VERSION_IS_RELEASE == EXPECTED_SFML_VERSION_IS_RELEASE);
}
SUBCASE("Fixed width types")
{
CHECK(sizeof(sf::Uint64) == 8);
}
}