lerp.h File Reference

#include <assert.h>
#include "vec.h"
#include "quaternion.h"

Go to the source code of this file.

Functions
Transformation	linear_interpolate_uncapped (const Transformation &a, const Transformation &b, double blend)
Transformation	linear_interpolate (const Transformation &a, const Transformation &b, double blend)

Function Documentation

Transformation linear_interpolate ( const Transformation &  a, const Transformation &  b, double  blend  )

inline

Definition at line 12 of file lerp.h.

References linear_interpolate_uncapped().

Referenced by GameStarSystem::Draw(), and GameUnit< UnitType >::Draw().

{
    return linear_interpolate_uncapped( a, b, ( (blend > 1.0) ? 1.0 : blend ) );
}

Transformation linear_interpolate_uncapped	(	const Transformation &	a,
		const Transformation &	b,
		double	blend
	)

Definition at line 3 of file lerp.cpp.

References a, UniverseUtil::acos(), b, DotProduct(), f, float, Quaternion::Normalize(), Transformation::orientation, Transformation::position, Quaternion::s, UniverseUtil::sin(), and Quaternion::v.

Referenced by LinearPrediction::Interpolate(), and linear_interpolate().

{
    Quaternion result;
    if (0 /*A.orientation==B.orientation*/) {
        result = A.orientation;
    } else {
        const Quaternion &a = A.orientation;
        const Quaternion &b = B.orientation;
        double     f = blend, f0, f1, sadj=1;
        double     cos_omega = DotProduct( a.v, b.v )+a.s*b.s;
        //Adjust signs if necessary.
        if (cos_omega < 0) {
            cos_omega = -cos_omega;
            sadj = -1;
        }
        if (cos_omega < 0.99) {
            //Do the spherical interp.
            double omega     = acos( cos_omega );
            double isin_omega = 1.0 / sin( omega );
            f0 = sin( (1-f)*omega ) * isin_omega;
            f1 = sin( f*omega ) * isin_omega;
        } else {
            //Quaternions are close; just do straight lerp and avoid division by near-zero.
            f0 = 1-f;
            f1 = f;
        }
        result.s = a.s*float(f0)+b.s*float(f1*sadj);
        result.v = a.v*float(f0)+b.v*float(f1*sadj);
        result.Normalize();
    }
    return Transformation( result, A.position+(B.position-A.position)*blend );
}