YourWishes/dusk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

First round of animation improvements

Browse Source
This commit is contained in:
Dominic Masters
2026-07-20 16:07:38 -05:00
parent 7ceb9e571d
commit 0826908068
20 changed files with 1049 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/animation/CMakeLists.txt
+11
View File
@@ -0,0 +1,11 @@
# Copyright (c) 2026 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
include(dusktest)
# Tests
dusktest(test_keyframe.c)
dusktest(test_keyframeset.c)
dusktest(test_animation.c)
test/animation/test_animation.c
+111
View File
@@ -0,0 +1,111 @@
/**
* Copyright (c) 2026 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "dusktest.h"
#include "time/time.h"
#include "animation/animation.h"
static void test_animationInitDefaults(void **state) {
keyframe_t keyframes[] = {
{ .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR },
{ .time = 1.0f, .value = 10.0f, .easing = EASING_LINEAR }
};
keyframe_t *tracks[] = { keyframes };
uint16_t trackCounts[] = { 2 };
animation_t anim;
animationInit(&anim, tracks, trackCounts, 1);
assert_float_equal(anim.time, 0.0f, 0.0001f);
assert_float_equal(anim.speed, 1.0f, 0.0001f);
assert_false(anim.loop);
assert_false(anim.playing);
assert_float_equal(animationGetValue(&anim, 0), 0.0f, 0.0001f);
}
static void test_animationUpdateNoopWhenNotPlaying(void **state) {
keyframe_t keyframes[] = {
{ .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR },
{ .time = 1.0f, .value = 10.0f, .easing = EASING_LINEAR }
};
keyframe_t *tracks[] = { keyframes };
uint16_t trackCounts[] = { 2 };
animation_t anim;
animationInit(&anim, tracks, trackCounts, 1);
TIME.delta = 1.0f;
animationUpdate(&anim);
assert_float_equal(anim.time, 0.0f, 0.0001f);
}
static void test_animationUpdateStopsAtEndWhenNotLooping(void **state) {
keyframe_t keyframes[] = {
{ .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR },
{ .time = 1.0f, .value = 10.0f, .easing = EASING_LINEAR }
};
keyframe_t *tracks[] = { keyframes };
uint16_t trackCounts[] = { 2 };
animation_t anim;
animationInit(&anim, tracks, trackCounts, 1);
anim.playing = true;
TIME.delta = 0.5f;
animationUpdate(&anim);
assert_true(anim.playing);
assert_float_equal(animationGetValue(&anim, 0), 5.0f, 0.0001f);
animationUpdate(&anim);
assert_false(anim.playing);
assert_float_equal(animationGetValue(&anim, 0), 10.0f, 0.0001f);
// Stays clamped/held once stopped, even if updated again.
animationUpdate(&anim);
assert_float_equal(anim.time, 1.0f, 0.0001f);
}
static void test_animationUpdateLoopsWithMultipleChannels(void **state) {
keyframe_t xKeyframes[] = {
{ .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR },
{ .time = 1.0f, .value = 10.0f, .easing = EASING_LINEAR }
};
keyframe_t yKeyframes[] = {
{ .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR },
{ .time = 2.0f, .value = 100.0f, .easing = EASING_LINEAR }
};
keyframe_t *tracks[] = { xKeyframes, yKeyframes };
uint16_t trackCounts[] = { 2, 2 };
animation_t anim;
animationInit(&anim, tracks, trackCounts, 2);
anim.loop = true;
anim.playing = true;
// Duration is the longer (Y) channel's 2s -- looping wraps against
// that, not X's shorter 1s.
TIME.delta = 1.5f;
animationUpdate(&anim);
assert_true(anim.playing);
assert_float_equal(anim.time, 1.5f, 0.0001f);
animationUpdate(&anim);
// 1.5 + 1.5 = 3.0 -> wraps to 1.0 against a 2.0s duration.
assert_true(anim.playing);
assert_float_equal(anim.time, 1.0f, 0.0001f);
}
int main(int argc, char **argv) {
const struct CMUnitTest tests[] = {
cmocka_unit_test(test_animationInitDefaults),
cmocka_unit_test(test_animationUpdateNoopWhenNotPlaying),
cmocka_unit_test(test_animationUpdateStopsAtEndWhenNotLooping),
cmocka_unit_test(test_animationUpdateLoopsWithMultipleChannels),
};
return cmocka_run_group_tests(tests, NULL, NULL);
}
test/animation/test_keyframe.c
+66
View File
@@ -0,0 +1,66 @@
/**
* Copyright (c) 2026 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "dusktest.h"
#include "animation/keyframe.h"
static void test_keyframeGetValueInterpolatesLinear(void **state) {
keyframe_t keyframes[] = {
{ .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR },
{ .time = 1.0f, .value = 10.0f, .easing = EASING_LINEAR }
};
assert_float_equal(keyframeGetValue(keyframes, 2, 0.5f), 5.0f, 0.0001f);
}
static void test_keyframeGetValueClampsAtBoundaries(void **state) {
keyframe_t keyframes[] = {
{ .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR },
{ .time = 1.0f, .value = 10.0f, .easing = EASING_LINEAR }
};
// Exactly on, and beyond, the final keyframe: holds its value rather
// than dividing by zero (start == end at that boundary).
assert_float_equal(keyframeGetValue(keyframes, 2, 1.0f), 10.0f, 0.0001f);
assert_float_equal(keyframeGetValue(keyframes, 2, 5.0f), 10.0f, 0.0001f);
// Exactly on the first keyframe: same boundary case at the start.
assert_float_equal(keyframeGetValue(keyframes, 2, 0.0f), 0.0f, 0.0001f);
}
static void test_keyframeGetValueRespectsEasing(void **state) {
keyframe_t keyframes[] = {
{ .time = 0.0f, .value = 0.0f, .easing = EASING_IN_QUAD },
{ .time = 1.0f, .value = 10.0f, .easing = EASING_IN_QUAD }
};
// easingInQuad(0.5) = 0.25 -> lerp(0, 10, 0.25) = 2.5, not the linear
// midpoint (5.0).
assert_float_equal(keyframeGetValue(keyframes, 2, 0.5f), 2.5f, 0.0001f);
}
static void test_keyframeGetValueWithThreeKeyframes(void **state) {
keyframe_t keyframes[] = {
{ .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR },
{ .time = 1.0f, .value = 10.0f, .easing = EASING_LINEAR },
{ .time = 2.0f, .value = 0.0f, .easing = EASING_LINEAR }
};
assert_float_equal(keyframeGetValue(keyframes, 3, 1.0f), 10.0f, 0.0001f);
assert_float_equal(keyframeGetValue(keyframes, 3, 1.5f), 5.0f, 0.0001f);
}
int main(int argc, char **argv) {
const struct CMUnitTest tests[] = {
cmocka_unit_test(test_keyframeGetValueInterpolatesLinear),
cmocka_unit_test(test_keyframeGetValueClampsAtBoundaries),
cmocka_unit_test(test_keyframeGetValueRespectsEasing),
cmocka_unit_test(test_keyframeGetValueWithThreeKeyframes),
};
return cmocka_run_group_tests(tests, NULL, NULL);
}
test/animation/test_keyframeset.c
+77
View File
@@ -0,0 +1,77 @@
/**
* Copyright (c) 2026 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "dusktest.h"
#include "animation/keyframeset.h"
static void test_keyframeSetGetValuePerTrack(void **state) {
keyframe_t xKeyframes[] = {
{ .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR },
{ .time = 1.0f, .value = 10.0f, .easing = EASING_LINEAR }
};
keyframe_t yKeyframes[] = {
{ .time = 0.0f, .value = 100.0f, .easing = EASING_LINEAR },
{ .time = 1.0f, .value = 200.0f, .easing = EASING_LINEAR }
};
keyframe_t *tracks[] = { xKeyframes, yKeyframes };
uint16_t trackCounts[] = { 2, 2 };
keyframeset_t set;
keyframeSetInit(&set, tracks, trackCounts, 2);
assert_float_equal(keyframeSetGetValue(&set, 0, 0.5f), 5.0f, 0.0001f);
assert_float_equal(keyframeSetGetValue(&set, 1, 0.5f), 150.0f, 0.0001f);
}
static void test_keyframeSetGetValuesFillsAllTracks(void **state) {
keyframe_t xKeyframes[] = {
{ .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR },
{ .time = 1.0f, .value = 10.0f, .easing = EASING_LINEAR }
};
keyframe_t yKeyframes[] = {
{ .time = 0.0f, .value = 100.0f, .easing = EASING_LINEAR },
{ .time = 1.0f, .value = 200.0f, .easing = EASING_LINEAR }
};
keyframe_t *tracks[] = { xKeyframes, yKeyframes };
uint16_t trackCounts[] = { 2, 2 };
keyframeset_t set;
keyframeSetInit(&set, tracks, trackCounts, 2);
float_t values[2];
keyframeSetGetValues(&set, 0.5f, values);
assert_float_equal(values[0], 5.0f, 0.0001f);
assert_float_equal(values[1], 150.0f, 0.0001f);
}
static void test_keyframeSetGetDurationIsLongestTrack(void **state) {
keyframe_t shortKeyframes[] = {
{ .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR },
{ .time = 1.0f, .value = 10.0f, .easing = EASING_LINEAR }
};
keyframe_t longKeyframes[] = {
{ .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR },
{ .time = 3.5f, .value = 10.0f, .easing = EASING_LINEAR }
};
keyframe_t *tracks[] = { shortKeyframes, longKeyframes };
uint16_t trackCounts[] = { 2, 2 };
keyframeset_t set;
keyframeSetInit(&set, tracks, trackCounts, 2);
assert_float_equal(keyframeSetGetDuration(&set), 3.5f, 0.0001f);
}
int main(int argc, char **argv) {
const struct CMUnitTest tests[] = {
cmocka_unit_test(test_keyframeSetGetValuePerTrack),
cmocka_unit_test(test_keyframeSetGetValuesFillsAllTracks),
cmocka_unit_test(test_keyframeSetGetDurationIsLongestTrack),
};
return cmocka_run_group_tests(tests, NULL, NULL);
}