Method derive

Engine/Interpolation.cpp:464–510

derive at currentTime. The derivative is with respect to currentTime

/// derive at currentTime. The derivative is with respect to currentTime
double
Interpolation::derive(double tcur,
                      const double vcur,              //start control point
                      const double vcurDerivRight,      //being the derivative dv/dt at tcur
                      const double vnextDerivLeft,      //being the derivative dv/dt at tnext
                      double tnext,
                      const double vnext,                    //end control point
                      double currentTime,
                      KeyframeTypeEnum interp,
                      KeyframeTypeEnum interpNext)
{
    double P0 = vcur;
    double P3 = vnext;
    // Hermite coefficients P0' and P3' are the derivatives with respect to x \in [0,1]
    double P0pr = vcurDerivRight * (tnext - tcur); // normalize for x \in [0,1]
    double P3pl = vnextDerivLeft * (tnext - tcur); // normalize for x \in [0,1]

    // if the following is true, this makes the special case for eKeyframeTypeConstant at tnext useless, and we can always use a cubic - the strict "currentTime < tnext" is the key
    assert( ( (interp == eKeyframeTypeNone) || (tcur <= currentTime) ) && ( (currentTime < tnext) || (interpNext == eKeyframeTypeNone) ) );
    // after the last / before the first keyframe, derivatives are wrt currentTime (i.e. non-normalized)
    if (interp == eKeyframeTypeNone) {
        // virtual previous frame at t-1
        P0 = P3 - P3pl;
        P0pr = P3pl;
        tcur = tnext - 1.;
    } else if (interp == eKeyframeTypeConstant) {
        P0pr = 0.;
        P3pl = 0.;
        P3 = P0;
    }
    if (interpNext == eKeyframeTypeNone) {
        // virtual next frame at t+1
        P3pl = P0pr;
        P3 = P0 + P0pr;
        tnext = tcur + 1;
    }
    double c0, c1, c2, c3;
    hermiteToCubicCoeffs(P0, P0pr, P3pl, P3, &c0, &c1, &c2, &c3);

    const double t = (currentTime - tcur) / (tnext - tcur);
    double ret = cubicDerive(c0, c1, c2, c3, t);

    // cubicDerive: divide the result by (tnext-tcur)

    // cubicIntegrate: multiply the result by (tnext-tcur)
    return ret / (tnext - tcur);
}

/// interpolate and derive at currentTime. The derivative is with respect to currentTime
double