martin
/
AnimTestbed
1
0
Fork 0
Code Issues 11 Pull Requests Projects 1 Releases Wiki Activity
AnimTestbed/3rdparty/ozz-animation/test/animation/runtime/track_triggering_job_tests.cc

1407 lines
44 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------//
// //
// ozz-animation is hosted at http://github.com/guillaumeblanc/ozz-animation //
// and distributed under the MIT License (MIT). //
// //
// Copyright (c) Guillaume Blanc //
// //
// Permission is hereby granted, free of charge, to any person obtaining a //
// copy of this software and associated documentation files (the "Software"), //
// to deal in the Software without restriction, including without limitation //
// the rights to use, copy, modify, merge, publish, distribute, sublicense, //
// and/or sell copies of the Software, and to permit persons to whom the //
// Software is furnished to do so, subject to the following conditions: //
// //
// The above copyright notice and this permission notice shall be included in //
// all copies or substantial portions of the Software. //
// //
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR //
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, //
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL //
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER //
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING //
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER //
// DEALINGS IN THE SOFTWARE. //
// //
//----------------------------------------------------------------------------//
#include "gtest/gtest.h"
#include "ozz/animation/offline/raw_track.h"
#include "ozz/animation/offline/track_builder.h"
#include "ozz/animation/runtime/track.h"
#include "ozz/animation/runtime/track_triggering_job.h"
#include "ozz/base/gtest_helper.h"
#include "ozz/base/maths/gtest_math_helper.h"
#include "ozz/base/memory/unique_ptr.h"
using ozz::animation::FloatTrack;
using ozz::animation::TrackTriggeringJob;
using ozz::animation::offline::RawFloatTrack;
using ozz::animation::offline::RawTrackInterpolation;
using ozz::animation::offline::TrackBuilder;
TEST(JobValidity, TrackTriggeringJob) {
// Builds track
ozz::animation::offline::RawFloatTrack raw_track;
TrackBuilder builder;
ozz::unique_ptr<FloatTrack> track(builder(raw_track));
ASSERT_TRUE(track);
{ // Default is invalid
TrackTriggeringJob job;
EXPECT_FALSE(job.Validate());
EXPECT_FALSE(job.Run());
}
{ // No track
TrackTriggeringJob job;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
EXPECT_FALSE(job.Validate());
EXPECT_FALSE(job.Run());
}
{ // No output
TrackTriggeringJob job;
job.track = track.get();
EXPECT_FALSE(job.Validate());
EXPECT_FALSE(job.Run());
}
{ // Valid
TrackTriggeringJob job;
job.track = track.get();
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
EXPECT_TRUE(job.Validate());
EXPECT_TRUE(job.Run());
}
{ // Valid
TrackTriggeringJob job;
job.from = 0.f;
job.to = 1.f;
job.track = track.get();
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
EXPECT_TRUE(job.Validate());
EXPECT_TRUE(job.Run());
}
{ // Empty output is valid
TrackTriggeringJob job;
job.track = track.get();
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
EXPECT_TRUE(job.Validate());
EXPECT_TRUE(job.Run());
}
}
TEST(Default, TrackEdgeTriggerJob) {
FloatTrack default_track;
TrackTriggeringJob job;
job.track = &default_track;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
EXPECT_EQ(iterator, job.end());
}
TEST(Empty, TrackEdgeTriggerJob) {
TrackBuilder builder;
// Builds track
ozz::animation::offline::RawFloatTrack raw_track;
ozz::unique_ptr<FloatTrack> track(builder(raw_track));
ASSERT_TRUE(track);
TrackTriggeringJob job;
job.track = track.get();
job.threshold = 1.f;
job.from = 0.f;
job.to = 1.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
EXPECT_EQ(iterator, job.end());
}
TEST(Iterator, TrackEdgeTriggerJob) {
TrackBuilder builder;
ozz::animation::offline::RawFloatTrack raw_track;
// Keyframe values oscillate in range [0,2].
const ozz::animation::offline::RawFloatTrack::Keyframe key0 = {
RawTrackInterpolation::kStep, 0.f, 0.f};
raw_track.keyframes.push_back(key0);
const ozz::animation::offline::RawFloatTrack::Keyframe key1 = {
RawTrackInterpolation::kStep, .5f, 2.f};
raw_track.keyframes.push_back(key1);
const ozz::animation::offline::RawFloatTrack::Keyframe key2 = {
RawTrackInterpolation::kStep, 1.f, 0.f};
raw_track.keyframes.push_back(key2);
// Builds track
ozz::unique_ptr<FloatTrack> track(builder(raw_track));
ASSERT_TRUE(track);
TrackTriggeringJob job;
job.track = track.get();
job.threshold = 1.f;
job.from = 0.f;
job.to = 2.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
EXPECT_TRUE(iterator == iterator);
EXPECT_FALSE(iterator != iterator);
EXPECT_TRUE(job.end() == job.end());
EXPECT_FALSE(job.end() != job.end());
EXPECT_TRUE(iterator != job.end());
EXPECT_FALSE(iterator == job.end());
TrackTriggeringJob::Iterator iterator_cpy(iterator);
EXPECT_TRUE(iterator == iterator_cpy);
EXPECT_FALSE(iterator != iterator_cpy);
TrackTriggeringJob::Iterator default_iterator;
EXPECT_TRUE(default_iterator == default_iterator);
EXPECT_FALSE(default_iterator != default_iterator);
EXPECT_TRUE(default_iterator != iterator);
EXPECT_FALSE(default_iterator == iterator);
EXPECT_TRUE(default_iterator != job.end());
EXPECT_FALSE(default_iterator == job.end());
{ // Other jobs
TrackTriggeringJob job2;
job2.track = track.get();
job2.threshold = 1.f;
job2.from = 0.f;
job2.to = 1.f;
TrackTriggeringJob::Iterator iterator2;
job2.iterator = &iterator2;
ASSERT_TRUE(job2.Run());
EXPECT_TRUE(iterator2 != iterator);
EXPECT_FALSE(iterator2 == iterator);
}
{ // *
EXPECT_TRUE((*iterator).rising);
TrackTriggeringJob::Edge edge;
EXPECT_ASSERTION(edge = *job.end(), "Can't dereference end iterator");
(void)edge;
}
{ // ->
EXPECT_TRUE(iterator->rising);
bool rising;
EXPECT_ASSERTION(rising = job.end()->rising,
"Can't dereference end iterator");
(void)rising;
}
{ // Pre increment
TrackTriggeringJob::Iterator iterator_cpy1(iterator);
TrackTriggeringJob::Iterator iterator_cpy2(iterator);
++iterator_cpy1;
EXPECT_TRUE(iterator_cpy1 != iterator_cpy2);
EXPECT_FALSE(iterator_cpy1 == iterator_cpy2);
++iterator_cpy2;
EXPECT_TRUE(iterator_cpy1 == iterator_cpy2);
EXPECT_FALSE(iterator_cpy1 != iterator_cpy2);
EXPECT_TRUE(++iterator_cpy1 != iterator_cpy2++);
EXPECT_ASSERTION(++job.end(), "Can't increment end iterator.");
}
{ // Post increment
TrackTriggeringJob::Iterator iterator_cpy1(iterator);
TrackTriggeringJob::Iterator iterator_cpy2(iterator);
iterator_cpy1++;
EXPECT_TRUE(iterator_cpy1 != iterator_cpy2);
EXPECT_FALSE(iterator_cpy1 == iterator_cpy2);
iterator_cpy2++;
EXPECT_TRUE(iterator_cpy1 == iterator_cpy2);
EXPECT_FALSE(iterator_cpy1 != iterator_cpy2);
EXPECT_TRUE((++iterator_cpy1)->rising != (iterator_cpy2++)->rising);
EXPECT_TRUE(iterator_cpy1->rising == iterator_cpy2->rising);
EXPECT_ASSERTION(job.end()++, "Can't increment end iterator.");
}
{ // Assignment
TrackTriggeringJob::Iterator iterator_cpy1(iterator);
TrackTriggeringJob::Iterator iterator_cpy2(iterator);
++iterator_cpy1;
EXPECT_TRUE(iterator_cpy1 != iterator_cpy2);
iterator_cpy2 = iterator_cpy1;
EXPECT_TRUE(iterator_cpy1 == iterator_cpy2);
++iterator_cpy1;
++iterator_cpy2;
EXPECT_TRUE(iterator_cpy1 == iterator_cpy2);
}
{ // Loop
TrackTriggeringJob::Iterator iterator_cpy1(iterator);
TrackTriggeringJob::Iterator iterator_cpy2(iterator);
for (; iterator_cpy1 != job.end(); ++iterator_cpy1, iterator_cpy2++) {
}
EXPECT_TRUE(iterator_cpy2 == job.end());
}
}
TEST(NoRange, TrackEdgeTriggerJob) {
TrackBuilder builder;
ozz::animation::offline::RawFloatTrack raw_track;
// Keyframe values oscillate in range [0,2].
const ozz::animation::offline::RawFloatTrack::Keyframe key0 = {
RawTrackInterpolation::kStep, 0.f, 0.f};
raw_track.keyframes.push_back(key0);
const ozz::animation::offline::RawFloatTrack::Keyframe key1 = {
RawTrackInterpolation::kStep, .5f, 2.f};
raw_track.keyframes.push_back(key1);
const ozz::animation::offline::RawFloatTrack::Keyframe key2 = {
RawTrackInterpolation::kStep, 1.f, 0.f};
raw_track.keyframes.push_back(key2);
// Builds track
ozz::unique_ptr<FloatTrack> track(builder(raw_track));
ASSERT_TRUE(track);
TrackTriggeringJob job;
job.track = track.get();
job.threshold = 1.f;
{ // Forward [0., 0.[
job.from = 0.f;
job.to = 0.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
EXPECT_TRUE(iterator == job.end());
}
{ // Forward [.1, .1]
job.from = .1f;
job.to = .1f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
EXPECT_TRUE(iterator == job.end());
}
{ // Forward [.5, .5[
job.from = .5f;
job.to = .5f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
EXPECT_TRUE(iterator == job.end());
}
{ // Forward [1., 1.]
job.from = 1.f;
job.to = 1.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
EXPECT_TRUE(iterator == job.end());
}
{ // Forward [-.5, -.5[
job.from = -.5f;
job.to = -.5f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
EXPECT_TRUE(iterator == job.end());
}
}
size_t CountEdges(TrackTriggeringJob::Iterator _begin,
const TrackTriggeringJob::Iterator& _end) {
size_t count = 0;
for (; _begin != _end; ++_begin, ++count) {
}
return count;
}
void TestEdgesExpectationBackward(TrackTriggeringJob::Iterator _fw_iterator,
const TrackTriggeringJob& _fw_job) {
// Compute forward edges;
ozz::vector<TrackTriggeringJob::Edge> fw_edges;
for (; _fw_iterator != _fw_job.end(); ++_fw_iterator) {
fw_edges.push_back(*_fw_iterator);
}
// Setup backward job from forward one.
TrackTriggeringJob bw_job = _fw_job;
std::swap(bw_job.from, bw_job.to);
TrackTriggeringJob::Iterator bw_iterator;
bw_job.iterator = &bw_iterator;
ASSERT_TRUE(bw_job.Run());
// Compare forward and backward iterations.
ASSERT_EQ(fw_edges.size(), CountEdges(bw_iterator, bw_job.end()));
for (ozz::vector<TrackTriggeringJob::Edge>::const_reverse_iterator fw_rit =
fw_edges.rbegin();
fw_rit != fw_edges.rend(); ++fw_rit, ++bw_iterator) {
EXPECT_FLOAT_EQ(fw_rit->ratio, bw_iterator->ratio);
EXPECT_EQ(fw_rit->rising, !bw_iterator->rising);
}
}
void TestEdgesExpectation(
const ozz::animation::offline::RawFloatTrack& _raw_track, float _threshold,
const TrackTriggeringJob::Edge* _expected, size_t _size) {
assert(_size >= 2);
// Builds track
ozz::unique_ptr<FloatTrack> track(TrackBuilder()(_raw_track));
ASSERT_TRUE(track);
TrackTriggeringJob job;
job.track = track.get();
job.threshold = _threshold;
{ // Forward [0, 1]
job.from = 0.f;
job.to = 1.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), _size);
TrackTriggeringJob::Iterator it = iterator;
for (size_t i = 0; it != job.end(); ++it, ++i) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i].ratio);
EXPECT_EQ(it->rising, _expected[i].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward [1, 2]
job.from = 1.f;
job.to = 2.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), _size);
TrackTriggeringJob::Iterator it = iterator;
for (size_t i = 0; it != job.end(); ++it, ++i) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i].ratio + 1.f);
EXPECT_EQ(it->rising, _expected[i].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward [0, 3]
job.from = 0.f;
job.to = 3.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), _size * 3);
TrackTriggeringJob::Iterator it = iterator;
for (size_t i = 0; it != job.end(); ++it, ++i) {
const size_t ie = i % _size;
const float loops = static_cast<float>(i / _size);
EXPECT_FLOAT_EQ(it->ratio, _expected[ie].ratio + loops);
EXPECT_EQ(it->rising, _expected[ie].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward, first edge to last, last can be included.
// Last edge is included if it ratio is 1.f.
const bool last_included = _expected[_size - 1].ratio == 1.f;
job.from = _expected[0].ratio;
job.to = _expected[_size - 1].ratio;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()),
last_included ? _size : _size - 1);
TrackTriggeringJob::Iterator it = iterator;
for (size_t i = 0; it != job.end(); ++it, ++i) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i].ratio);
EXPECT_EQ(it->rising, _expected[i].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward, after first edge to 1.
job.from = nexttowardf(_expected[0].ratio, 1.f);
job.to = 1.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), _size - 1);
TrackTriggeringJob::Iterator it = iterator;
for (size_t i = 0; it != job.end(); ++it, ++i) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i + 1].ratio);
EXPECT_EQ(it->rising, _expected[i + 1].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward, 0 to first edge.
job.from = 0.f;
job.to = _expected[0].ratio;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), 0u);
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward, 0 to after first edge.
job.from = 0.f;
job.to = nexttowardf(_expected[0].ratio, 1.f);
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), 1u);
EXPECT_FLOAT_EQ(iterator->ratio, _expected[0].ratio);
EXPECT_EQ(iterator->rising, _expected[0].rising);
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward, 0 to before last edge.
job.from = 0.f;
job.to = nexttowardf(_expected[_size - 1].ratio, 0.f);
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), _size - 1);
TrackTriggeringJob::Iterator it = iterator;
for (size_t i = 0; it != job.end(); ++it, ++i) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i].ratio);
EXPECT_EQ(it->rising, _expected[i].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward, 0 to after last edge.
job.from = 0.f;
job.to = nexttowardf(_expected[_size - 1].ratio, 1.f);
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), _size);
TrackTriggeringJob::Iterator it = iterator;
for (size_t i = 0; it != job.end(); ++it, ++i) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i].ratio);
EXPECT_EQ(it->rising, _expected[i].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward, 1 to after last edge + 1.
job.from = 1.f;
job.to = nexttowardf(_expected[_size - 1].ratio + 1.f, 2.f);
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), _size);
TrackTriggeringJob::Iterator it = iterator;
for (size_t i = 0; it != job.end(); ++it, ++i) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i].ratio + 1.f);
EXPECT_EQ(it->rising, _expected[i].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward, 46 to after last edge + 46.
job.from = 46.f;
job.to = nexttowardf(_expected[_size - 1].ratio + 46.f, 100.f);
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), _size);
TrackTriggeringJob::Iterator it = iterator;
for (size_t i = 0; it != job.end(); ++it, ++i) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i].ratio + 46.f);
EXPECT_EQ(it->rising, _expected[i].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward, 46 to before last edge + 46.
job.from = 46.f;
job.to = nexttowardf(_expected[_size - 1].ratio + 46.f, -100.f);
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), _size - 1);
TrackTriggeringJob::Iterator it = iterator;
for (size_t i = 0; it != job.end(); ++it, ++i) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i].ratio + 46.f);
EXPECT_EQ(it->rising, _expected[i].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward, 46 to last edge + 46.
const bool last_included = _expected[_size - 1].ratio == 1.f;
job.from = 46.f;
job.to = _expected[_size - 1].ratio + 46.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()),
last_included ? _size : _size - 1);
TrackTriggeringJob::Iterator it = iterator;
for (size_t i = 0; it != job.end(); ++it, ++i) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i].ratio + 46.f);
EXPECT_EQ(it->rising, _expected[i].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward, 0 to before last edge + 1
const bool last_included = _expected[_size - 1].ratio == 1.f;
job.from = 0.f;
job.to = _expected[_size - 1].ratio + 1.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()),
last_included ? _size * 2 : _size * 2 - 1);
TrackTriggeringJob::Iterator it = iterator;
for (size_t i = 0; i < _size; ++i, ++it) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i].ratio);
EXPECT_EQ(it->rising, _expected[i].rising);
}
for (size_t i = _size; i < (last_included ? _size * 2 : _size * 2 - 1);
++i, ++it) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i - _size].ratio + 1.f);
EXPECT_EQ(it->rising, _expected[i - _size].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
// Negative times
{ // Forward [-1, 0]
job.from = -1.f;
job.to = 0.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), _size);
TrackTriggeringJob::Iterator it = iterator;
for (size_t i = 0; it != job.end(); ++it, ++i) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i].ratio - 1.f);
EXPECT_EQ(it->rising, _expected[i].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward [-2, -1]
job.from = -2.f;
job.to = -1.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), _size);
TrackTriggeringJob::Iterator it = iterator;
for (size_t i = 0; it != job.end(); ++it, ++i) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i].ratio - 2.f);
EXPECT_EQ(it->rising, _expected[i].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward [-1, 1]
job.from = -1.f;
job.to = 1.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), _size * 2);
TrackTriggeringJob::Iterator it = iterator;
for (size_t i = 0; i < _size; ++i, ++it) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i].ratio - 1.f);
EXPECT_EQ(it->rising, _expected[i].rising);
}
for (size_t i = 0; i < _size; ++i, ++it) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i].ratio);
EXPECT_EQ(it->rising, _expected[i].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward, -1 to first edge.
job.from = -1.f;
job.to = _expected[0].ratio - 1.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), 0u);
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward, -1 to after last edge.
job.from = -1.f;
job.to = _expected[_size - 1].ratio - .999999f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), _size);
TrackTriggeringJob::Iterator it = iterator;
for (size_t i = 0; it != job.end(); ++it, ++i) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i].ratio - 1.f);
EXPECT_EQ(it->rising, _expected[i].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward [-1, -eps]
// Last edge is included if it ratio is not 1.f.
const bool last_included = _expected[_size - 1].ratio != 1.f;
job.from = -1.f;
job.to = nexttowardf(0.f, -1.f);
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()),
last_included ? _size : _size - 1);
TrackTriggeringJob::Iterator it = iterator;
for (size_t i = 0; it != job.end(); ++it, ++i) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i].ratio - 1.f);
EXPECT_EQ(it->rising, _expected[i].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward [-eps, ..]
// Last edge is included if it ratio is 1.f.
const bool last_included = _expected[_size - 1].ratio == 1.f;
job.from = nexttowardf(0.f, -1.f);
job.to = nexttowardf(_expected[0].ratio, 1.f);
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
if (last_included) {
ASSERT_EQ(CountEdges(iterator, job.end()), 2u);
TrackTriggeringJob::Iterator it = iterator;
EXPECT_FLOAT_EQ(it->ratio, _expected[_size - 1].ratio - 1.f);
EXPECT_EQ(it->rising, _expected[_size - 1].rising);
++it;
EXPECT_FLOAT_EQ(it->ratio, _expected[0].ratio);
EXPECT_EQ(it->rising, _expected[0].rising);
} else {
ASSERT_EQ(CountEdges(iterator, job.end()), 1u);
TrackTriggeringJob::Iterator it = iterator;
EXPECT_FLOAT_EQ(it->ratio, _expected[0].ratio);
EXPECT_EQ(it->rising, _expected[0].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward, -46 to after last edge + -46.
job.from = -46.f;
job.to = nexttowardf(_expected[_size - 1].ratio + -46.f, 100.f);
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), _size);
TrackTriggeringJob::Iterator it = iterator;
for (size_t i = 0; it != job.end(); ++it, ++i) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i].ratio + -46.f);
EXPECT_EQ(it->rising, _expected[i].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward, -46 to before last edge + -46.
job.from = -46.f;
job.to = nexttowardf(_expected[_size - 1].ratio + -46.f, -100.f);
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), _size - 1);
TrackTriggeringJob::Iterator it = iterator;
for (size_t i = 0; it != job.end(); ++it, ++i) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i].ratio + -46.f);
EXPECT_EQ(it->rising, _expected[i].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward, -46 to last edge + -46.
const bool last_included = _expected[_size - 1].ratio == 1.f;
job.from = -46.f;
job.to = _expected[_size - 1].ratio + -46.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()),
last_included ? _size : _size - 1);
TrackTriggeringJob::Iterator it = iterator;
for (size_t i = 0; it != job.end(); ++it, ++i) {
EXPECT_FLOAT_EQ(it->ratio, _expected[i].ratio + -46.f);
EXPECT_EQ(it->rising, _expected[i].rising);
}
TestEdgesExpectationBackward(iterator, job);
}
{ // Forward [-21.3999996, -21.0000019]
job.from = -21.3999996f;
job.to = -21.0000019f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
size_t found = 0;
for (size_t i = 0; i < _size; ++i) {
if (_expected[i].ratio - 22.f >= job.from &&
_expected[i].ratio - 22.f < job.to) {
found++;
}
}
ASSERT_EQ(CountEdges(iterator, job.end()), found);
TestEdgesExpectationBackward(iterator, job);
}
{ // Randomized tests forward/backward coherency
const float kMaxRange = 10.f;
const size_t kMaxIterations = 1000;
for (size_t i = 0; i < kMaxIterations; ++i) {
job.from =
kMaxRange * (1.f - 2.f * static_cast<float>(rand()) /
static_cast<float>(RAND_MAX));
job.to = kMaxRange * (1.f - 2.f * static_cast<float>(rand()) /
static_cast<float>(RAND_MAX));
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
TestEdgesExpectationBackward(iterator, job);
}
}
{ // Randomized tests rising/falling coherency
const float kMaxRange = 2.f;
const size_t kMaxIterations = 1000;
float ratio = 0.f;
bool rising = false;
bool init = false;
for (size_t i = 0; i < kMaxIterations; ++i) {
// Finds new evaluation range
float new_time =
ratio +
kMaxRange * (1.f - 2.f * static_cast<float>(rand()) /
static_cast<float>(RAND_MAX));
switch (rand() % 20) {
case 0: {
// Set ratio to a keyframe ratio.
new_time = _expected[rand() % _size].ratio + floorf(new_time);
break;
}
case 1: {
// Set ratio to after a keyframe ratio.
new_time = nexttowardf(
_expected[rand() % _size].ratio + floorf(new_time), 1e15f);
break;
}
case 2: {
// Set ratio to before a keyframe ratio.
new_time = nexttowardf(
_expected[rand() % _size].ratio + floorf(new_time), -1e15f);
break;
}
default:
break;
}
job.from = ratio;
ratio = new_time;
job.to = ratio;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
// Successive edges should always be opposed, whichever direction the
// ratio is going.
for (const TrackTriggeringJob::Iterator end = job.end(); iterator != end;
++iterator) {
const TrackTriggeringJob::Edge& edge = *iterator;
if (!init) {
rising = edge.rising;
init = true;
} else {
// if (rising == edges[e].rising) {
// assert(false);
// break;
// }
ASSERT_TRUE(rising != edge.rising);
rising = edge.rising;
}
}
}
}
}
template <size_t _size>
inline void TestEdgesExpectation(
const ozz::animation::offline::RawFloatTrack& _raw_track, float _threshold,
const TrackTriggeringJob::Edge (&_expected)[_size]) {
static_assert(_size >= 2, "Minimum 2 edges.");
TestEdgesExpectation(_raw_track, _threshold, _expected, _size);
}
TEST(SquareStep, TrackEdgeTriggerJob) {
{ // Rising edge at t = 0.5
ozz::animation::offline::RawFloatTrack raw_track;
// Keyframe values oscillate in range [0,2].
const ozz::animation::offline::RawFloatTrack::Keyframe key0 = {
RawTrackInterpolation::kStep, 0.f, 0.f};
raw_track.keyframes.push_back(key0);
const ozz::animation::offline::RawFloatTrack::Keyframe key1 = {
RawTrackInterpolation::kStep, .5f, 2.f};
raw_track.keyframes.push_back(key1);
const ozz::animation::offline::RawFloatTrack::Keyframe key2 = {
RawTrackInterpolation::kStep, 1.f, 0.f};
raw_track.keyframes.push_back(key2);
const TrackTriggeringJob::Edge expected[] = {{.5f, true}, {1.f, false}};
TestEdgesExpectation(raw_track, 0.f, expected);
TestEdgesExpectation(raw_track, 1.f, expected);
}
{ // Rising edge at t = 0.6, no falling edge at end
ozz::animation::offline::RawFloatTrack raw_track;
// Keyframe values oscillate in range [0,2].
const ozz::animation::offline::RawFloatTrack::Keyframe key0 = {
RawTrackInterpolation::kStep, 0.f, 0.f};
raw_track.keyframes.push_back(key0);
const ozz::animation::offline::RawFloatTrack::Keyframe key1 = {
RawTrackInterpolation::kStep, .6f, 2.f};
raw_track.keyframes.push_back(key1);
const TrackTriggeringJob::Edge expected[] = {{0.f, false}, {.6f, true}};
TestEdgesExpectation(raw_track, 0.f, expected);
TestEdgesExpectation(raw_track, 1.f, expected);
}
{ // Falling edge at t = 0.5
ozz::animation::offline::RawFloatTrack raw_track;
// Keyframe values oscillate in range [0,2].
const ozz::animation::offline::RawFloatTrack::Keyframe key0 = {
RawTrackInterpolation::kStep, 0.f, 2.f};
raw_track.keyframes.push_back(key0);
const ozz::animation::offline::RawFloatTrack::Keyframe key1 = {
RawTrackInterpolation::kStep, .5f, 0.f};
raw_track.keyframes.push_back(key1);
const TrackTriggeringJob::Edge expected[] = {{0.f, true}, {.5f, false}};
TestEdgesExpectation(raw_track, 0.f, expected);
TestEdgesExpectation(raw_track, 1.f, expected);
}
{ // Negative values
ozz::animation::offline::RawFloatTrack raw_track;
// Keyframe values oscillate in range [-1,1].
const ozz::animation::offline::RawFloatTrack::Keyframe key0 = {
RawTrackInterpolation::kStep, 0.f, -1.f};
raw_track.keyframes.push_back(key0);
const ozz::animation::offline::RawFloatTrack::Keyframe key1 = {
RawTrackInterpolation::kStep, .5f, 1.f};
raw_track.keyframes.push_back(key1);
const ozz::animation::offline::RawFloatTrack::Keyframe key2 = {
RawTrackInterpolation::kStep, 1.f, -1.f};
raw_track.keyframes.push_back(key2);
const TrackTriggeringJob::Edge expected[] = {{.5f, true}, {1.f, false}};
TestEdgesExpectation(raw_track, 0.f, expected);
TestEdgesExpectation(raw_track, -1.f, expected);
}
{ // More edges
ozz::animation::offline::RawFloatTrack raw_track;
const ozz::animation::offline::RawFloatTrack::Keyframe key0 = {
RawTrackInterpolation::kStep, .0f, 0.f};
raw_track.keyframes.push_back(key0);
const ozz::animation::offline::RawFloatTrack::Keyframe key1 = {
RawTrackInterpolation::kStep, .2f, 2.f};
raw_track.keyframes.push_back(key1);
const ozz::animation::offline::RawFloatTrack::Keyframe key2 = {
RawTrackInterpolation::kStep, .3f, 0.f};
raw_track.keyframes.push_back(key2);
const ozz::animation::offline::RawFloatTrack::Keyframe key3 = {
RawTrackInterpolation::kStep, .4f, 1.f};
raw_track.keyframes.push_back(key3);
const ozz::animation::offline::RawFloatTrack::Keyframe key4 = {
RawTrackInterpolation::kStep, .5f, 0.f};
raw_track.keyframes.push_back(key4);
const TrackTriggeringJob::Edge expected0[] = {
{.2f, true}, {.3f, false}, {.4f, true}, {.5f, false}};
TestEdgesExpectation(raw_track, 0.f, expected0);
const TrackTriggeringJob::Edge expected1[] = {{.2f, true}, {.3f, false}};
TestEdgesExpectation(raw_track, 1.f, expected1);
}
}
TEST(Linear, TrackEdgeTriggerJob) {
{ // Higher point at t = 0.5
ozz::animation::offline::RawFloatTrack raw_track;
// Keyframe values oscillate in range [0,2].
const ozz::animation::offline::RawFloatTrack::Keyframe key0 = {
RawTrackInterpolation::kLinear, 0.f, 0.f};
raw_track.keyframes.push_back(key0);
const ozz::animation::offline::RawFloatTrack::Keyframe key1 = {
RawTrackInterpolation::kLinear, .5f, 2.f};
raw_track.keyframes.push_back(key1);
const ozz::animation::offline::RawFloatTrack::Keyframe key2 = {
RawTrackInterpolation::kLinear, 1.f, 0.f};
raw_track.keyframes.push_back(key2);
const TrackTriggeringJob::Edge expected0[] = {{.25f, true}, {.75f, false}};
TestEdgesExpectation(raw_track, 1.f, expected0);
const TrackTriggeringJob::Edge expected1[] = {{.125f, true},
{.875f, false}};
TestEdgesExpectation(raw_track, .5f, expected1);
const TrackTriggeringJob::Edge expected2[] = {{.375f, true},
{.625f, false}};
TestEdgesExpectation(raw_track, 1.5f, expected2);
}
{ // Higher point at t = 0.5
ozz::animation::offline::RawFloatTrack raw_track;
// Keyframe values oscillate in range [0,2].
const ozz::animation::offline::RawFloatTrack::Keyframe key0 = {
RawTrackInterpolation::kLinear, 0.f, 0.f};
raw_track.keyframes.push_back(key0);
const ozz::animation::offline::RawFloatTrack::Keyframe key1 = {
RawTrackInterpolation::kLinear, .5f, 2.f};
raw_track.keyframes.push_back(key1);
const TrackTriggeringJob::Edge expected[] = {{0.f, false}, {.25f, true}};
TestEdgesExpectation(raw_track, 1.f, expected);
}
{ // Negative values
ozz::animation::offline::RawFloatTrack raw_track;
// Keyframe values oscillate in range [-1,1].
const ozz::animation::offline::RawFloatTrack::Keyframe key0 = {
RawTrackInterpolation::kLinear, 0.f, -1.f};
raw_track.keyframes.push_back(key0);
const ozz::animation::offline::RawFloatTrack::Keyframe key1 = {
RawTrackInterpolation::kLinear, .5f, 1.f};
raw_track.keyframes.push_back(key1);
const TrackTriggeringJob::Edge expected[] = {{0.f, false}, {.25f, true}};
TestEdgesExpectation(raw_track, 0.f, expected);
}
}
TEST(Mixed, TrackEdgeTriggerJob) {
{ // Higher point at t = 0.5
ozz::animation::offline::RawFloatTrack raw_track;
// Keyframe values oscillate in range [0,2].
const ozz::animation::offline::RawFloatTrack::Keyframe key0 = {
RawTrackInterpolation::kStep, 0.f, 0.f};
raw_track.keyframes.push_back(key0);
const ozz::animation::offline::RawFloatTrack::Keyframe key1 = {
RawTrackInterpolation::kLinear, .5f, 2.f};
raw_track.keyframes.push_back(key1);
const ozz::animation::offline::RawFloatTrack::Keyframe key2 = {
RawTrackInterpolation::kLinear, 1.f, 0.f};
raw_track.keyframes.push_back(key2);
const TrackTriggeringJob::Edge expected0[] = {{.5f, true}, {.75f, false}};
TestEdgesExpectation(raw_track, 1.f, expected0);
const TrackTriggeringJob::Edge expected1[] = {{.5f, true}, {.875f, false}};
TestEdgesExpectation(raw_track, .5f, expected1);
const TrackTriggeringJob::Edge expected2[] = {{.5f, true}, {.625f, false}};
TestEdgesExpectation(raw_track, 1.5f, expected2);
}
{ // Higher point at t = 0.5
ozz::animation::offline::RawFloatTrack raw_track;
// Keyframe values oscillate in range [0,2].
const ozz::animation::offline::RawFloatTrack::Keyframe key0 = {
RawTrackInterpolation::kLinear, 0.f, 0.f};
raw_track.keyframes.push_back(key0);
const ozz::animation::offline::RawFloatTrack::Keyframe key1 = {
RawTrackInterpolation::kStep, .5f, 2.f};
raw_track.keyframes.push_back(key1);
const ozz::animation::offline::RawFloatTrack::Keyframe key2 = {
RawTrackInterpolation::kLinear, 1.f, 0.f};
raw_track.keyframes.push_back(key2);
const TrackTriggeringJob::Edge expected0[] = {{.25f, true}, {1.f, false}};
TestEdgesExpectation(raw_track, 1.f, expected0);
const TrackTriggeringJob::Edge expected1[] = {{.125f, true}, {1.f, false}};
TestEdgesExpectation(raw_track, .5f, expected1);
const TrackTriggeringJob::Edge expected2[] = {{.375f, true}, {1.f, false}};
TestEdgesExpectation(raw_track, 1.5f, expected2);
}
}
TEST(StepThreshold, TrackEdgeTriggerJob) {
TrackBuilder builder;
// Rising edge at t = 0.5
ozz::animation::offline::RawFloatTrack raw_track;
// Keyframe values oscillate in range [-1,1].
const ozz::animation::offline::RawFloatTrack::Keyframe key0 = {
RawTrackInterpolation::kStep, 0.f, -1.f};
raw_track.keyframes.push_back(key0);
const ozz::animation::offline::RawFloatTrack::Keyframe key1 = {
RawTrackInterpolation::kStep, .5f, 1.f};
raw_track.keyframes.push_back(key1);
const ozz::animation::offline::RawFloatTrack::Keyframe key2 = {
RawTrackInterpolation::kStep, 1.f, -1.f};
raw_track.keyframes.push_back(key2);
// Builds track
ozz::unique_ptr<FloatTrack> track(builder(raw_track));
ASSERT_TRUE(track);
TrackTriggeringJob job;
job.track = track.get();
job.from = 0.f;
job.to = 1.f;
{ // In range
job.threshold = .5f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), 2u);
EXPECT_FLOAT_EQ(iterator->ratio, .5f);
EXPECT_EQ(iterator->rising, true);
++iterator;
EXPECT_FLOAT_EQ(iterator->ratio, 1.f);
EXPECT_EQ(iterator->rising, false);
}
{ // Bottom of range is included
job.threshold = -1.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), 2u);
EXPECT_FLOAT_EQ(iterator->ratio, .5f);
EXPECT_EQ(iterator->rising, true);
++iterator;
EXPECT_FLOAT_EQ(iterator->ratio, 1.f);
EXPECT_EQ(iterator->rising, false);
}
{ // Top range is excluded
job.threshold = 1.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), 0u);
}
{ // In range
job.threshold = 0.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), 2u);
EXPECT_FLOAT_EQ(iterator->ratio, .5f);
EXPECT_EQ(iterator->rising, true);
++iterator;
EXPECT_FLOAT_EQ(iterator->ratio, 1.f);
EXPECT_EQ(iterator->rising, false);
}
{ // Out of range
job.from = 0.f;
job.to = 1.f;
job.threshold = 2.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), 0u);
}
}
TEST(StepThresholdBool, TrackEdgeTriggerJob) {
TrackBuilder builder;
// Rising edge at t = 0.5
ozz::animation::offline::RawFloatTrack raw_track;
// Keyframe values oscillate in range [0,1].
const ozz::animation::offline::RawFloatTrack::Keyframe key0 = {
RawTrackInterpolation::kStep, 0.f, 0.f};
raw_track.keyframes.push_back(key0);
const ozz::animation::offline::RawFloatTrack::Keyframe key1 = {
RawTrackInterpolation::kStep, .5f, 1.f};
raw_track.keyframes.push_back(key1);
const ozz::animation::offline::RawFloatTrack::Keyframe key2 = {
RawTrackInterpolation::kStep, 1.f, 0.f};
raw_track.keyframes.push_back(key2);
// Builds track
ozz::unique_ptr<FloatTrack> track(builder(raw_track));
ASSERT_TRUE(track);
TrackTriggeringJob job;
job.track = track.get();
job.from = 0.f;
job.to = 1.f;
{ // In range
job.threshold = .5f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), 2u);
EXPECT_FLOAT_EQ(iterator->ratio, .5f);
EXPECT_EQ(iterator->rising, true);
++iterator;
EXPECT_FLOAT_EQ(iterator->ratio, 1.f);
EXPECT_EQ(iterator->rising, false);
}
{ // Top range is excluded
job.threshold = 1.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), 0u);
}
{ // Bottom range is included
job.threshold = 0.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), 2u);
EXPECT_FLOAT_EQ(iterator->ratio, .5f);
EXPECT_EQ(iterator->rising, true);
++iterator;
EXPECT_FLOAT_EQ(iterator->ratio, 1.f);
EXPECT_EQ(iterator->rising, false);
}
}
TEST(LinearThreshold, TrackEdgeTriggerJob) {
TrackBuilder builder;
// Rising edge at t = 0.5
ozz::animation::offline::RawFloatTrack raw_track;
// Keyframe values oscillate in range [-1,1].
const ozz::animation::offline::RawFloatTrack::Keyframe key0 = {
RawTrackInterpolation::kLinear, 0.f, -1.f};
raw_track.keyframes.push_back(key0);
const ozz::animation::offline::RawFloatTrack::Keyframe key1 = {
RawTrackInterpolation::kLinear, .5f, 1.f};
raw_track.keyframes.push_back(key1);
const ozz::animation::offline::RawFloatTrack::Keyframe key2 = {
RawTrackInterpolation::kLinear, 1.f, -1.f};
raw_track.keyframes.push_back(key2);
// Builds track
ozz::unique_ptr<FloatTrack> track(builder(raw_track));
ASSERT_TRUE(track);
TrackTriggeringJob job;
job.track = track.get();
job.from = 0.f;
job.to = 1.f;
{ // In range
job.threshold = .5f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), 2u);
EXPECT_FLOAT_EQ(iterator->ratio, .375f);
EXPECT_EQ(iterator->rising, true);
++iterator;
EXPECT_FLOAT_EQ(iterator->ratio, .625f);
EXPECT_EQ(iterator->rising, false);
}
{ // Top range is excluded
job.threshold = 1.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), 0u);
}
{ // In range
job.threshold = 0.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), 2u);
EXPECT_FLOAT_EQ(iterator->ratio, .25f);
EXPECT_EQ(iterator->rising, true);
++iterator;
EXPECT_FLOAT_EQ(iterator->ratio, .75f);
EXPECT_EQ(iterator->rising, false);
}
{ // Bottom of range is included
job.threshold = -1.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), 2u);
EXPECT_FLOAT_EQ(iterator->ratio, 0.f);
EXPECT_EQ(iterator->rising, true);
++iterator;
EXPECT_FLOAT_EQ(iterator->ratio, 1.f);
EXPECT_EQ(iterator->rising, false);
}
{ // Out of range
job.from = 0.f;
job.to = 1.f;
job.threshold = 2.f;
TrackTriggeringJob::Iterator iterator;
job.iterator = &iterator;
ASSERT_TRUE(job.Run());
ASSERT_EQ(CountEdges(iterator, job.end()), 0u);
}
}
Reference in New Issue View Git Blame Copy Permalink