X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fanimation.cpp;h=e82a92a87ce4811b3e465b345e6f5477d1c61f27;hp=ccd37bca5e0daec3d782cfd8504827efca53b922;hb=9319f1c8ed99866966f20fbab952da673af2257e;hpb=4a1e2b6a68095e6bb7c212be57abb5a1509739b9 diff --git a/source/animation.cpp b/source/animation.cpp index ccd37bca..e82a92a8 100644 --- a/source/animation.cpp +++ b/source/animation.cpp @@ -3,6 +3,7 @@ #include #include #include "animation.h" +#include "animationeventobserver.h" #include "armature.h" #include "error.h" #include "pose.h" @@ -42,40 +43,50 @@ const string &Animation::get_uniform_name(unsigned i) const } void Animation::add_keyframe(const Time::TimeDelta &t, const KeyFrame &kf) +{ + add_keyframe(t, kf, 1.0f, 1.0f); +} + +void Animation::add_keyframe(const Time::TimeDelta &t, const KeyFrame &kf, float slope) +{ + add_keyframe(t, kf, slope, slope); +} + +void Animation::add_keyframe(const Time::TimeDelta &t, const KeyFrame &kf, float ss, float es) { RefPtr kfr(&kf); kfr.keep(); - add_keyframe(t, kfr); + add_keyframe(t, kfr, ss, es); } -void Animation::add_keyframe(const Time::TimeDelta &t, const RefPtr &kf) +void Animation::add_keyframe(const Time::TimeDelta &t, const RefPtr &kf, float ss, float es) { + if(keyframes.empty() && t!=Time::zero) + throw invalid_argument("Animation::add_keyframe"); if(!keyframes.empty() && t=keyframes.capacity()); - keyframes.push_back(TimedKeyFrame(*this)); + keyframes.push_back(TimedKeyFrame()); TimedKeyFrame &tkf = keyframes.back(); tkf.time = t; + tkf.start_slope = ss; + tkf.end_slope = es; tkf.keyframe = kf; if(realloc) { for(unsigned i=1; i1) + if(keyframes.size()>1 && t>(&tkf-1)->time) tkf.prev = &tkf-1; prepare_keyframe(tkf); } -void Animation::set_looping(bool l) -{ - looping = l; -} - void Animation::prepare_keyframe(TimedKeyFrame &tkf) { const KeyFrame::UniformMap &kf_uniforms = tkf.keyframe->get_uniforms(); @@ -94,7 +105,29 @@ void Animation::prepare_keyframe(TimedKeyFrame &tkf) uniforms.push_back(UniformInfo(i->first, i->second.size)); } - tkf.prepare(); + tkf.prepare(*this); +} + +void Animation::add_event(const Time::TimeDelta &t, const string &n, const Variant &v) +{ + Event event; + event.time = t; + event.name = n; + event.value = v; + events.push_back(event); +} + +const Time::TimeDelta &Animation::get_duration() const +{ + if(keyframes.empty()) + return Time::zero; + + return keyframes.back().time; +} + +void Animation::set_looping(bool l) +{ + looping = l; } @@ -106,18 +139,19 @@ Animation::AxisInterpolation::AxisInterpolation(): Animation::AxisInterpolation::AxisInterpolation(const float *axis1, const float *axis2) { // Compute a normalized vector halfway between the two endpoints - float half[3]; float a1_len = 0; float h_len = 0; + float cos_half = 0; for(unsigned i=0; i<3; ++i) { - half[i] = (axis1[i]+axis2[i])/2; + float half_i = (axis1[i]+axis2[i])/2; + cos_half += axis1[i]*half_i; a1_len += axis1[i]*axis1[i]; - h_len += half[i]*half[i]; + h_len += half_i*half_i; } // Compute correction factors for smooth interpolation - float cos_half = (axis1[0]*half[0]+axis1[1]*half[1]+axis1[2]*half[2])/sqrt(a1_len*h_len); + cos_half = min(max(cos_half/sqrt(a1_len*h_len), -1.0f), 1.0f); float angle = acos(cos_half); slope = (angle ? angle/tan(angle) : 1); scale = cos_half; @@ -185,12 +219,13 @@ Matrix Animation::MatrixInterpolation::get(float t) const } -Animation::TimedKeyFrame::TimedKeyFrame(const Animation &a): - animation(a), - prev(0) +Animation::TimedKeyFrame::TimedKeyFrame(): + prev(0), + start_slope(1), + end_slope(1) { } -void Animation::TimedKeyFrame::prepare() +void Animation::TimedKeyFrame::prepare(const Animation &animation) { const KeyFrame::UniformMap &kf_uniforms = keyframe->get_uniforms(); for(KeyFrame::UniformMap::const_iterator i=kf_uniforms.begin(); i!=kf_uniforms.end(); ++i) @@ -235,8 +270,13 @@ Animation::UniformInfo::UniformInfo(const string &n, unsigned s): Animation::Iterator::Iterator(const Animation &a): animation(&a), iter(animation->keyframes.begin()), + event_iter(animation->events.begin()), + x(0), end(false) -{ } +{ + if(iter==animation->keyframes.end()) + throw invalid_argument("Animation::Iterator::Iterator"); +} Animation::Iterator &Animation::Iterator::operator+=(const Time::TimeDelta &t) { @@ -261,15 +301,36 @@ Animation::Iterator &Animation::Iterator::operator+=(const Time::TimeDelta &t) iter = next; } + x = time_since_keyframe/iter->delta_t; + x += (iter->start_slope-1)*((x-2)*x+1)*x + (1-iter->end_slope)*(1-x)*x*x; + return *this; } +void Animation::Iterator::dispatch_events(AnimationEventObserver &observer) +{ + vector::const_iterator events_end = animation->events.end(); + if(end) + { + for(; event_iter!=events_end; ++event_iter) + observer.animation_event(0, event_iter->name, event_iter->value); + } + else if(event_iter!=events_end) + { + Time::TimeDelta t = time_since_keyframe; + if(iter->prev) + t += iter->prev->time; + for(; (event_iter!=events_end && event_iter->time<=t); ++event_iter) + observer.animation_event(0, event_iter->name, event_iter->value); + } +} + Matrix Animation::Iterator::get_matrix() const { if(!iter->prev) return iter->keyframe->get_matrix(); - return iter->matrix.get(time_since_keyframe/iter->delta_t); + return iter->matrix.get(x); } KeyFrame::AnimatedUniform Animation::Iterator::get_uniform(unsigned i) const @@ -283,10 +344,9 @@ KeyFrame::AnimatedUniform Animation::Iterator::get_uniform(unsigned i) const } unsigned size = animation->uniforms[i].size; - float t = time_since_keyframe/iter->delta_t; KeyFrame::AnimatedUniform result(size, 0.0f); for(unsigned j=0; jprev->uniforms[i].values[j]*(1-t)+iter->uniforms[i].values[j]*t; + result.values[j] = iter->prev->uniforms[i].values[j]*(1-x)+iter->uniforms[i].values[j]*x; return result; } @@ -305,9 +365,9 @@ Matrix Animation::Iterator::get_pose_matrix(unsigned link) const return Matrix(); } - // We must redo the base point correction since interpolation throws if off + // We must redo the base point correction since interpolation throws it off // XXX This should probably be done on local matrices - Matrix result = iter->pose_matrices[link].get(time_since_keyframe/iter->delta_t); + Matrix result = iter->pose_matrices[link].get(x); const Vector3 &base = animation->armature->get_link(link).get_base(); Vector3 new_base = result*base; result = Matrix::translation(base-new_base)*result; @@ -329,16 +389,62 @@ Animation::Loader::Loader(Animation &a, Collection &c): void Animation::Loader::init() { + start_slope = 1; + end_slope = 1; add("armature", &Animation::armature); + add("event", &Loader::event); + add("event", &Loader::event1i); + add("event", &Loader::event1f); + add("event", &Loader::event2f); + add("event", &Loader::event3f); + add("event", &Loader::event4f); add("interval", &Loader::interval); add("keyframe", &Loader::keyframe); add("keyframe", &Loader::keyframe_inline); add("looping", &Animation::looping); + add("slopes", &Loader::slopes); +} + +void Animation::Loader::event(const string &n) +{ + obj.add_event(current_time, n); +} + +void Animation::Loader::event1i(const string &n, int v) +{ + obj.add_event(current_time, n, v); +} + +void Animation::Loader::event1f(const string &n, float v) +{ + obj.add_event(current_time, n, v); +} + +void Animation::Loader::event2f(const string &n, float v0, float v1) +{ + obj.add_event(current_time, n, LinAl::Vector(v0, v1)); +} + +void Animation::Loader::event3f(const string &n, float v0, float v1, float v2) +{ + obj.add_event(current_time, n, Vector3(v0, v1, v2)); +} + +void Animation::Loader::event4f(const string &n, float v0, float v1, float v2, float v3) +{ + obj.add_event(current_time, n, Vector4(v0, v1, v2, v3)); +} + +void Animation::Loader::interval(float t) +{ + current_time += t*Time::sec; } void Animation::Loader::keyframe(const string &n) { - obj.add_keyframe(current_time, get_collection().get(n)); + obj.add_keyframe(current_time, get_collection().get(n), start_slope, end_slope); + start_slope = end_slope; + end_slope = 1; } void Animation::Loader::keyframe_inline() @@ -349,12 +455,15 @@ void Animation::Loader::keyframe_inline() else load_sub(*kf); - obj.add_keyframe(current_time, kf); + obj.add_keyframe(current_time, kf, start_slope, end_slope); + start_slope = end_slope; + end_slope = 1; } -void Animation::Loader::interval(float t) +void Animation::Loader::slopes(float s, float e) { - current_time += t*Time::sec; + start_slope = s; + end_slope = e; } } // namespace GL