KeyFrame Curve::setKeyFrameDerivatives(double left, double right,int index,int* newIndex)
{
bool evaluateAnimation = false;
KeyFrame ret;
{
QWriteLocker l(&_imp->_lock);
KeyFrameSet::iterator it = atIndex(index);
assert(it != _imp->keyFrames.end());
if (left != it->getLeftDerivative() || right != it->getRightDerivative()) {
KeyFrame newKey(*it);
newKey.setLeftDerivative(left);
newKey.setRightDerivative(right);
it = addKeyFrameNoUpdate(newKey).first;
it = evaluateCurveChanged(DERIVATIVES_CHANGED,it);
evaluateAnimation = true;
}
if (newIndex) {
*newIndex = std::distance(_imp->keyFrames.begin(),it);
}
ret = *it;
}
if (evaluateAnimation && _imp->owner) {
_imp->owner->evaluateAnimationChange();
}
return ret;
}
KeyFrame Curve::setKeyFrameValueAndTime(double time,double value,int index,int* newIndex)
{
bool evaluateAnimation = false;
KeyFrame ret;
{
QWriteLocker l(&_imp->_lock);
KeyFrameSet::iterator it = atIndex(index);
if (it == _imp->keyFrames.end()) {
QString err = QString("No such keyframe at index %1").arg(index);
throw std::invalid_argument(err.toStdString());
}
bool setTime = (time != it->getTime());
bool setValue = (value != it->getValue());
if (setTime || setValue) {
it = setKeyFrameValueAndTimeNoUpdate(value,time, it);
it = evaluateCurveChanged(KEYFRAME_CHANGED,it);
evaluateAnimation = true;
}
if (newIndex) {
*newIndex = std::distance(_imp->keyFrames.begin(),it);
}
ret = *it;
}
if (evaluateAnimation && _imp->owner) {
_imp->owner->evaluateAnimationChange();
}
return ret;
}
KeyFrame Curve::setKeyFrameInterpolation(Natron::KeyframeType interp,int index,int* newIndex)
{
bool evaluateAnimation = false;
KeyFrame ret;
{
QWriteLocker l(&_imp->_lock);
KeyFrameSet::iterator it = atIndex(index);
assert(it != _imp->keyFrames.end());
///if the curve is a string_curve or bool_curve the interpolation is bound to be constant.
if ((_imp->type == CurvePrivate::STRING_CURVE || _imp->type == CurvePrivate::BOOL_CURVE)
&& interp != Natron::KEYFRAME_CONSTANT) {
return *it;
}
if (interp != it->getInterpolation()) {
KeyFrame newKey(*it);
newKey.setInterpolation(interp);
it = addKeyFrameNoUpdate(newKey).first;
evaluateCurveChanged(KEYFRAME_CHANGED,it);
evaluateAnimation = true;
}
if (newIndex) {
*newIndex = std::distance(_imp->keyFrames.begin(),it);
}
ret = *it;
}
if (evaluateAnimation && _imp->owner) {
_imp->owner->evaluateAnimationChange();
}
return ret;
}
KeyFrameSet::iterator Curve::setKeyframeInterpolation_internal(KeyFrameSet::iterator it,Natron::KeyframeType interp)
{
///private should not be locked
assert(it != _imp->keyFrames.end());
KeyFrame newKey(*it);
newKey.setInterpolation(interp);
it = addKeyFrameNoUpdate(newKey).first;
it = evaluateCurveChanged(KEYFRAME_CHANGED,it);
return it;
}
bool Curve::addKeyFrame(KeyFrame key)
{
QWriteLocker l(&_imp->_lock);
if (_imp->type == CurvePrivate::BOOL_CURVE || _imp->type == CurvePrivate::STRING_CURVE) {
key.setInterpolation(Natron::KEYFRAME_CONSTANT);
}
std::pair<KeyFrameSet::iterator,bool> it = addKeyFrameNoUpdate(key);
evaluateCurveChanged(KEYFRAME_CHANGED,it.first);
l.unlock();
///This call must not be locked!
if (_imp->owner) {
_imp->owner->evaluateAnimationChange();
}
return it.second;
}
KeyFrameSet::iterator Curve::refreshDerivatives(Curve::CurveChangedReason reason, KeyFrameSet::iterator key)
{
// PRIVATE - should not lock
double tcur = key->getTime();
double vcur = key->getValue();
double tprev, vprev, tnext, vnext, vprevDerivRight, vnextDerivLeft;
Natron::KeyframeType prevType, nextType;
if (key == _imp->keyFrames.begin()) {
tprev = tcur;
vprev = vcur;
vprevDerivRight = 0.;
prevType = Natron::KEYFRAME_NONE;
} else {
KeyFrameSet::const_iterator prev = key;
--prev;
tprev = prev->getTime();
vprev = prev->getValue();
vprevDerivRight = prev->getRightDerivative();
prevType = prev->getInterpolation();
//if prev is the first keyframe, and not edited by the user then interpolate linearly
if (prev == _imp->keyFrames.begin() && prevType != Natron::KEYFRAME_FREE &&
prevType != Natron::KEYFRAME_BROKEN) {
prevType = Natron::KEYFRAME_LINEAR;
}
}
KeyFrameSet::const_iterator next = key;
++next;
if (next == _imp->keyFrames.end()) {
tnext = tcur;
vnext = vcur;
vnextDerivLeft = 0.;
nextType = Natron::KEYFRAME_NONE;
} else {
tnext = next->getTime();
vnext = next->getValue();
vnextDerivLeft = next->getLeftDerivative();
nextType = next->getInterpolation();
KeyFrameSet::const_iterator nextnext = next;
++nextnext;
//if next is thelast keyframe, and not edited by the user then interpolate linearly
if (nextnext == _imp->keyFrames.end() && nextType != Natron::KEYFRAME_FREE &&
nextType != Natron::KEYFRAME_BROKEN) {
nextType = Natron::KEYFRAME_LINEAR;
}
}
double vcurDerivLeft,vcurDerivRight;
assert(key->getInterpolation() != Natron::KEYFRAME_NONE &&
key->getInterpolation() != Natron::KEYFRAME_BROKEN &&
key->getInterpolation() != Natron::KEYFRAME_FREE);
Natron::autoComputeDerivatives(prevType,
key->getInterpolation(),
nextType,
tprev, vprev,
tcur, vcur,
tnext, vnext,
vprevDerivRight,
vnextDerivLeft,
&vcurDerivLeft, &vcurDerivRight);
KeyFrame newKey(*key);
newKey.setLeftDerivative(vcurDerivLeft);
newKey.setRightDerivative(vcurDerivRight);
std::pair<KeyFrameSet::iterator,bool> newKeyIt = _imp->keyFrames.insert(newKey);
// keyframe at this time exists, erase and insert again
if (!newKeyIt.second) {
_imp->keyFrames.erase(newKeyIt.first);
newKeyIt = _imp->keyFrames.insert(newKey);
assert(newKeyIt.second);
}
key = newKeyIt.first;
if (reason != DERIVATIVES_CHANGED) {
key = evaluateCurveChanged(DERIVATIVES_CHANGED,key);
}
return key;
}
