admin/CSFML
1
0 Fork 0
mirror of https://github.com/SFML/CSFML.git synced 2026-10-24 21:53:37 +02:00
Code Issues Packages Projects Releases Wiki Activity

Implement new sf::Clock functions

Browse Source
This commit is contained in:
Chris Thrasher committed 2024-09-20 17:08:32 -05:00
1 parent fbe6e6193f
commit 4ef89bb387
3 files changed
+133 -12
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

include/CSFML/System/Clock.h
+45
View File
@@ -73,6 +73,36 @@ CSFML_SYSTEM_API void sfClock_destroy(const sfClock* clock);
////////////////////////////////////////////////////////////
CSFML_SYSTEM_API sfTime sfClock_getElapsedTime(const sfClock* clock);
////////////////////////////////////////////////////////////
/// \brief Check whether the clock is running
///
/// \param clock Clock object
///
/// \return `true` if the clock is running, `false` otherwise
///
////////////////////////////////////////////////////////////
CSFML_SYSTEM_API bool sfClock_isRunning(const sfClock* clock);
////////////////////////////////////////////////////////////
/// \brief Start the clock
///
/// \param clock Clock object
///
/// \see `stop`
///
////////////////////////////////////////////////////////////
CSFML_SYSTEM_API void sfClock_start(sfClock* clock);
////////////////////////////////////////////////////////////
/// \brief Stop the clock
///
/// \param clock Clock object
///
/// \see `start`
///
////////////////////////////////////////////////////////////
CSFML_SYSTEM_API void sfClock_stop(sfClock* clock);
////////////////////////////////////////////////////////////
/// \brief Restart a clock
///
@@ -85,3 +115,18 @@ CSFML_SYSTEM_API sfTime sfClock_getElapsedTime(const sfClock* clock);
///
////////////////////////////////////////////////////////////
CSFML_SYSTEM_API sfTime sfClock_restart(sfClock* clock);
////////////////////////////////////////////////////////////
/// \brief Reset the clock
///
/// This function puts the time counter back to zero, returns
/// the elapsed time, and leaves the clock in a paused state.
///
/// \param clock Clock object
///
/// \return Time elapsed
///
/// \see `restart`
///
////////////////////////////////////////////////////////////
CSFML_SYSTEM_API sfTime sfClock_reset(sfClock* clock);
src/CSFML/System/Clock.cpp
+32
View File
@@ -61,9 +61,41 @@ sfTime sfClock_getElapsedTime(const sfClock* clock)
}
////////////////////////////////////////////////////////////
bool sfClock_isRunning(const sfClock* clock)
{
assert(clock);
return clock->This.isRunning();
}
////////////////////////////////////////////////////////////
void sfClock_start(sfClock* clock)
{
assert(clock);
clock->This.start();
}
////////////////////////////////////////////////////////////
void sfClock_stop(sfClock* clock)
{
assert(clock);
clock->This.stop();
}
////////////////////////////////////////////////////////////
sfTime sfClock_restart(sfClock* clock)
{
assert(clock);
return {clock->This.restart().asMicroseconds()};
}
////////////////////////////////////////////////////////////
sfTime sfClock_reset(sfClock* clock)
{
assert(clock);
return {clock->This.reset().asMicroseconds()};
}
test/System/Clock.test.cpp
+56 -12
View File
@@ -6,20 +6,64 @@
TEST_CASE("[System] sfClock")
{
sfClock* clock = sfClock_create();
using namespace std::chrono_literals;
CHECK(sfTime_asMicroseconds(sfClock_getElapsedTime(clock)) >= 0);
std::this_thread::sleep_for(std::chrono::milliseconds(1));
CHECK(sfTime_asMicroseconds(sfClock_getElapsedTime(clock)) >= 1'000);
SECTION("sfClock_create/sfClock_copy")
{
const sfClock* clock1 = sfClock_create();
CHECK(sfTime_asMicroseconds(sfClock_getElapsedTime(clock1)) >= 0);
CHECK(sfClock_isRunning(clock1));
sfClock_restart(clock);
CHECK(sfTime_asMicroseconds(sfClock_getElapsedTime(clock)) >= 0);
std::this_thread::sleep_for(std::chrono::milliseconds(1));
CHECK(sfTime_asMicroseconds(sfClock_getElapsedTime(clock)) >= 1'000);
const auto elapsed = sfClock_getElapsedTime(clock1);
const sfClock* clock2 = sfClock_copy(clock1);
CHECK(sfTime_asMicroseconds(sfClock_getElapsedTime(clock2)) >= sfTime_asMicroseconds(elapsed));
CHECK(sfClock_isRunning(clock2));
sfClock* anotherClock = sfClock_copy(clock);
CHECK(sfTime_asMicroseconds(sfClock_getElapsedTime(anotherClock)) >= 1'000);
sfClock_destroy(clock2);
sfClock_destroy(clock1);
}
sfClock_destroy(anotherClock);
sfClock_destroy(clock);
SECTION("sfClock_getElapsedTime")
{
const sfClock* clock = sfClock_create();
CHECK(sfTime_asMicroseconds(sfClock_getElapsedTime(clock)) >= 0);
const auto elapsed = sfClock_getElapsedTime(clock);
std::this_thread::sleep_for(1ms);
CHECK(sfTime_asMicroseconds(sfClock_getElapsedTime(clock)) >= sfTime_asMicroseconds(elapsed));
sfClock_destroy(clock);
}
SECTION("sfClock_start/sfClock_stop")
{
sfClock* clock = sfClock_create();
sfClock_stop(clock);
CHECK(!sfClock_isRunning(clock));
const auto elapsed = sfClock_getElapsedTime(clock);
std::this_thread::sleep_for(1ms);
CHECK(sfTime_asMicroseconds(sfClock_getElapsedTime(clock)) == sfTime_asMicroseconds(elapsed));
sfClock_start(clock);
CHECK(sfTime_asMicroseconds(sfClock_getElapsedTime(clock)) >= sfTime_asMicroseconds(elapsed));
CHECK(sfClock_isRunning(clock));
sfClock_destroy(clock);
}
SECTION("sfClock_restart")
{
sfClock* clock = sfClock_create();
CHECK(sfTime_asMicroseconds(sfClock_restart(clock)) >= 0);
CHECK(sfClock_isRunning(clock));
std::this_thread::sleep_for(1ms);
const auto elapsed = sfClock_restart(clock);
CHECK(sfTime_asMicroseconds(sfClock_restart(clock)) < sfTime_asMicroseconds(elapsed));
sfClock_destroy(clock);
}
SECTION("sfClock_reset")
{
sfClock* clock = sfClock_create();
CHECK(sfTime_asMicroseconds(sfClock_reset(clock)) >= 0);
CHECK(!sfClock_isRunning(clock));
sfClock_destroy(clock);
}
}