// TnzCore includes
#include "tstream.h"
#include "tconvert.h"
#include "tsystem.h"
#include "tcubicbezier.h"
#include "tundo.h"
// TnzBase includes
#include "tdoublekeyframe.h"
#include "tdoubleparamfile.h"
#include "texpression.h"
#include "tgrammar.h"
#include "tparser.h"
#include "tunit.h"
// STD includes
#include <set>
#include "tdoubleparam.h"
using namespace std;
//===============================
class TActualDoubleKeyframe : public TDoubleKeyframe {
public:
mutable TExpression m_expression;
mutable TDoubleParamFileData m_fileData;
TActualDoubleKeyframe(double frame = 0, double value = 0)
: TDoubleKeyframe(frame, value), m_unit(0) {}
explicit TActualDoubleKeyframe(const TDoubleKeyframe &src) : m_unit(0) {
TDoubleKeyframe::operator=(src);
if (m_type == Expression || m_type == SimilarShape)
m_expression.setText(m_expressionText);
else if (m_type == File)
m_fileData.setParams(m_fileParams);
}
TActualDoubleKeyframe &operator=(const TDoubleKeyframe &src) {
TDoubleKeyframe::operator=(src);
m_unit = 0;
if (m_type == Expression || m_type == SimilarShape) {
m_expression.setText(m_expressionText);
} else if (m_type == File) {
m_fileData.setParams(m_fileParams);
}
return *this;
}
const TUnit *updateUnit(const TMeasure *measure) {
if (!measure) {
m_unit = 0;
m_unitName = "";
} else {
if (m_unitName != "")
m_unit = measure->getUnit(::to_wstring(m_unitName));
else
m_unit = 0;
if (!m_unit) {
m_unit = measure->getCurrentUnit();
if (m_unit) {
QString app = QString::fromStdWString(m_unit->getDefaultExtension());
m_unitName = app.toStdString();
}
}
}
assert(measure || m_unit == 0 && m_unitName == "");
assert((m_unit == 0) == (m_unitName == ""));
QString app = QString::fromStdString(m_unitName);
assert(m_unit == 0 || m_unit->isExtension(app.toStdWString()));
return m_unit;
}
double convertFrom(TMeasure *measure, double value) const {
if (!m_unit) const_cast<TActualDoubleKeyframe *>(this)->updateUnit(measure);
if (m_unit) value = m_unit->convertFrom(value);
return value;
}
private:
mutable const TUnit *m_unit;
};
typedef vector<TActualDoubleKeyframe> DoubleKeyframeVector;
//===================================================================
inline double getConstantValue(const TActualDoubleKeyframe &k0,
const TActualDoubleKeyframe &k1, double f) {
return (f == k1.m_frame) ? k1.m_value : k0.m_value;
}
//---------------------------------------------------------
inline double getLinearValue(const TActualDoubleKeyframe &k0,
const TActualDoubleKeyframe &k1, double f) {
return k0.m_value +
(f - k0.m_frame) * (k1.m_value - k0.m_value) /
(k1.m_frame - k0.m_frame);
}
//---------------------------------------------------------
void truncateSpeeds(double aFrame, double bFrame, TPointD &aSpeedTrunc,
TPointD &bSpeedTrunc) {
double deltaX = bFrame - aFrame;
if (aSpeedTrunc.x < 0) aSpeedTrunc.x = 0;
if (bSpeedTrunc.x > 0) bSpeedTrunc.x = 0;
if (aFrame + aSpeedTrunc.x > bFrame) {
if (aSpeedTrunc.x != 0) {
aSpeedTrunc = aSpeedTrunc * (deltaX / aSpeedTrunc.x);
}
}
if (bFrame + bSpeedTrunc.x < aFrame) {
if (bSpeedTrunc.x != 0) {
bSpeedTrunc = -bSpeedTrunc * (deltaX / bSpeedTrunc.x);
}
}
}
//---------------------------------------------------------
inline double getSpeedInOutValue(const TActualDoubleKeyframe &k0,
const TActualDoubleKeyframe &k1,
const TPointD &speed0, const TPointD &speed1,
double frame) {
double aFrame = k0.m_frame;
double bFrame = k1.m_frame;
double aValue = k0.m_value;
double bValue = k1.m_value;
if (frame <= aFrame)
return aValue;
else if (frame >= bFrame)
return bValue;
TPointD aSpeedTrunc = speed0;
TPointD bSpeedTrunc = speed1;
truncateSpeeds(aFrame, bFrame, aSpeedTrunc, bSpeedTrunc);
return getCubicBezierY(frame, TPointD(aFrame, aValue), aSpeedTrunc,
bSpeedTrunc, TPointD(bFrame, bValue));
}
//---------------------------------------------------------
DV_EXPORT_API void splitSpeedInOutSegment(TDoubleKeyframe &k,
TDoubleKeyframe &k0,
TDoubleKeyframe &k1) {
if (k.m_frame <= k0.m_frame) {
k = k0;
return;
} else if (k.m_frame >= k1.m_frame) {
k = k1;
return;
}
TPointD aSpeed = k0.m_speedOut;
TPointD bSpeed = k1.m_speedIn;
truncateSpeeds(k0.m_frame, k1.m_frame, aSpeed, bSpeed);
TPointD p0(k0.m_frame, k0.m_value);
TPointD p3(k1.m_frame, k1.m_value);
TPointD p1 = p0 + aSpeed;
TPointD p2 = p3 + bSpeed;
double t = invCubicBezierX(k.m_frame, p0, aSpeed, bSpeed, p3);
t = tcrop(t, 0.0, 1.0);
TPointD p01 = (1 - t) * p0 + t * p1;
TPointD p12 = (1 - t) * p1 + t * p2;
TPointD p23 = (1 - t) * p2 + t * p3;
TPointD p012 = (1 - t) * p01 + t * p12;
TPointD p123 = (1 - t) * p12 + t * p23;
TPointD p = (1 - t) * p012 + t * p123;
assert(fabs(p.x - k.m_frame) < 0.1e-3);
k.m_value = p.y;
k0.m_speedOut = p01 - p0;
k.m_speedIn = p012 - p;
k.m_speedOut = p123 - p;
k1.m_speedIn = p23 - p3;
}
//---------------------------------------------------------
inline double getEaseInOutValue(const TActualDoubleKeyframe &k0,
const TActualDoubleKeyframe &k1, double frame,
bool percentage) {
double x3 = k1.m_frame - k0.m_frame;
if (x3 <= 0.0) return k0.m_value;
double x = frame - k0.m_frame;
if (x <= 0)
return k0.m_value;
else if (x >= x3)
return k1.m_value;
double e0 = std::max(k0.m_speedOut.x, 0.0);
double e1 = std::max(-k1.m_speedIn.x, 0.0);
if (percentage) {
e0 *= x3 * 0.01;
e1 *= x3 * 0.01;
}
if (e0 + e1 >= x3) {
double x = tcrop((e0 + x3 - e1) / 2, 0.0, x3);
e0 = x;
e1 = x3 - x;
}
double x1 = e0, x2 = x3 - e1;
if (0 < x1 - x2 && x1 - x2 < 0.1e-5)
x1 = x2 = (x1 + x2) * 0.5; // against rounding problems
assert(0 <= x1 && x1 <= x2 && x2 <= x3);
double v = 2 / (x3 + x2 - x1);
double value = 0;
if (x < x1) {
double a = v / e0;
value = 0.5 * a * x * x;
} else if (x > x2) {
double a = v / e1;
value = 1 - 0.5 * a * (x3 - x) * (x3 - x);
} else {
double c = -0.5 * v * e0;
value = x * v + c;
}
return (1 - value) * k0.m_value + value * k1.m_value;
}
//---------------------------------------------------------
inline double getExponentialValue(const TActualDoubleKeyframe &k0,
const TActualDoubleKeyframe &k1,
double frame) {
double aFrame = k0.m_frame;
double bFrame = k1.m_frame;
double deltaX = bFrame - aFrame;
double aValue = k0.m_value;
double bValue = k1.m_value;
// if min(aValue,bValue)<=0 => error => linear
if (aValue <= 0 || bValue <= 0) return getLinearValue(k0, k1, frame);
double t = (frame - aFrame) / deltaX;
// if aValue<bValue then v = aValue * exp(t * log(bValue/aValue))
// if bValue<aValue then v = bValue * exp((1-t) * log(aValue/bValue))
if (bValue < aValue) {
t = 1 - t;
tswap(aValue, bValue);
}
return aValue * exp(t * log(bValue / aValue));
}
//---------------------------------------------------------
inline double getExpressionValue(const TActualDoubleKeyframe &k0,
const TActualDoubleKeyframe &k1, double frame,
const TMeasure *measure) {
double t = 0, rframe = frame - k0.m_frame;
if (k1.m_frame > k0.m_frame) t = rframe / (k1.m_frame - k0.m_frame);
TSyntax::Calculator *calculator = k0.m_expression.getCalculator();
if (calculator) {
calculator->setUnit(
(const_cast<TActualDoubleKeyframe &>(k0)).updateUnit(measure));
return calculator->compute(t, frame + 1, rframe + 1);
} else if (measure)
return measure->getDefaultValue();
else
return 0;
}
//---------------------------------------------------------
inline double getSimilarShapeValue(const TActualDoubleKeyframe &k0,
const TActualDoubleKeyframe &k1,
double frame, const TMeasure *measure) {
double offset = k0.m_similarShapeOffset;
double rv0 = getExpressionValue(k0, k1, k0.m_frame + offset, measure);
double rv1 = getExpressionValue(k0, k1, k1.m_frame + offset, measure);
double rv = getExpressionValue(k0, k1, frame + offset, measure);
double v0 = k0.m_value;
double v1 = k1.m_value;
if (rv1 != rv0)
return v0 + (v1 - v0) * (rv - rv0) / (rv1 - rv0);
else if (measure)
return measure->getDefaultValue();
else
return 0;
}
//===================================================================
class TDoubleParam::Imp {
public:
const TSyntax::Grammar *m_grammar;
string m_measureName;
TMeasure *m_measure;
double m_defaultValue, m_minValue, m_maxValue;
DoubleKeyframeVector m_keyframes;
bool m_cycleEnabled;
std::set<TParamObserver *> m_observers;
Imp(double v = 0.0)
: m_grammar(0)
, m_measureName()
, m_measure(0)
, m_defaultValue(v)
, m_minValue(-(std::numeric_limits<double>::max)())
, m_maxValue((std::numeric_limits<double>::max)())
, m_cycleEnabled(false) {}
~Imp() {}
void copy(std::unique_ptr<Imp> const &src) {
m_grammar = src->m_grammar;
m_measureName = src->m_measureName;
m_measure = src->m_measure;
m_defaultValue = src->m_defaultValue;
m_minValue = src->m_minValue;
m_maxValue = src->m_maxValue;
m_keyframes = src->m_keyframes;
m_cycleEnabled = src->m_cycleEnabled;
}
void notify(const TParamChange &change) {
std::set<TParamObserver *>::iterator it = m_observers.begin();
for (; it != m_observers.end(); ++it) (*it)->onChange(change);
}
double getValue(int segmentIndex, double frame);
double getSpeed(int segmentIndex, double frame);
TPointD getSpeedIn(int kIndex);
TPointD getSpeedOut(int kIndex);
};
//---------------------------------------------------------
double TDoubleParam::Imp::getValue(int segmentIndex, double frame) {
assert(0 <= segmentIndex && segmentIndex + 1 < (int)m_keyframes.size());
const TActualDoubleKeyframe &k0 = m_keyframes[segmentIndex];
const TActualDoubleKeyframe &k1 = m_keyframes[segmentIndex + 1];
double value = m_defaultValue;
bool convertUnit = false;
switch (k0.m_type) {
case TDoubleKeyframe::Constant:
value = getConstantValue(k0, k1, frame);
break;
case TDoubleKeyframe::Linear:
value = getLinearValue(k0, k1, frame);
break;
case TDoubleKeyframe::SpeedInOut:
value = getSpeedInOutValue(k0, k1, getSpeedOut(segmentIndex),
getSpeedIn(segmentIndex + 1), frame);
break;
case TDoubleKeyframe::EaseInOut:
value = getEaseInOutValue(k0, k1, frame, false);
break;
case TDoubleKeyframe::EaseInOutPercentage:
value = getEaseInOutValue(k0, k1, frame, true);
break;
case TDoubleKeyframe::Exponential:
value = getExponentialValue(k0, k1, frame);
break;
case TDoubleKeyframe::Expression:
value = getExpressionValue(k0, k1, frame, m_measure);
convertUnit = true;
break;
case TDoubleKeyframe::File:
value = k0.m_fileData.getValue(frame, m_defaultValue);
convertUnit = true;
break;
case TDoubleKeyframe::SimilarShape:
value = getSimilarShapeValue(k0, k1, frame, m_measure);
break;
}
if (convertUnit) value = k0.convertFrom(m_measure, value);
return value;
}
//---------------------------------------------------------
double TDoubleParam::Imp::getSpeed(int segmentIndex, double frame) {
const double h = 0.00001;
return (getValue(segmentIndex, frame + h) -
getValue(segmentIndex, frame - h)) /
(2 * h);
}
//---------------------------------------------------------
TPointD TDoubleParam::Imp::getSpeedIn(int kIndex) {
assert(1 <= kIndex && kIndex < (int)m_keyframes.size());
const TActualDoubleKeyframe &kf0 = m_keyframes[kIndex - 1];
const TActualDoubleKeyframe &kf1 = m_keyframes[kIndex];
assert(kf0.m_type == TDoubleKeyframe::SpeedInOut);
if (!kf1.m_linkedHandles) return kf1.m_speedIn;
TPointD speedIn = kf1.m_speedIn;
if (kIndex + 1 >= (int)m_keyframes.size()) {
// speedIn.y = 0;
} else {
if (kf1.m_type != TDoubleKeyframe::SpeedInOut &&
(kf1.m_type != TDoubleKeyframe::Expression ||
!kf1.m_expression.isCycling())) {
double speed = getSpeed(kIndex, kf1.m_frame);
speedIn.y = speedIn.x * speed;
}
}
return speedIn;
}
//---------------------------------------------------------
TPointD TDoubleParam::Imp::getSpeedOut(int kIndex) {
assert(0 <= kIndex && kIndex < (int)m_keyframes.size());
const TDoubleKeyframe &kf1 = m_keyframes[kIndex];
assert(kf1.m_type == TDoubleKeyframe::SpeedInOut);
if (!kf1.m_linkedHandles) return kf1.m_speedOut;
TPointD speedOut = kf1.m_speedOut;
if (kIndex == 0) {
// speedOut.y = 0;
} else {
const TDoubleKeyframe &kf0 = m_keyframes[kIndex - 1];
if (kf0.m_type != TDoubleKeyframe::SpeedInOut) {
double speed = getSpeed(kIndex - 1, kf1.m_frame);
speedOut.y = speedOut.x * speed;
}
}
return speedOut;
}
//---------------------------------------------------------
TPointD TDoubleParam::getSpeedIn(int kIndex) const {
return m_imp->getSpeedIn(kIndex);
}
TPointD TDoubleParam::getSpeedOut(int kIndex) const {
return m_imp->getSpeedOut(kIndex);
}
//=========================================================
PERSIST_IDENTIFIER(TDoubleParam, "doubleParam")
//---------------------------------------------------------
TDoubleParam::TDoubleParam(double v) : m_imp(new TDoubleParam::Imp(v)) {}
//---------------------------------------------------------
TDoubleParam::TDoubleParam(const TDoubleParam &src)
: TParam(src.getName()), m_imp(new TDoubleParam::Imp()) {
m_imp->copy(src.m_imp);
}
//---------------------------------------------------------
TDoubleParam::~TDoubleParam() {}
//---------------------------------------------------------
TDoubleParam &TDoubleParam::operator=(const TDoubleParam &dp) {
setName(dp.getName());
m_imp->copy(dp.m_imp);
return *this;
}
//---------------------------------------------------------
void TDoubleParam::copy(TParam *src) {
TDoubleParam *p = dynamic_cast<TDoubleParam *>(src);
if (!p) throw TException("invalid source for copy");
setName(src->getName());
m_imp->copy(p->m_imp);
m_imp->notify(TParamChange(this, 0, 0, true, false, false));
}
//---------------------------------------------------------
void TDoubleParam::setValueRange(double min, double max, double step) {
if (min > max) min = max;
m_imp->m_minValue = min;
m_imp->m_maxValue = max;
// m_imp->m_valueStep = step;
}
//---------------------------------------------------------
bool TDoubleParam::getValueRange(double &min, double &max, double &step) const {
min = m_imp->m_minValue;
max = m_imp->m_maxValue;
step = 1; // m_imp->m_valueStep;
return min < max;
}
//---------------------------------------------------------
double TDoubleParam::getDefaultValue() const {
assert(m_imp);
return m_imp->m_defaultValue;
}
//---------------------------------------------------------
void TDoubleParam::enableCycle(bool enabled) {
m_imp->m_cycleEnabled = enabled;
m_imp->notify(TParamChange(this, 0, 0, true, false, false));
}
//---------------------------------------------------------
bool TDoubleParam::isCycleEnabled() const { return m_imp->m_cycleEnabled; }
//=========================================================
//=========================================================
double TDoubleParam::getValue(double frame, bool leftmost) const {
double value = 0;
assert(m_imp);
const DoubleKeyframeVector &keyframes = m_imp->m_keyframes;
if (keyframes.empty()) {
// no keyframes: return the default value
value = m_imp->m_defaultValue;
} else if (keyframes.size() == 1) {
// a single keyframe. Type must be keyframe based (no expression/file)
value = keyframes[0].m_value;
} else {
// keyframes range is [f0,f1]
double f0 = keyframes.begin()->m_frame;
double f1 = keyframes.back().m_frame;
if (frame < f0)
frame = f0;
else if (frame > f1 && !m_imp->m_cycleEnabled)
frame = f1;
double valueOffset = 0;
if (m_imp->m_cycleEnabled) {
double dist = (f1 - f0);
double dvalue = keyframes.back().m_value - keyframes.begin()->m_value;
while (frame >= f1) {
if (frame != f1 || !leftmost) {
frame -= dist;
valueOffset += dvalue;
} else
break;
}
}
// frame is in [f0,f1]
assert(f0 <= frame && frame <= f1);
DoubleKeyframeVector::const_iterator b;
b = std::lower_bound(keyframes.begin(), keyframes.end(),
TDoubleKeyframe(frame));
assert(b != keyframes.end());
DoubleKeyframeVector::const_iterator a;
if (b->m_frame == frame && (b + 1) != keyframes.end()) {
a = b;
b++;
} else {
assert(b != keyframes.begin());
a = b - 1;
}
if (leftmost && frame - a->m_frame < 0.00001 && a != keyframes.begin()) {
a--;
b--;
}
// segment (a,b) contains frame
assert(a != keyframes.end());
assert(b != keyframes.end());
assert(a->m_frame <= frame);
assert(b->m_frame >= frame);
int kIndex = std::distance(keyframes.begin(), a);
vector<TActualDoubleKeyframe> tmpKeyframe(3);
// if segment is keyframe based ....
if (TDoubleKeyframe::isKeyframeBased(a->m_type)) {
// .. and next segment is not then update the b value
if ((b + 1) != keyframes.end() &&
!TDoubleKeyframe::isKeyframeBased(b->m_type)) {
tmpKeyframe[0] = *b;
if (b->m_type != TDoubleKeyframe::Expression ||
!b->m_expression.isCycling())
tmpKeyframe[0].m_value = getValue(b->m_frame);
b = tmpKeyframe.begin();
}
// .. and/or if prev segment is not then update the a value
if (a != keyframes.begin() &&
!TDoubleKeyframe::isKeyframeBased(a[-1].m_type)) {
tmpKeyframe[1] = *a;
tmpKeyframe[1].m_value = getValue(a->m_frame, true);
a = tmpKeyframe.begin() + 1;
}
}
if (a->m_step > 1) {
tmpKeyframe[2] = *b;
b = tmpKeyframe.begin() + 2;
int relPos = tfloor(b->m_frame - a->m_frame),
step = std::min(a->m_step, relPos);
tmpKeyframe[2].m_frame = a->m_frame + tfloor(relPos, step);
if (frame > b->m_frame) frame = b->m_frame;
frame = a->m_frame + tfloor(tfloor(frame - a->m_frame), step);
}
assert(0 <= kIndex && kIndex + 1 < (int)m_imp->m_keyframes.size());
value = m_imp->m_defaultValue;
bool convertUnit = false;
switch (a->m_type) {
case TDoubleKeyframe::Constant:
value = getConstantValue(*a, *b, frame);
break;
case TDoubleKeyframe::Linear:
value = getLinearValue(*a, *b, frame);
break;
case TDoubleKeyframe::SpeedInOut:
value = getSpeedInOutValue(*a, *b, getSpeedOut(kIndex),
getSpeedIn(kIndex + 1), frame);
break;
case TDoubleKeyframe::EaseInOut:
value = getEaseInOutValue(*a, *b, frame, false);
break;
case TDoubleKeyframe::EaseInOutPercentage:
value = getEaseInOutValue(*a, *b, frame, true);
break;
case TDoubleKeyframe::Exponential:
value = getExponentialValue(*a, *b, frame);
break;
case TDoubleKeyframe::Expression:
value = getExpressionValue(*a, *b, frame, m_imp->m_measure);
convertUnit = true;
break;
case TDoubleKeyframe::File:
value = a->m_fileData.getValue(frame, m_imp->m_defaultValue);
convertUnit = true;
break;
case TDoubleKeyframe::SimilarShape:
value = getSimilarShapeValue(*a, *b, frame, m_imp->m_measure);
// convertUnit = true;
break;
default:
value = 0.0;
}
value += valueOffset;
if (convertUnit) value = a->convertFrom(m_imp->m_measure, value);
}
// if (cropped)
// value = tcrop(value, m_imp->m_minValue, m_imp->m_maxValue);
return value;
}
//---------------------------------------------------------
bool TDoubleParam::setValue(double frame, double value) {
assert(m_imp);
DoubleKeyframeVector &keyframes = m_imp->m_keyframes;
DoubleKeyframeVector::iterator it;
TActualDoubleKeyframe k(frame);
it = std::lower_bound(keyframes.begin(), keyframes.end(), k);
int index = 0;
bool created = false;
/*-- キーフレームが見つかった場合 --*/
if (it != keyframes.end() && it->m_frame == frame) {
// changing a keyframe value
index = std::distance(keyframes.begin(), it);
TActualDoubleKeyframe oldKeyframe = *it;
if (oldKeyframe.m_type == TDoubleKeyframe::Expression ||
oldKeyframe.m_type == TDoubleKeyframe::File)
return false;
it->m_value = value;
m_imp->notify(TParamChange(this, 0, 0, true, false, false));
}
/*-- セグメントの部分なので、新たにキーフレームを作る --*/
else {
assert(it == keyframes.end() || it->m_frame > frame);
// can't change value in a file/expression segment
if (it != keyframes.end() && it > keyframes.begin() &&
((it - 1)->m_type == TDoubleKeyframe::Expression ||
(it - 1)->m_type == TDoubleKeyframe::File))
return false;
// inserting a new keyframe
k.m_value = value;
k.m_isKeyframe = true;
k.m_expression.setGrammar(m_imp->m_grammar);
k.m_expression.setOwnerParameter(this);
it = keyframes.insert(it, k);
if (it == keyframes.begin())
it->m_prevType = TDoubleKeyframe::None;
else {
it->m_prevType = it[-1].m_type;
/*-- FxGuiでSegment内にKeyを打った場合は、Step値も引き継ぐ --*/
it->m_step = it[-1].m_step;
}
if (it + 1 != keyframes.end()) it[1].m_prevType = it->m_type;
index = std::distance(keyframes.begin(), it);
m_imp->notify(TParamChange(this, 0, 0, true, false, false));
created = true;
}
assert(0 == index || keyframes[index - 1].m_frame < keyframes[index].m_frame);
assert(getKeyframeCount() - 1 == index ||
keyframes[index + 1].m_frame > keyframes[index].m_frame);
return created;
}
//---------------------------------------------------------
void TDoubleParam::setKeyframe(int index, const TDoubleKeyframe &k) {
DoubleKeyframeVector &keyframes = m_imp->m_keyframes;
assert(0 <= index && index < (int)keyframes.size());
TActualDoubleKeyframe &dst = keyframes[index];
TActualDoubleKeyframe oldKeyframe = dst;
(TDoubleKeyframe &)dst = k;
dst.updateUnit(m_imp->m_measure);
if (dst.m_type == TDoubleKeyframe::Expression ||
dst.m_type == TDoubleKeyframe::SimilarShape)
dst.m_expression.setText(dst.m_expressionText);
if (dst.m_type == TDoubleKeyframe::File)
dst.m_fileData.setParams(dst.m_fileParams);
m_imp->notify(TParamChange(this, 0, 0, true, false, false));
assert(0 == index || keyframes[index - 1].m_frame < keyframes[index].m_frame);
assert(getKeyframeCount() - 1 == index ||
keyframes[index + 1].m_frame > keyframes[index].m_frame);
if (index == 0)
dst.m_prevType = TDoubleKeyframe::None;
else
dst.m_prevType = keyframes[index - 1].m_type;
}
//---------------------------------------------------------
void TDoubleParam::setKeyframes(const std::map<int, TDoubleKeyframe> &ks) {
DoubleKeyframeVector &keyframes = m_imp->m_keyframes;
std::map<int, TDoubleKeyframe>::const_iterator it;
for (it = ks.begin(); it != ks.end(); ++it) {
int index = it->first;
assert(0 <= index && index < (int)keyframes.size());
TActualDoubleKeyframe oldKeyframe = keyframes[index];
TActualDoubleKeyframe &dst = keyframes[index];
(TDoubleKeyframe &)dst = it->second;
dst.updateUnit(m_imp->m_measure);
if (dst.m_type == TDoubleKeyframe::Expression ||
dst.m_type == TDoubleKeyframe::SimilarShape)
dst.m_expression.setText(dst.m_expressionText);
if (dst.m_type == TDoubleKeyframe::File)
dst.m_fileData.setParams(dst.m_fileParams);
}
if (!keyframes.empty()) {
keyframes[0].m_prevType = TDoubleKeyframe::None;
for (int i = 1; i < (int)keyframes.size(); i++)
keyframes[i].m_prevType = keyframes[i - 1].m_type;
}
m_imp->notify(TParamChange(this, 0, 0, true, false, false));
#ifndef NDEBUG
for (int i = 0; i + 1 < (int)keyframes.size(); i++) {
assert(keyframes[i].m_frame <= keyframes[i + 1].m_frame);
}
#endif
}
//---------------------------------------------------------
void TDoubleParam::setKeyframe(const TDoubleKeyframe &k) {
DoubleKeyframeVector &keyframes = m_imp->m_keyframes;
DoubleKeyframeVector::iterator it;
it = std::lower_bound(keyframes.begin(), keyframes.end(), k);
if (it != keyframes.end() && it->m_frame == k.m_frame) {
// int index = std::distance(keyframes.begin(), it);
TActualDoubleKeyframe &dst = *it;
(TDoubleKeyframe &)dst = k;
dst.updateUnit(m_imp->m_measure);
} else {
it = keyframes.insert(it, TActualDoubleKeyframe(k));
// int index = std::distance(keyframes.begin(), it);
// TDoubleKeyframe oldKeyframe = *it;
it->m_expression.setGrammar(m_imp->m_grammar);
it->m_expression.setOwnerParameter(this);
it->updateUnit(m_imp->m_measure);
}
it->m_isKeyframe = true;
if (it->m_type == TDoubleKeyframe::Expression)
it->m_expression.setText(it->m_expressionText);
if (it->m_type == TDoubleKeyframe::File)
it->m_fileData.setParams(it->m_fileParams);
if (it == keyframes.begin())
it->m_prevType = TDoubleKeyframe::None;
else
it->m_prevType = it[-1].m_type;
m_imp->notify(TParamChange(this, 0, 0, true, false, false));
assert(it == keyframes.begin() || (it - 1)->m_frame < it->m_frame);
assert(it + 1 == keyframes.end() || (it + 1)->m_frame > it->m_frame);
}
//---------------------------------------------------------
void TDoubleParam::setDefaultValue(double value) {
assert(m_imp);
if (m_imp->m_defaultValue != value) {
m_imp->m_defaultValue = value;
// gmt, 19-6-2010; needed to get a notification in the FxParamsGraphicEditor
// (Camera Stand)
// when a param (without keyframes) is changed
m_imp->notify(TParamChange(this, 0, 0, true, false, false));
}
}
//---------------------------------------------------------
bool TDoubleParam::isDefault() const {
return m_imp->m_keyframes.empty() &&
// m_imp->m_type == Keyframes &&
m_imp->m_defaultValue == 0;
}
//---------------------------------------------------------
int TDoubleParam::getKeyframeCount() const { return m_imp->m_keyframes.size(); }
//---------------------------------------------------------
void TDoubleParam::getKeyframes(std::set<double> &frames) const {
for (DoubleKeyframeVector::iterator it = m_imp->m_keyframes.begin();
it != m_imp->m_keyframes.end(); ++it)
frames.insert(it->m_frame);
}
//---------------------------------------------------------
bool TDoubleParam::hasKeyframes() const { return !m_imp->m_keyframes.empty(); }
//---------------------------------------------------------
const TDoubleKeyframe &TDoubleParam::getKeyframe(int index) const {
assert(0 <= index && index < (int)m_imp->m_keyframes.size());
return m_imp->m_keyframes[index];
}
//---------------------------------------------------------
const TDoubleKeyframe &TDoubleParam::getKeyframeAt(double frame) const {
static TDoubleKeyframe k;
k = TDoubleKeyframe();
int i = 0;
for (i = 0; i < (int)m_imp->m_keyframes.size(); i++)
if (m_imp->m_keyframes[i].m_frame >= frame) break;
if (i < (int)m_imp->m_keyframes.size() &&
m_imp->m_keyframes[i].m_frame == frame) {
k = m_imp->m_keyframes[i];
return k;
}
k.m_frame = frame;
k.m_value = getValue(frame);
k.m_isKeyframe = false;
return k;
}
//---------------------------------------------------------
bool TDoubleParam::isKeyframe(double frame) const {
return std::binary_search(m_imp->m_keyframes.begin(),
m_imp->m_keyframes.end(), TDoubleKeyframe(frame));
}
//---------------------------------------------------------
void TDoubleParam::deleteKeyframe(double frame) {
DoubleKeyframeVector &keyframes = m_imp->m_keyframes;
DoubleKeyframeVector::iterator it;
it = std::lower_bound(keyframes.begin(), keyframes.end(),
TDoubleKeyframe(frame));
if (it == keyframes.end() || it->m_frame != frame) return;
TDoubleKeyframe::Type type = it->m_prevType;
it = m_imp->m_keyframes.erase(it);
if (it != keyframes.end()) it->m_prevType = type;
m_imp->notify(TParamChange(this, 0, 0, true, false, false));
}
//---------------------------------------------------------
void TDoubleParam::clearKeyframes() {
m_imp->m_keyframes.clear();
m_imp->notify(TParamChange(this, 0, 0, true, false, false));
}
//---------------------------------------------------------
void TDoubleParam::assignKeyframe(double frame, const TParamP &src,
double srcFrame, bool changedOnly) {
TDoubleParamP dp = src;
if (!dp) return;
double value = dp->getValue(srcFrame);
if (!changedOnly || getValue(frame) != value) setValue(frame, value);
}
//---------------------------------------------------------
int TDoubleParam::getClosestKeyframe(double frame) const {
DoubleKeyframeVector &keyframes = m_imp->m_keyframes;
typedef DoubleKeyframeVector::iterator Iterator;
Iterator it = std::lower_bound(keyframes.begin(), keyframes.end(),
TDoubleKeyframe(frame));
if (it == keyframes.end()) {
// frame > k.m_frame per qualsiasi k.
// ritorna l'indice dell'ultimo keyframe (o -1 se l'array e' vuoto)
return keyframes.size() - 1;
} else {
int index = std::distance<Iterator>(keyframes.begin(), it);
if (it->m_frame == frame || index == 0)
return index;
else {
double nextFrame = it->m_frame;
double prevFrame = keyframes[index - 1].m_frame;
assert(prevFrame < frame && frame < nextFrame);
return (nextFrame - frame < frame - prevFrame) ? index : index - 1;
}
}
}
//---------------------------------------------------------
int TDoubleParam::getNextKeyframe(double frame) const {
TDoubleKeyframe k(frame);
typedef DoubleKeyframeVector::const_iterator Iterator;
Iterator it =
std::upper_bound(m_imp->m_keyframes.begin(), m_imp->m_keyframes.end(), k);
if (it == m_imp->m_keyframes.end()) return -1;
int index = std::distance<Iterator>(m_imp->m_keyframes.begin(), it);
if (it->m_frame == frame) {
++index;
return index < getKeyframeCount() ? index : -1;
}
return index;
}
//---------------------------------------------------------
int TDoubleParam::getPrevKeyframe(double frame) const {
TDoubleKeyframe k(frame);
typedef DoubleKeyframeVector::const_iterator Iterator;
Iterator it =
std::lower_bound(m_imp->m_keyframes.begin(), m_imp->m_keyframes.end(), k);
if (it == m_imp->m_keyframes.end()) return m_imp->m_keyframes.size() - 1;
int index = std::distance<Iterator>(m_imp->m_keyframes.begin(), it);
return index - 1;
}
//---------------------------------------------------------
double TDoubleParam::keyframeIndexToFrame(int index) const {
assert(0 <= index && index < getKeyframeCount());
return getKeyframe(index).m_frame;
}
//---------------------------------------------------------
void TDoubleParam::addObserver(TParamObserver *observer) {
m_imp->m_observers.insert(observer);
}
//---------------------------------------------------------
void TDoubleParam::removeObserver(TParamObserver *observer) {
m_imp->m_observers.erase(observer);
}
//---------------------------------------------------------
const std::set<TParamObserver *> &TDoubleParam::observers() const {
return m_imp->m_observers;
}
//---------------------------------------------------------
void TDoubleParam::loadData(TIStream &is) {
string tagName;
/*
if(is.matchTag(tagName))
{
// nuovo formato (29 agosto 2005)
if(tagName!="type") throw TException("expected <type>");
int type = 0;
is >> type;
// m_imp->m_type = TDoubleParam::Type(type);
if(!is.matchEndTag()) throw TException(tagName + " : missing endtag");
//if(!is.matchTag(tagName) || tagName != "default") throw TException("expected
<default>");
//is >> m_imp->m_defaultValue;
//if(!is.matchEndTag()) throw TException(tagName + " : missing endtag");
//if(!is.matchTag(tagName) || tagName != "default") throw TException("expected
<default>");
}
else
{
// vecchio formato
is >> m_imp->m_defaultValue;
}
*/
m_imp->m_keyframes.clear();
int oldType = -1;
while (is.matchTag(tagName)) {
if (tagName == "type") {
// (old) format 5.2. Since 6.0 param type is no used anymore
is >> oldType;
} else if (tagName == "default") {
is >> m_imp->m_defaultValue;
} else if (tagName == "cycle") {
string dummy;
is >> dummy;
m_imp->m_cycleEnabled = true;
// setExtrapolationAfter(Loop);
} else if (tagName == "k") {
// vecchio formato
if (oldType != 0) continue;
int linkStatus = 0;
TActualDoubleKeyframe k;
is >> k.m_frame >> k.m_value >> k.m_speedIn.x >> k.m_speedIn.y >>
k.m_speedOut.x >> k.m_speedOut.y >> linkStatus;
k.m_isKeyframe = true;
k.m_linkedHandles = (linkStatus & 1) != 0;
if ((linkStatus & 1) != 0)
k.m_type = TDoubleKeyframe::SpeedInOut;
else if ((linkStatus & 2) != 0 || (linkStatus & 4) != 0)
k.m_type = TDoubleKeyframe::EaseInOut;
else
k.m_type = TDoubleKeyframe::Linear;
k.m_expression.setGrammar(m_imp->m_grammar);
k.m_expression.setOwnerParameter(this);
k.m_prevType = m_imp->m_keyframes.empty()
? TDoubleKeyframe::None
: m_imp->m_keyframes.back().m_type;
m_imp->m_keyframes.push_back(k);
} else if (tagName == "expr") {
// vecchio formato
if (oldType != 1) continue;
string text = is.getTagAttribute("text");
string enabled = is.getTagAttribute("enabled");
TDoubleKeyframe kk1, kk2;
kk1.m_frame = -1000;
kk2.m_frame = 1000;
kk1.m_isKeyframe = true;
kk2.m_isKeyframe = true;
kk1.m_expressionText = text;
kk2.m_expressionText = text;
kk1.m_type = TDoubleKeyframe::Expression;
kk2.m_type = TDoubleKeyframe::Expression;
TActualDoubleKeyframe k1(kk1);
TActualDoubleKeyframe k2(kk2);
k1.m_expression.setGrammar(m_imp->m_grammar);
k1.m_expression.setOwnerParameter(this);
k1.m_prevType = m_imp->m_keyframes.empty()
? TDoubleKeyframe::None
: m_imp->m_keyframes.back().m_type;
k2.m_expression.setGrammar(m_imp->m_grammar);
k2.m_expression.setOwnerParameter(this);
k2.m_prevType = m_imp->m_keyframes.empty()
? TDoubleKeyframe::None
: m_imp->m_keyframes.back().m_type;
m_imp->m_keyframes.push_back(k1);
m_imp->m_keyframes.push_back(k2);
continue;
} else if (tagName == "file") {
// vecchio formato
if (oldType != 2) continue;
TDoubleKeyframe::FileParams params;
params.m_path = TFilePath(is.getTagAttribute("path"));
params.m_fieldIndex = std::stoi(is.getTagAttribute("index"));
TActualDoubleKeyframe k1, k2;
k1.m_frame = -1000;
k2.m_frame = 1000;
k1.m_isKeyframe = true;
k2.m_isKeyframe = true;
k1.m_fileData.setParams(params);
k2.m_fileData.setParams(params);
k1.m_type = TDoubleKeyframe::File;
k2.m_type = TDoubleKeyframe::File;
k1.m_expression.setGrammar(m_imp->m_grammar);
k1.m_expression.setOwnerParameter(this);
k1.m_prevType = m_imp->m_keyframes.empty()
? TDoubleKeyframe::None
: m_imp->m_keyframes.back().m_type;
k2.m_expression.setGrammar(m_imp->m_grammar);
k2.m_expression.setOwnerParameter(this);
k2.m_prevType = m_imp->m_keyframes.empty()
? TDoubleKeyframe::None
: m_imp->m_keyframes.back().m_type;
m_imp->m_keyframes.push_back(k1);
m_imp->m_keyframes.push_back(k2);
continue;
} else if (tagName == "step") {
int step = 0;
is >> step;
// if(step>1)
// m_imp->m_frameStep = step;
} else if (tagName == "keyframes") {
while (!is.eos()) {
TDoubleKeyframe kk;
kk.loadData(is);
TActualDoubleKeyframe k(kk);
k.m_expression.setGrammar(m_imp->m_grammar);
k.m_expression.setOwnerParameter(this);
k.m_prevType = m_imp->m_keyframes.empty()
? TDoubleKeyframe::None
: m_imp->m_keyframes.back().m_type;
m_imp->m_keyframes.push_back(k);
}
} else {
throw TException(tagName + " : unexpected tag");
}
if (!is.matchEndTag()) throw TException(tagName + " : missing endtag");
}
if (m_imp->m_keyframes.empty() && !is.eos()) {
// vecchio sistema (prima 16/1/2003)
while (!is.eos()) {
double t, v;
is >> t >> v;
m_imp->m_keyframes.push_back(TActualDoubleKeyframe(t, v));
}
if (!m_imp->m_keyframes.empty()) {
m_imp->m_keyframes[0].m_prevType = TDoubleKeyframe::None;
for (int i = 1; i < (int)m_imp->m_keyframes.size(); i++)
m_imp->m_keyframes[i].m_prevType = m_imp->m_keyframes[i - 1].m_type;
}
}
m_imp->notify(TParamChange(this, 0, 0, true, false, false));
}
//---------------------------------------------------------
void TDoubleParam::saveData(TOStream &os) {
// os.child("type") << (int)m_imp->m_type;
os.child("default") << m_imp->m_defaultValue;
if (isCycleEnabled()) os.child("cycle") << std::string("enabled");
// if(getExtrapolationAfter() == Loop)
// os.child("cycle") << string("loop");
if (!m_imp->m_keyframes.empty()) {
os.openChild("keyframes");
DoubleKeyframeVector::const_iterator it;
for (it = m_imp->m_keyframes.begin(); it != m_imp->m_keyframes.end(); ++it)
it->saveData(os);
os.closeChild();
}
}
//---------------------------------------------------------
string TDoubleParam::getStreamTag() const { return "doubleParam"; }
//-------------------------------------------------------------------
string TDoubleParam::getValueAlias(double frame, int precision) {
return ::to_string(getValue(frame), precision);
}
//-------------------------------------------------------------------
void TDoubleParam::setGrammar(const TSyntax::Grammar *grammar) {
m_imp->m_grammar = grammar;
for (int i = 0; i < (int)m_imp->m_keyframes.size(); i++)
m_imp->m_keyframes[i].m_expression.setGrammar(grammar);
}
//-------------------------------------------------------------------
const TSyntax::Grammar *TDoubleParam::getGrammar() const {
return m_imp->m_grammar;
}
//-------------------------------------------------------------------
void TDoubleParam::accept(TSyntax::CalculatorNodeVisitor &visitor) {
for (int i = 0; i < (int)m_imp->m_keyframes.size(); i++)
if (m_imp->m_keyframes[i].m_type == TDoubleKeyframe::Expression ||
m_imp->m_keyframes[i].m_type == TDoubleKeyframe::SimilarShape)
m_imp->m_keyframes[i].m_expression.accept(visitor);
}
//-------------------------------------------------------------------
string TDoubleParam::getMeasureName() const { return m_imp->m_measureName; }
//-------------------------------------------------------------------
void TDoubleParam::setMeasureName(string name) {
m_imp->m_measureName = name;
m_imp->m_measure = TMeasureManager::instance()->get(name);
}
//-------------------------------------------------------------------
TMeasure *TDoubleParam::getMeasure() const { return m_imp->m_measure; }