Bind textures in the modern way when shaders are used

[libs/gl.git] / source / animation.cpp

diff --git a/source/animation.cpp b/source/animation.cpp
index 744262d84781ae40e0b2c42b604b1b2badb516cf..c7e23b8e3b26f8bda1332cafcf3efb3d3680845b 100644 (file)
--- a/source/animation.cpp
+++ b/source/animation.cpp
@@ -72,20 +72,6 @@ void Animation::add_keyframe(const Time::TimeDelta &t, const RefPtr<const KeyFra
        prepare_keyframe(tkf);
 }
 
-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);
-}
-
-void Animation::set_looping(bool l)
-{
-       looping = l;
-}
-
 void Animation::prepare_keyframe(TimedKeyFrame &tkf)
 {
        const KeyFrame::UniformMap &kf_uniforms = tkf.keyframe->get_uniforms();
@@ -107,6 +93,20 @@ void Animation::prepare_keyframe(TimedKeyFrame &tkf)
        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);
+}
+
+void Animation::set_looping(bool l)
+{
+       looping = l;
+}
+
 
 Animation::AxisInterpolation::AxisInterpolation():
        slope(0),
@@ -116,18 +116,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;
@@ -333,7 +334,7 @@ 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);
        const Vector3 &base = animation->armature->get_link(link).get_base();
@@ -400,6 +401,11 @@ void Animation::Loader::event4f(const string &n, float v0, float v1, float v2, f
        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<KeyFrame>(n));
@@ -416,10 +422,5 @@ void Animation::Loader::keyframe_inline()
        obj.add_keyframe(current_time, kf);
 }
 
-void Animation::Loader::interval(float t)
-{
-       current_time += t*Time::sec;
-}
-
 } // namespace GL
 } // namespace Msp