oak-team/oak-editor
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

implemented support for multilayered keyframes

Browse Source 
This adds the ability to keyframe more than one value per input (e.g. a vec2,
vec3, etc.) so that you can animate, for example, an X axis separately from a
Y axis.
This commit is contained in:
itsmattkc
2019-12-30 04:47:23 +11:00
parent ae84067084
commit 245aa44efc
11 changed files with 444 additions and 251 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/node/input.cpp
+287 -152
View File
@@ -34,24 +34,35 @@ NodeInput::NodeInput(const QString& id, const DataType &type, const QVariant &de
NodeParam(id),
data_type_(type),
keyframable_(true),
standard_value_(default_value),
keyframing_(false),
dependent_(true),
has_minimum_(false),
has_maximum_(false)
{
int track_size;
switch (data_type_) {
case kVec2:
keyframes_.resize(2);
track_size = 2;
break;
case kVec3:
keyframes_.resize(3);
track_size = 3;
break;
case kVec4:
keyframes_.resize(4);
track_size = 4;
break;
default:
keyframes_.resize(1);
track_size = 1;
}
keyframe_tracks_.resize(track_size);
if (!default_value.isNull()) {
standard_value_ = split_normal_value_into_track_values(default_value);
Q_ASSERT(standard_value_.size() == track_size);
} else {
standard_value_.resize(track_size);
}
}
@@ -110,145 +121,120 @@ bool NodeInput::type_can_be_interpolated(NodeParam::DataType type)
QVariant NodeInput::get_value_at_time(const rational &time) const
{
switch (data_type_) {
case kVec2:
{
QVariant x = get_value_at_time_for_track(time, 0);
QVariant y = get_value_at_time_for_track(time, 1);
return QVector2D(x.toFloat(), y.toFloat());
}
case kVec3:
{
QVariant x = get_value_at_time_for_track(time, 0);
QVariant y = get_value_at_time_for_track(time, 1);
QVariant z = get_value_at_time_for_track(time, 2);
return QVector3D(x.toFloat(), y.toFloat(), z.toFloat());
}
case kVec4:
{
QVariant x = get_value_at_time_for_track(time, 0);
QVariant y = get_value_at_time_for_track(time, 1);
QVariant z = get_value_at_time_for_track(time, 2);
QVariant w = get_value_at_time_for_track(time, 3);
return QVector4D(x.toFloat(), y.toFloat(), z.toFloat(), w.toFloat());
}
default:
return get_value_at_time_for_track(time, 0);
return combine_track_values_into_normal_value(get_split_values_at_time(time));
}
QVector<QVariant> NodeInput::get_split_values_at_time(const rational &time) const
{
QVector<QVariant> vals;
for (int i=0;i<get_number_of_keyframe_tracks();i++) {
if (is_using_standard_value(i)) {
vals.append(standard_value_.at(i));
} else {
vals.append(get_value_at_time_for_track(time, i));
}
}
return vals;
}
QVariant NodeInput::get_value_at_time_for_track(const rational& time, int track) const
{
if (is_using_standard_value()) {
return standard_value_;
}
if (!is_using_standard_value(track)) {
const KeyframeTrack& key_track = keyframe_tracks_.at(track);
const QList<NodeKeyframePtr>& key_track = keyframes_.at(track);
if (key_track.first()->time() >= time) {
// This time precedes any keyframe, so we just return the first value
return key_track.first()->value();
}
if (key_track.first()->time() >= time) {
// This time precedes any keyframe, so we just return the first value
return key_track.first()->value();
}
if (key_track.last()->time() <= time) {
// This time is after any keyframes so we return the last value
return key_track.last()->value();
}
if (key_track.last()->time() <= time) {
// This time is after any keyframes so we return the last value
return key_track.last()->value();
}
// If we're here, the time must be somewhere in between the keyframes
for (int i=0;i<key_track.size()-1;i++) {
NodeKeyframePtr before = key_track.at(i);
NodeKeyframePtr after = key_track.at(i+1);
// If we're here, the time must be somewhere in between the keyframes
for (int i=0;i<key_track.size()-1;i++) {
NodeKeyframePtr before = key_track.at(i);
NodeKeyframePtr after = key_track.at(i+1);
if (before->time() == time
|| !type_can_be_interpolated(data_type())
|| (before->time() < time && before->type() == NodeKeyframe::kHold)) {
if (before->time() == time
|| !type_can_be_interpolated(data_type())
|| (before->time() < time && before->type() == NodeKeyframe::kHold)) {
// Time == keyframe time, so value is precise
return before->value();
// Time == keyframe time, so value is precise
return before->value();
} else if (after->time() == time) {
} else if (before->time() < time && after->time() > time) {
// We must interpolate between these keyframes
// Time == keyframe time, so value is precise
return after->value();
if (before->type() == NodeKeyframe::kBezier && after->type() == NodeKeyframe::kBezier) {
// Perform a cubic bezier with two control points
} else if (before->time() < time && after->time() > time) {
// We must interpolate between these keyframes
double t = Bezier::CubicXtoT(time.toDouble(),
before->time().toDouble(),
before->time().toDouble() + before->bezier_control_out().x(),
after->time().toDouble() + after->bezier_control_in().x(),
after->time().toDouble());
if (before->type() == NodeKeyframe::kBezier && after->type() == NodeKeyframe::kBezier) {
// Perform a cubic bezier with two control points
double y = Bezier::CubicTtoY(before->value().toDouble(),
before->value().toDouble() + before->bezier_control_out().y(),
after->value().toDouble() + after->bezier_control_in().y(),
after->value().toDouble(),
t);
double t = Bezier::CubicXtoT(time.toDouble(),
before->time().toDouble(),
before->time().toDouble() + before->bezier_control_out().x(),
after->time().toDouble() + after->bezier_control_in().x(),
after->time().toDouble());
return y;
double y = Bezier::CubicTtoY(before->value().toDouble(),
before->value().toDouble() + before->bezier_control_out().y(),
after->value().toDouble() + after->bezier_control_in().y(),
after->value().toDouble(),
t);
} else if (before->type() == NodeKeyframe::kBezier || after->type() == NodeKeyframe::kBezier) {
// Perform a quadratic bezier with only one control point
return y;
QPointF control_point;
double control_point_time;
double control_point_value;
} else if (before->type() == NodeKeyframe::kBezier || after->type() == NodeKeyframe::kBezier) {
// Perform a quadratic bezier with only one control point
QPointF control_point;
double control_point_time;
double control_point_value;
if (before->type() == NodeKeyframe::kBezier) {
control_point = before->bezier_control_out();
control_point_time = before->time().toDouble() + control_point.x();
control_point_value = before->value().toDouble() + control_point.y();
} else {
control_point = after->bezier_control_in();
control_point_time = after->time().toDouble() + control_point.x();
control_point_value = after->value().toDouble() + control_point.y();
}
// Generate T from time values - used to determine bezier progress
double t = Bezier::QuadraticXtoT(time.toDouble(), before->time().toDouble(), control_point_time, after->time().toDouble());
// Generate value using T
double y = Bezier::QuadraticTtoY(before->value().toDouble(), control_point_value, after->value().toDouble(), t);
return y;
if (before->type() == NodeKeyframe::kBezier) {
control_point = before->bezier_control_out();
control_point_time = before->time().toDouble() + control_point.x();
control_point_value = before->value().toDouble() + control_point.y();
} else {
control_point = after->bezier_control_in();
control_point_time = after->time().toDouble() + control_point.x();
control_point_value = after->value().toDouble() + control_point.y();
// To have arrived here, the keyframes must both be linear
qreal period_progress = (time.toDouble() - before->time().toDouble()) / (after->time().toDouble() - before->time().toDouble());
return lerp(before->value().toDouble(), after->value().toDouble(), period_progress);
}
// Generate T from time values - used to determine bezier progress
double t = Bezier::QuadraticXtoT(time.toDouble(), before->time().toDouble(), control_point_time, after->time().toDouble());
// Generate value using T
double y = Bezier::QuadraticTtoY(before->value().toDouble(), control_point_value, after->value().toDouble(), t);
return y;
} else {
// To have arrived here, the keyframes must both be linear
qreal period_progress = (time.toDouble() - before->time().toDouble()) / (after->time().toDouble() - before->time().toDouble());
QVariant interpolated_value;
switch (data_type()) {
case kFloat:
interpolated_value = lerp(before->value().toDouble(), after->value().toDouble(), period_progress);
break;
case kVec2:
interpolated_value = lerp(before->value().value<QVector2D>(), after->value().value<QVector2D>(), static_cast<float>(period_progress));
break;
case kVec3:
interpolated_value = lerp(before->value().value<QVector3D>(), after->value().value<QVector3D>(), static_cast<float>(period_progress));
break;
case kVec4:
interpolated_value = lerp(before->value().value<QVector4D>(), after->value().value<QVector4D>(), static_cast<float>(period_progress));
break;
default:
interpolated_value = before->value();
}
return interpolated_value;
}
}
}
return standard_value_;
return standard_value_.at(track);
}
QList<NodeKeyframePtr> NodeInput::get_keyframe_at_time(const rational &time) const
{
QList<NodeKeyframePtr> keys;
if (!is_using_standard_value()) {
for (int i=0;i<keyframes_.size();i++) {
for (int i=0;i<keyframe_tracks_.size();i++) {
if (!is_using_standard_value(i)) {
keys.append(get_keyframe_at_time_on_track(time, i));
}
}
@@ -258,8 +244,8 @@ QList<NodeKeyframePtr> NodeInput::get_keyframe_at_time(const rational &time) con
NodeKeyframePtr NodeInput::get_keyframe_at_time_on_track(const rational &time, int track) const
{
if (!is_using_standard_value()) {
foreach (NodeKeyframePtr key, keyframes_.at(track)) {
if (!is_using_standard_value(track)) {
foreach (NodeKeyframePtr key, keyframe_tracks_.at(track)) {
if (key->time() == time) {
return key;
}
@@ -269,13 +255,13 @@ NodeKeyframePtr NodeInput::get_keyframe_at_time_on_track(const rational &time, i
return nullptr;
}
NodeKeyframePtr NodeInput::get_closest_keyframe_to_time(const rational &time, int track) const
NodeKeyframePtr NodeInput::get_closest_keyframe_to_time_on_track(const rational &time, int track) const
{
if (is_using_standard_value()) {
if (is_using_standard_value(track)) {
return nullptr;
}
const QList<NodeKeyframePtr>& key_track = keyframes_.at(track);
const KeyframeTrack& key_track = keyframe_tracks_.at(track);
if (time <= key_track.first()->time()) {
return key_track.first();
@@ -305,9 +291,45 @@ NodeKeyframePtr NodeInput::get_closest_keyframe_to_time(const rational &time, in
return nullptr;
}
NodeKeyframePtr NodeInput::get_closest_keyframe_before_time(const rational &time) const
{
NodeKeyframePtr key = nullptr;
foreach (const KeyframeTrack& track, keyframe_tracks_) {
foreach (NodeKeyframePtr k, track) {
if (k->time() >= time) {
break;
} else if (!key || k->time() > key->time()) {
key = k;
}
}
}
return key;
}
NodeKeyframePtr NodeInput::get_closest_keyframe_after_time(const rational &time) const
{
NodeKeyframePtr key = nullptr;
foreach (const KeyframeTrack& track, keyframe_tracks_) {
for (int i=track.size()-1;i>=0;i--) {
NodeKeyframePtr k = track.at(i);
if (k->time() <= time) {
break;
} else if (!key || k->time() < key->time()) {
key = k;
}
}
}
return key;
}
NodeKeyframe::Type NodeInput::get_best_keyframe_type_for_time(const rational &time, int track) const
{
NodeKeyframePtr closest_key = get_closest_keyframe_to_time(time, track);
NodeKeyframePtr closest_key = get_closest_keyframe_to_time_on_track(time, track);
if (closest_key) {
return closest_key->type();
@@ -316,9 +338,50 @@ NodeKeyframe::Type NodeInput::get_best_keyframe_type_for_time(const rational &ti
return NodeKeyframe::kDefaultType;
}
int NodeInput::get_number_of_keyframe_tracks() const
{
return keyframe_tracks_.size();
}
NodeKeyframePtr NodeInput::get_earliest_keyframe() const
{
NodeKeyframePtr earliest = nullptr;
foreach (const KeyframeTrack& track, keyframe_tracks_) {
if (!track.isEmpty()) {
NodeKeyframePtr earliest_in_track = track.first();
if (!earliest
|| earliest_in_track->time() < earliest->time()) {
earliest = earliest_in_track;
}
}
}
return earliest;
}
NodeKeyframePtr NodeInput::get_latest_keyframe() const
{
NodeKeyframePtr latest = nullptr;
foreach (const KeyframeTrack& track, keyframe_tracks_) {
if (!track.isEmpty()) {
NodeKeyframePtr latest_in_track = track.last();
if (!latest
|| latest_in_track->time() > latest->time()) {
latest = latest_in_track;
}
}
}
return latest;
}
void NodeInput::insert_keyframe(NodeKeyframePtr key)
{
Q_ASSERT(is_keyframable() || keyframes_.isEmpty());
Q_ASSERT(is_keyframable());
insert_keyframe_internal(key);
@@ -335,7 +398,7 @@ void NodeInput::insert_keyframe(NodeKeyframePtr key)
void NodeInput::remove_keyframe(NodeKeyframePtr key)
{
Q_ASSERT(is_keyframable() && keyframes_.size() > 1);
Q_ASSERT(is_keyframable());
TimeRange time_affected = get_range_affected_by_keyframe(key.get());
@@ -345,7 +408,7 @@ void NodeInput::remove_keyframe(NodeKeyframePtr key)
disconnect(key.get(), &NodeKeyframe::BezierControlInChanged, this, &NodeInput::KeyframeBezierInChanged);
disconnect(key.get(), &NodeKeyframe::BezierControlOutChanged, this, &NodeInput::KeyframeBezierOutChanged);
keyframes_[key->track()].removeOne(key);
keyframe_tracks_[key->track()].removeOne(key);
emit KeyframeRemoved(key);
emit_time_range(time_affected);
@@ -362,9 +425,9 @@ void NodeInput::KeyframeTimeChanged()
if (!(original_range.in() < key->time() && original_range.out() > key->time())) {
// This keyframe needs resorting, store it and remove it from the list
NodeKeyframePtr key_shared_ptr = keyframes_.at(key->track()).at(keyframe_index);
NodeKeyframePtr key_shared_ptr = keyframe_tracks_.at(key->track()).at(keyframe_index);
keyframes_.removeAt(keyframe_index);
keyframe_tracks_.removeAt(keyframe_index);
// Automatically insertion sort
insert_keyframe_internal(key_shared_ptr);
@@ -388,7 +451,7 @@ void NodeInput::KeyframeTypeChanged()
NodeKeyframe* key = static_cast<NodeKeyframe*>(sender());
int keyframe_index = FindIndexOfKeyframeFromRawPtr(key);
if (keyframes_.size() <= 1) {
if (keyframe_tracks_.at(key->track()).size() == 1) {
// If there are no other frames, the interpolation won't do anything
return;
}
@@ -406,7 +469,7 @@ void NodeInput::KeyframeBezierInChanged()
rational end = key->time();
if (keyframe_index > 0) {
start = keyframes_.at(key->track()).at(keyframe_index - 1)->time();
start = keyframe_tracks_.at(key->track()).at(keyframe_index - 1)->time();
}
emit ValueChanged(start, end);
@@ -420,8 +483,8 @@ void NodeInput::KeyframeBezierOutChanged()
rational start = key->time();
rational end = RATIONAL_MAX;
if (keyframe_index < keyframes_.size() - 1) {
end = keyframes_.at(key->track()).at(keyframe_index + 1)->time();
if (keyframe_index < keyframe_tracks_.at(key->track()).size() - 1) {
end = keyframe_tracks_.at(key->track()).at(keyframe_index + 1)->time();
}
emit ValueChanged(start, end);
@@ -429,8 +492,10 @@ void NodeInput::KeyframeBezierOutChanged()
int NodeInput::FindIndexOfKeyframeFromRawPtr(NodeKeyframe *raw_ptr) const
{
for (int i=0;i<keyframes_.size();i++) {
if (keyframes_.at(raw_ptr->track()).at(i).get() == raw_ptr) {
const KeyframeTrack& track = keyframe_tracks_.at(raw_ptr->track());
for (int i=0;i<track.size();i++) {
if (track.at(i).get() == raw_ptr) {
return i;
}
}
@@ -440,7 +505,7 @@ int NodeInput::FindIndexOfKeyframeFromRawPtr(NodeKeyframe *raw_ptr) const
void NodeInput::insert_keyframe_internal(NodeKeyframePtr key)
{
QList<NodeKeyframePtr>& key_track = keyframes_[key->track()];
KeyframeTrack& key_track = keyframe_tracks_[key->track()];
for (int i=0;i<key_track.size();i++) {
NodeKeyframePtr compare = key_track.at(i);
@@ -457,9 +522,9 @@ void NodeInput::insert_keyframe_internal(NodeKeyframePtr key)
key_track.append(key);
}
bool NodeInput::is_using_standard_value() const
bool NodeInput::is_using_standard_value(int track) const
{
return (!is_keyframing() || keyframes_.isEmpty());
return (!is_keyframing() || keyframe_tracks_.at(track).isEmpty());
}
TimeRange NodeInput::get_range_affected_by_keyframe(NodeKeyframe *key) const
@@ -468,10 +533,12 @@ TimeRange NodeInput::get_range_affected_by_keyframe(NodeKeyframe *key) const
TimeRange range = get_range_around_index(keyframe_index, key->track());
const KeyframeTrack& key_track = keyframe_tracks_.at(key->track());
// If a previous key exists and it's a hold, we don't need to invalidate those frames
if (keyframes().size() > 1
if (key_track.size() > 1
&& keyframe_index > 0
&& keyframes_.at(key->track()).at(keyframe_index - 1)->type() == NodeKeyframe::kHold) {
&& key_track.at(keyframe_index - 1)->type() == NodeKeyframe::kHold) {
range.set_in(key->time());
}
@@ -483,14 +550,16 @@ TimeRange NodeInput::get_range_around_index(int index, int track) const
rational range_begin = RATIONAL_MIN;
rational range_end = RATIONAL_MAX;
if (keyframes_.size() > 1) {
const KeyframeTrack& key_track = keyframe_tracks_.at(track);
if (key_track.size() > 1) {
if (index > 0) {
// If this is not the first key, we'll need to limit it to the key just before
range_begin = keyframes_.at(track).at(index - 1)->time();
range_begin = key_track.at(index - 1)->time();
}
if (index < keyframes_.size() - 1) {
if (index < key_track.size() - 1) {
// If this is not the last key, we'll need to limit it to the key just after
range_end = keyframes_.at(track).at(index + 1)->time();
range_end = key_track.at(index + 1)->time();
}
}
@@ -509,13 +578,12 @@ void NodeInput::emit_range_affected_by_keyframe(NodeKeyframe *key)
bool NodeInput::has_keyframe_at_time(const rational &time) const
{
// If we aren't keyframing, there definitely isn't a keyframe at a given time
if (is_using_standard_value()) {
if (!is_keyframing()) {
return false;
}
// Loop through keyframes to see if any match
foreach (const QList<NodeKeyframePtr>& track, keyframes_) {
foreach (const KeyframeTrack& track, keyframe_tracks_) {
foreach (NodeKeyframePtr key, track) {
if (key->time() == time) {
return true;
@@ -544,24 +612,29 @@ bool NodeInput::is_keyframable() const
return keyframable_;
}
const QVariant &NodeInput::get_standard_value() const
QVariant NodeInput::get_standard_value() const
{
return combine_track_values_into_normal_value(standard_value_);
}
const QVector<QVariant> &NodeInput::get_split_standard_value() const
{
return standard_value_;
}
void NodeInput::set_standard_value(const QVariant &value)
void NodeInput::set_standard_value(const QVariant &value, int track)
{
standard_value_ = value;
standard_value_.replace(track, value);
if (is_using_standard_value()) {
if (is_using_standard_value(track)) {
// If this standard value is being used, we need to send a value changed signal
emit ValueChanged(RATIONAL_MIN, RATIONAL_MAX);
}
}
const QVector< QList<NodeKeyframePtr> > &NodeInput::keyframes() const
const QVector<NodeInput::KeyframeTrack> &NodeInput::keyframe_tracks() const
{
return keyframes_;
return keyframe_tracks_;
}
void NodeInput::set_is_keyframable(bool k)
@@ -609,10 +682,10 @@ void NodeInput::CopyValues(NodeInput *source, NodeInput *dest, bool include_conn
dest->standard_value_ = source->standard_value_;
// Copy keyframes
for (int i=0;i<source->keyframes_.size();i++) {
dest->keyframes_[i].clear();
foreach (NodeKeyframePtr key, source->keyframes_.at(i)) {
dest->keyframes_[i].append(key->copy());
for (int i=0;i<source->keyframe_tracks_.size();i++) {
dest->keyframe_tracks_[i].clear();
foreach (NodeKeyframePtr key, source->keyframe_tracks_.at(i)) {
dest->keyframe_tracks_[i].append(key->copy());
}
}
@@ -638,3 +711,65 @@ void NodeInput::CopyValues(NodeInput *source, NodeInput *dest, bool include_conn
emit dest->ValueChanged(RATIONAL_MIN, RATIONAL_MAX);
}
QVector<QVariant> NodeInput::split_normal_value_into_track_values(const QVariant &value) const
{
QVector<QVariant> vals(get_number_of_keyframe_tracks());
switch (data_type_) {
case kVec2:
{
QVector2D vec = value.value<QVector2D>();
vals.replace(0, vec.x());
vals.replace(1, vec.y());
break;
}
case kVec3:
{
QVector3D vec = value.value<QVector3D>();
vals.replace(0, vec.x());
vals.replace(1, vec.y());
vals.replace(2, vec.z());
break;
}
case kVec4:
{
QVector4D vec = value.value<QVector4D>();
vals.replace(0, vec.x());
vals.replace(1, vec.y());
vals.replace(2, vec.z());
vals.replace(3, vec.w());
break;
}
default:
vals.replace(0, value);
}
return vals;
}
QVariant NodeInput::combine_track_values_into_normal_value(const QVector<QVariant> &split) const
{
switch (data_type_) {
case kVec2:
{
return QVector2D(split.at(0).toFloat(),
split.at(1).toFloat());
}
case kVec3:
{
return QVector3D(split.at(0).toFloat(),
split.at(1).toFloat(),
split.at(2).toFloat());
}
case kVec4:
{
return QVector4D(split.at(0).toFloat(),
split.at(1).toFloat(),
split.at(2).toFloat(),
split.at(3).toFloat());
}
default:
return split.first();
}
}
app/node/input.h
+49 -7
View File
@@ -32,6 +32,8 @@ class NodeInput : public NodeParam
{
Q_OBJECT
public:
using KeyframeTrack = QList<NodeKeyframePtr>;
/**
* @brief NodeInput Constructor
*
@@ -85,6 +87,8 @@ public:
*/
QVariant get_value_at_time(const rational& time) const;
QVector<QVariant> get_split_values_at_time(const rational& time) const;
/**
* @brief Calculate the stored value for a specific track
*
@@ -114,13 +118,42 @@ public:
*
* If is_keyframing() is false or keyframes_ is empty, this will return nullptr.
*/
NodeKeyframePtr get_closest_keyframe_to_time(const rational& time, int track) const;
NodeKeyframePtr get_closest_keyframe_to_time_on_track(const rational& time, int track) const;
/**
* @brief Get closest keyframe that's before the time on any track
*
* If no keyframe is before this time, returns nullptr.
*/
NodeKeyframePtr get_closest_keyframe_before_time(const rational& time) const;
/**
* @brief Get closest keyframe that's before the time on any track
*
* If no keyframe is before this time, returns nullptr.
*/
NodeKeyframePtr get_closest_keyframe_after_time(const rational& time) const;
/**
* @brief A heuristic to determine what type a keyframe should be if it's inserted at a certain time (between keyframes)
*/
NodeKeyframe::Type get_best_keyframe_type_for_time(const rational& time, int track) const;
/**
* @brief Retrieve the number of
*/
int get_number_of_keyframe_tracks() const;
/**
* @brief Gets the earliest keyframe on any track
*/
NodeKeyframePtr get_earliest_keyframe() const;
/**
* @brief Gets the latest keyframe on any track
*/
NodeKeyframePtr get_latest_keyframe() const;
/**
* @brief Inserts a keyframe at the given time and returns a reference to it
*/
@@ -157,17 +190,22 @@ public:
/**
* @brief Get non-keyframed value
*/
const QVariant& get_standard_value() const;
QVariant get_standard_value() const;
/**
* @brief Get non-keyframed value split into components (the way it's stored)
*/
const QVector<QVariant>& get_split_standard_value() const;
/**
* @brief Set non-keyframed value
*/
void set_standard_value(const QVariant& value);
void set_standard_value(const QVariant& value, int track = 0);
/**
* @brief Return list of keyframes in this parameter
*/
const QVector<QList<NodeKeyframePtr> > &keyframes() const;
const QVector<KeyframeTrack> &keyframe_tracks() const;
/**
* @brief Set whether this input can be keyframed or not
@@ -187,6 +225,10 @@ public:
*/
static void CopyValues(NodeInput* source, NodeInput* dest, bool include_connections = true, bool lock_connections = true);
QVector<QVariant> split_normal_value_into_track_values(const QVariant &value) const;
QVariant combine_track_values_into_normal_value(const QVector<QVariant>& split) const;
signals:
void ValueChanged(const rational& start, const rational& end);
@@ -216,7 +258,7 @@ private:
/**
* @brief Return whether the standard value should be used over keyframe data
*/
bool is_using_standard_value() const;
bool is_using_standard_value(int track) const;
/**
* @brief Intelligently determine how what time range is affected by a keyframe
@@ -253,14 +295,14 @@ private:
/**
* @brief Non-keyframed value
*/
QVariant standard_value_;
QVector<QVariant> standard_value_;
/**
* @brief Internal keyframe array
*
* If keyframing is enabled, this data is used instead of standard_value.
*/
QVector< QList<NodeKeyframePtr> > keyframes_;
QVector< QList<NodeKeyframePtr> > keyframe_tracks_;
/**
* @brief Internal keyframing enabled setting
app/node/keyframe.cpp
+6 -1
View File
@@ -37,7 +37,7 @@ NodeKeyframePtr NodeKeyframe::Create(const rational &time, const QVariant &value
NodeKeyframePtr NodeKeyframe::copy() const
{
NodeKeyframePtr copy = std::make_shared<NodeKeyframe>(time_, value_, type_);
NodeKeyframePtr copy = std::make_shared<NodeKeyframe>(time_, value_, type_, track_);
copy->bezier_control_in_ = bezier_control_in_;
copy->bezier_control_out_ = bezier_control_out_;
return copy;
@@ -116,6 +116,11 @@ void NodeKeyframe::set_bezier_control(NodeKeyframe::BezierType type, const QPoin
}
}
const int &NodeKeyframe::track() const
{
return track_;
}
NodeKeyframe::BezierType NodeKeyframe::get_opposing_bezier_type(NodeKeyframe::BezierType type)
{
if (type == kInHandle) {
app/node/keyframe.h
+2 -2
View File
@@ -58,9 +58,9 @@ public:
/**
* @brief NodeKeyframe Constructor
*/
NodeKeyframe(const rational& time, const QVariant& value, const Type& type, const int& track = 0);
NodeKeyframe(const rational& time, const QVariant& value, const Type& type, const int& track);
static NodeKeyframePtr Create(const rational& time, const QVariant& value, const Type& type, const int &track = 0);
static NodeKeyframePtr Create(const rational& time, const QVariant& value, const Type& type, const int &track);
NodeKeyframePtr copy() const;
app/widget/curvewidget/curvewidget.cpp
+4 -2
View File
@@ -114,8 +114,10 @@ void CurveWidget::SetInput(NodeInput *input)
connect(input_, &NodeInput::KeyframeAdded, view_, &CurveView::AddKeyframe);
connect(input_, &NodeInput::KeyframeRemoved, view_, &CurveView::RemoveKeyframe);
foreach (NodeKeyframePtr key, input_->keyframes()) {
view_->AddKeyframe(key);
foreach (const NodeInput::KeyframeTrack& track, input_->keyframe_tracks()) {
foreach (NodeKeyframePtr key, track) {
view_->AddKeyframe(key);
}
}
}
app/widget/nodeparamview/nodeparamviewitem.cpp
+13 -9
View File
@@ -93,8 +93,10 @@ void NodeParamViewItem::SignalAllKeyframes()
if (param->type() == NodeParam::kInput) {
NodeInput* input = static_cast<NodeInput*>(param);
foreach (NodeKeyframePtr key, input->keyframes()) {
InputAddedKeyframeInternal(input, key);
foreach (const NodeInput::KeyframeTrack& track, input->keyframe_tracks()) {
foreach (NodeKeyframePtr key, track) {
InputAddedKeyframeInternal(input, key);
}
}
}
}
@@ -220,13 +222,15 @@ void NodeParamViewItem::InputKeyframeEnableChanged(bool e)
{
NodeInput* input = static_cast<NodeInput*>(sender());
foreach (NodeKeyframePtr key, input->keyframes()) {
if (e) {
// Add a keyframe item for each keyframe
InputAddedKeyframeInternal(input, key);
} else {
// Remove each keyframe item
emit KeyframeRemoved(key);
foreach (const NodeInput::KeyframeTrack& track, input->keyframe_tracks()) {
foreach (NodeKeyframePtr key, track) {
if (e) {
// Add a keyframe item for each keyframe
InputAddedKeyframeInternal(input, key);
} else {
// Remove each keyframe item
emit KeyframeRemoved(key);
}
}
}
}
app/widget/nodeparamview/nodeparamviewkeyframecontrol.cpp
+51 -36
View File
@@ -111,24 +111,32 @@ void NodeParamViewKeyframeControl::ShowButtonsFromKeyframeEnable(bool e)
void NodeParamViewKeyframeControl::ToggleKeyframe(bool e)
{
NodeKeyframePtr key = input_->get_keyframe_at_time(time_);
QList<NodeKeyframePtr> keys = input_->get_keyframe_at_time(time_);
QUndoCommand* command = new QUndoCommand();
if (e && !key) {
// Add a keyframe here
key = NodeKeyframe::Create(time_,
input_->get_value_at_time(time_),
input_->get_best_keyframe_type_for_time(time_));
if (e && keys.isEmpty()) {
// Add a keyframe here (one for each track)
for (int i=0;i<input_->get_number_of_keyframe_tracks();i++) {
NodeKeyframePtr key = NodeKeyframe::Create(time_,
input_->get_value_at_time_for_track(time_, i),
input_->get_best_keyframe_type_for_time(time_, i),
i);
new NodeParamInsertKeyframeCommand(input_, key, command);
} else if (!e && key) {
// Remove a keyframe here
new NodeParamRemoveKeyframeCommand(input_, key, command);
new NodeParamInsertKeyframeCommand(input_, key, command);
}
} else if (!e && !keys.isEmpty()) {
// Remove all keyframes at this time
foreach (NodeKeyframePtr key, keys) {
new NodeParamRemoveKeyframeCommand(input_, key, command);
// If this was the last keyframe, we'll set the standard value to the value at this time too
if (input_->keyframes().size() == 1) {
new NodeParamSetStandardValueCommand(input_, key->value(), command);
if (input_->keyframe_tracks().at(key->track()).size() == 1) {
// If this was the last keyframe on this track, set the standard value to the value at this time too
new NodeParamSetStandardValueCommand(input_,
key->track(),
input_->get_value_at_time_for_track(time_, key->track()),
command);
}
}
}
@@ -141,34 +149,29 @@ void NodeParamViewKeyframeControl::UpdateState()
return;
}
prev_key_btn_->setEnabled(!input_->keyframes().isEmpty() && time_ > input_->keyframes().first()->time());
next_key_btn_->setEnabled(!input_->keyframes().isEmpty() && time_ < input_->keyframes().last()->time());
NodeKeyframePtr earliest_key = input_->get_earliest_keyframe();
NodeKeyframePtr latest_key = input_->get_latest_keyframe();
prev_key_btn_->setEnabled(earliest_key && time_ > earliest_key->time());
next_key_btn_->setEnabled(latest_key && time_ < latest_key->time());
toggle_key_btn_->setChecked(input_->has_keyframe_at_time(time_));
}
void NodeParamViewKeyframeControl::GoToPreviousKey()
{
for (int i=input_->keyframes().size()-1;i>=0;i--) {
// Find closest keyframe that is before this time
const rational& this_key_time = input_->keyframes().at(i)->time();
NodeKeyframePtr previous_key = input_->get_closest_keyframe_before_time(time_);
if (this_key_time < time_) {
emit RequestSetTime(this_key_time);
break;
}
if (previous_key) {
emit RequestSetTime(previous_key->time());
}
}
void NodeParamViewKeyframeControl::GoToNextKey()
{
for (int i=0;i<input_->keyframes().size();i++) {
// Find closest keyframe that is before this time
const rational& this_key_time = input_->keyframes().at(i)->time();
NodeKeyframePtr next_key = input_->get_closest_keyframe_after_time(time_);
if (this_key_time > time_) {
emit RequestSetTime(this_key_time);
break;
}
if (next_key) {
emit RequestSetTime(next_key->time());
}
}
@@ -185,9 +188,17 @@ void NodeParamViewKeyframeControl::KeyframeEnableChanged(bool e)
// Enable keyframing
new NodeParamSetKeyframingCommand(input_, true, command);
// NodeInputs already have one keyframe by default, we move it to the current time here
NodeKeyframePtr key = NodeKeyframe::Create(time_, input_->get_standard_value(), NodeKeyframe::kDefaultType);
new NodeParamInsertKeyframeCommand(input_, key, command);
// Create one keyframe across all tracks here
QVector<QVariant> key_vals = input_->get_split_standard_value();
for (int i=0;i<key_vals.size();i++) {
NodeKeyframePtr key = NodeKeyframe::Create(time_,
key_vals.at(i),
NodeKeyframe::kDefaultType,
i);
new NodeParamInsertKeyframeCommand(input_, key, command);
}
} else {
// Confirm the user wants to clear all keyframes
if (QMessageBox::warning(this,
@@ -196,15 +207,19 @@ void NodeParamViewKeyframeControl::KeyframeEnableChanged(bool e)
QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes) {
// Store value at this time, we'll set this as the persistent value later
QVariant stored_val = input_->get_value_at_time(time_);
QVector<QVariant> stored_vals = input_->get_split_values_at_time(time_);
// Delete all keyframes
for (int i=input_->keyframes().size()-1;i>=0;i--) {
new NodeParamRemoveKeyframeCommand(input_, input_->keyframes().at(i), command);
foreach (const NodeInput::KeyframeTrack& track, input_->keyframe_tracks()) {
for (int i=track.size()-1;i>=0;i--) {
new NodeParamRemoveKeyframeCommand(input_, track.at(i), command);
}
}
// Update standard value
new NodeParamSetStandardValueCommand(input_, stored_val, command);
for (int i=0;i<stored_vals.size();i++) {
new NodeParamSetStandardValueCommand(input_, i, stored_vals.at(i), command);
}
// Disable keyframing
new NodeParamSetKeyframingCommand(input_, false, command);
app/widget/nodeparamview/nodeparamviewundo.cpp
+6 -4
View File
@@ -117,17 +117,19 @@ void NodeParamSetKeyframeTimeCommand::undo()
key_->set_time(old_time_);
}
NodeParamSetStandardValueCommand::NodeParamSetStandardValueCommand(NodeInput *input, const QVariant &value, QUndoCommand *parent) :
NodeParamSetStandardValueCommand::NodeParamSetStandardValueCommand(NodeInput *input, int track, const QVariant &value, QUndoCommand *parent) :
QUndoCommand(parent),
input_(input),
track_(track),
old_value_(input_->get_standard_value()),
new_value_(value)
{
}
NodeParamSetStandardValueCommand::NodeParamSetStandardValueCommand(NodeInput *input, const QVariant &new_value, const QVariant &old_value, QUndoCommand *parent) :
NodeParamSetStandardValueCommand::NodeParamSetStandardValueCommand(NodeInput *input, int track, const QVariant &new_value, const QVariant &old_value, QUndoCommand *parent) :
QUndoCommand(parent),
input_(input),
track_(track),
old_value_(old_value),
new_value_(new_value)
{
@@ -135,10 +137,10 @@ NodeParamSetStandardValueCommand::NodeParamSetStandardValueCommand(NodeInput *in
void NodeParamSetStandardValueCommand::redo()
{
input_->set_standard_value(new_value_);
input_->set_standard_value(new_value_, track_);
}
void NodeParamSetStandardValueCommand::undo()
{
input_->set_standard_value(old_value_);
input_->set_standard_value(old_value_, track_);
}
app/widget/nodeparamview/nodeparamviewundo.h
+4 -2
View File
@@ -82,17 +82,19 @@ private:
class NodeParamSetStandardValueCommand : public QUndoCommand {
public:
NodeParamSetStandardValueCommand(NodeInput* input, const QVariant& value, QUndoCommand* parent = nullptr);
NodeParamSetStandardValueCommand(NodeInput* input, const QVariant& new_value, const QVariant& old_value, QUndoCommand* parent = nullptr);
NodeParamSetStandardValueCommand(NodeInput* input, int track, const QVariant& value, QUndoCommand* parent = nullptr);
NodeParamSetStandardValueCommand(NodeInput* input, int track, const QVariant& new_value, const QVariant& old_value, QUndoCommand* parent = nullptr);
virtual void redo() override;
virtual void undo() override;
private:
NodeInput* input_;
int track_;
QVariant old_value_;
QVariant new_value_;
};
#endif // NODEPARAMVIEWUNDO_H
app/widget/nodeparamview/nodeparamviewwidgetbridge.cpp
+21 -35
View File
@@ -251,12 +251,12 @@ void NodeParamViewWidgetBridge::CreateWidgets()
}
}
void NodeParamViewWidgetBridge::SetInputValue(const QVariant &value)
void NodeParamViewWidgetBridge::SetInputValue(const QVariant &value, int track)
{
QUndoCommand* command = new QUndoCommand();
if (input_->is_keyframing()) {
NodeKeyframePtr existing_key = input_->get_keyframe_at_time(time_);
NodeKeyframePtr existing_key = input_->get_keyframe_at_time_on_track(time_, track);
if (existing_key) {
new NodeParamSetKeyframeValueCommand(existing_key, value, command);
@@ -264,12 +264,13 @@ void NodeParamViewWidgetBridge::SetInputValue(const QVariant &value)
// No existing key, create a new one
NodeKeyframePtr new_key = NodeKeyframe::Create(time_,
value,
input_->get_best_keyframe_type_for_time(time_));
input_->get_best_keyframe_type_for_time(time_, track),
track);
new NodeParamInsertKeyframeCommand(input_, new_key, command);
}
} else {
new NodeParamSetStandardValueCommand(input_, value, command);
new NodeParamSetStandardValueCommand(input_, track, value, command);
}
Core::instance()->undo_stack()->pushIfHasChildren(command);
@@ -277,6 +278,8 @@ void NodeParamViewWidgetBridge::SetInputValue(const QVariant &value)
void NodeParamViewWidgetBridge::ProcessSlider(SliderBase *slider, const QVariant &value)
{
int slider_track = widgets_.indexOf(slider);
if (slider->IsDragging()) {
// While we're dragging, we block the input's normal signalling and create our own
@@ -287,17 +290,18 @@ void NodeParamViewWidgetBridge::ProcessSlider(SliderBase *slider, const QVariant
dragging_ = true;
// Cache current value
drag_old_value_ = input_->get_value_at_time(time_);
drag_old_value_ = input_->get_value_at_time_for_track(time_, slider_track);
// Determine whether we are creating a keyframe or not
if (input_->is_keyframing()) {
dragging_keyframe_ = input_->get_keyframe_at_time(time_);
dragging_keyframe_ = input_->get_keyframe_at_time_on_track(time_, slider_track);
drag_created_keyframe_ = !dragging_keyframe_;
if (drag_created_keyframe_) {
dragging_keyframe_ = NodeKeyframe::Create(time_,
value,
input_->get_best_keyframe_type_for_time(time_));
input_->get_best_keyframe_type_for_time(time_, slider_track),
slider_track);
input_->insert_keyframe(dragging_keyframe_);
@@ -312,7 +316,7 @@ void NodeParamViewWidgetBridge::ProcessSlider(SliderBase *slider, const QVariant
if (input_->is_keyframing()) {
dragging_keyframe_->set_value(value);
} else {
input_->set_standard_value(value);
input_->set_standard_value(value, slider_track);
}
input_->blockSignals(false);
@@ -337,14 +341,14 @@ void NodeParamViewWidgetBridge::ProcessSlider(SliderBase *slider, const QVariant
new NodeParamSetKeyframeValueCommand(dragging_keyframe_, value, drag_old_value_, command);
} else {
// We just set the standard value
new NodeParamSetStandardValueCommand(input_, value, drag_old_value_, command);
new NodeParamSetStandardValueCommand(input_, slider_track, value, drag_old_value_, command);
}
Core::instance()->undo_stack()->push(command);
} else {
// No drag was involved, we can just push the value
SetInputValue(value);
SetInputValue(value, slider_track);
}
}
}
@@ -387,12 +391,7 @@ void NodeParamViewWidgetBridge::WidgetCallback()
// Widget is a FloatSlider
FloatSlider* slider = static_cast<FloatSlider*>(sender());
QVector2D value(
static_cast<float>(static_cast<FloatSlider*>(widgets_.at(0))->GetValue()),
static_cast<float>(static_cast<FloatSlider*>(widgets_.at(1))->GetValue())
);
ProcessSlider(slider, value);
ProcessSlider(slider, slider->GetValue());
break;
}
case NodeParam::kVec3:
@@ -400,13 +399,7 @@ void NodeParamViewWidgetBridge::WidgetCallback()
// Widget is a FloatSlider
FloatSlider* slider = static_cast<FloatSlider*>(sender());
QVector3D value(
static_cast<float>(static_cast<FloatSlider*>(widgets_.at(0))->GetValue()),
static_cast<float>(static_cast<FloatSlider*>(widgets_.at(1))->GetValue()),
static_cast<float>(static_cast<FloatSlider*>(widgets_.at(2))->GetValue())
);
ProcessSlider(slider, value);
ProcessSlider(slider, slider->GetValue());
break;
}
case NodeParam::kVec4:
@@ -414,14 +407,7 @@ void NodeParamViewWidgetBridge::WidgetCallback()
// Widget is a FloatSlider
FloatSlider* slider = static_cast<FloatSlider*>(sender());
QVector4D value(
static_cast<float>(static_cast<FloatSlider*>(widgets_.at(0))->GetValue()),
static_cast<float>(static_cast<FloatSlider*>(widgets_.at(1))->GetValue()),
static_cast<float>(static_cast<FloatSlider*>(widgets_.at(2))->GetValue()),
static_cast<float>(static_cast<FloatSlider*>(widgets_.at(3))->GetValue())
);
ProcessSlider(slider, value);
ProcessSlider(slider, slider->GetValue());
break;
}
case NodeParam::kFile:
@@ -433,25 +419,25 @@ void NodeParamViewWidgetBridge::WidgetCallback()
case NodeParam::kText:
{
// Sender is a QLineEdit
SetInputValue(static_cast<QLineEdit*>(sender())->text());
SetInputValue(static_cast<QLineEdit*>(sender())->text(), 0);
break;
}
case NodeParam::kBoolean:
{
// Widget is a QCheckBox
SetInputValue(static_cast<QCheckBox*>(sender())->isChecked());
SetInputValue(static_cast<QCheckBox*>(sender())->isChecked(), 0);
break;
}
case NodeParam::kFont:
{
// Widget is a QFontComboBox
SetInputValue(static_cast<QFontComboBox*>(sender())->currentFont());
SetInputValue(static_cast<QFontComboBox*>(sender())->currentFont(), 0);
break;
}
case NodeParam::kFootage:
{
// Widget is a FootageComboBox
SetInputValue(QVariant::fromValue(static_cast<FootageComboBox*>(sender())->SelectedFootage()));
SetInputValue(QVariant::fromValue(static_cast<FootageComboBox*>(sender())->SelectedFootage()), 0);
break;
}
}
app/widget/nodeparamview/nodeparamviewwidgetbridge.h
+1 -1
View File
@@ -19,7 +19,7 @@ public:
private:
void CreateWidgets();
void SetInputValue(const QVariant& value);
void SetInputValue(const QVariant& value, int track);
void ProcessSlider(SliderBase* slider, const QVariant& value);