// TODO: Change to CreateSplineToTarget()
void SetTarget(MotiveIndex index, const MotiveTarget1f& t) {
SplineData& d = Data(index);
// If the first node specifies time=0 or there is no valid data in the
// interpolator, we want to override the current values with the values
// specified in the first node.
const MotiveNode1f& node0 = t.Node(0);
const bool override_current =
node0.time == 0 || !interpolator_.Valid(index);
// TODO(b/65298927): It seems that the animation pipeline can produce data
// that is out of range. Instead of just using node0.value directly, if
// the interpolator is doing modular arithmetic, normalize the y value to
// the modulator's range.
const float start_y =
override_current
? (interpolator_.ModularArithmetic(index)
? interpolator_.ModularRange(index).Normalize(node0.value)
: node0.value)
: interpolator_.NormalizedY(index);
const float start_derivative =
override_current ? node0.velocity : Velocity(index);
const int start_node_index = override_current ? 1 : 0;
// Ensure we have a local spline available, allocated from our pool of
// splines.
if (d.local_spline == nullptr) {
d.local_spline = AllocateSpline();
}
// Initialize the compact spline to hold the sequence of nodes in 't'.
// Add the first node, which has the start condition.
const float end_x = static_cast<float>(t.EndTime());
const Range y_range = CalculateYRange(index, t, start_y);
const float x_granularity = CompactSpline::RecommendXGranularity(end_x);
d.local_spline->Init(y_range, x_granularity);
d.local_spline->AddNode(0.0f, start_y, start_derivative);
// Add subsequent nodes, in turn, taking care to respect the 'direction'
// request when using modular arithmetic.
float prev_y = start_y;
for (int i = start_node_index; i < t.num_nodes(); ++i) {
const MotiveNode1f& n = t.Node(i);
const float y = interpolator_.NextY(index, prev_y, n.value, n.direction);
d.local_spline->AddNode(static_cast<float>(n.time), y, n.velocity,
motive::kAddWithoutModification);
prev_y = y;
}
// Point the interpolator at the spline we just created. Always start our
// spline at time 0.
interpolator_.SetSplines(index, 1, d.local_spline, SplinePlayback());
}
bool iupPlot::CalculateAxisRange()
{
if (mAxisX.mAutoScaleMin || mAxisX.mAutoScaleMax)
{
double theXMin;
double theXMax;
CalculateXRange(theXMin, theXMax);
if (mAxisX.mAutoScaleMin)
{
mAxisX.mMin = theXMin;
if (mAxisX.mLogScale && (theXMin < kLogMinClipValue))
mAxisX.mMin = kLogMinClipValue;
}
if (mAxisX.mAutoScaleMax)
mAxisX.mMax = theXMax;
if (!mAxisX.mTickIter->AdjustRange(mAxisX.mMin, mAxisX.mMax))
return false;
}
if (mAxisY.mAutoScaleMin || mAxisY.mAutoScaleMax)
{
double theYMin;
double theYMax;
CalculateYRange(theYMin, theYMax);
if (mAxisY.mAutoScaleMin)
{
mAxisY.mMin = theYMin;
if (mAxisY.mLogScale && (theYMin < kLogMinClipValue))
mAxisY.mMin = kLogMinClipValue;
}
if (mAxisY.mAutoScaleMax)
mAxisY.mMax = theYMax;
if (!mAxisY.mTickIter->AdjustRange(mAxisY.mMin, mAxisY.mMax))
return false;
}
if (mScaleEqual)
{
if (mAxisY.HasZoom() || mAxisX.HasZoom())
{
if (mAxisY.mMax - mAxisY.mMin != mAxisX.mMax - mAxisX.mMin)
{
double theLength;
if (mAxisY.mMax - mAxisY.mMin > mAxisX.mMax - mAxisX.mMin)
{
theLength = mAxisY.mMax - mAxisY.mMin;
mAxisX.mMax = mAxisX.mMin + theLength;
}
else
{
theLength = mAxisX.mMax - mAxisX.mMin;
mAxisY.mMax = mAxisY.mMin + theLength;
}
}
}
else
{
double theMin = mAxisY.mMin;
if (mAxisX.mMin < theMin)
theMin = mAxisX.mMin;
double theMax = mAxisY.mMax;
if (mAxisX.mMax > theMax)
theMax = mAxisX.mMax;
mAxisX.mMin = theMin;
mAxisY.mMin = theMin;
mAxisX.mMax = theMax;
mAxisY.mMax = theMax;
}
}
return true;
}
bool iupPlot::CalculateAxisRange()
{
if (mAxisX.mAutoScaleMin || mAxisX.mAutoScaleMax)
{
double theXMin;
double theXMax;
CalculateXRange(theXMin, theXMax);
if (mAxisX.mAutoScaleMin)
{
mAxisX.mMin = theXMin;
if (mAxisX.mLogScale && (theXMin < kLogMinClipValue))
mAxisX.mMin = kLogMinClipValue;
}
if (mAxisX.mAutoScaleMax)
mAxisX.mMax = theXMax;
if (!mAxisX.mTickIter->AdjustRange(mAxisX.mMin, mAxisX.mMax))
return false;
}
if (mAxisY.mAutoScaleMin || mAxisY.mAutoScaleMax)
{
double theYMin;
double theYMax;
CalculateYRange(theYMin, theYMax);
if (mAxisY.mAutoScaleMin)
{
mAxisY.mMin = theYMin;
if (mAxisY.mLogScale && (theYMin < kLogMinClipValue))
mAxisY.mMin = kLogMinClipValue;
}
if (mAxisY.mAutoScaleMax)
mAxisY.mMax = theYMax;
if (!mAxisY.mTickIter->AdjustRange(mAxisY.mMin, mAxisY.mMax))
return false;
}
if (mAxisX.mAutoScaleEqual && mAxisY.mAutoScaleEqual &&
mAxisX.mAutoScaleMin && mAxisX.mAutoScaleMax &&
mAxisY.mAutoScaleMin && mAxisY.mAutoScaleMax)
{
double theMin = mAxisY.mMin;
if (mAxisX.mMin < theMin)
theMin = mAxisX.mMin;
double theMax = mAxisY.mMax;
if (mAxisX.mMax > theMax)
theMax = mAxisX.mMax;
mAxisX.mMin = theMin;
mAxisY.mMin = theMin;
mAxisX.mMax = theMax;
mAxisY.mMax = theMax;
}
return true;
}