implemented full bezier interpolation for keyframes

This commit is contained in:
itsmattkc
2019-01-03 21:52:01 +11:00
parent 215c784f8e
commit 30933cbfcd
25 changed files with 1311 additions and 1071 deletions
+4 -4
View File
@@ -4,15 +4,15 @@
#include <QtMath> #include <QtMath>
AudioNoiseEffect::AudioNoiseEffect(Clip* c, const EffectMeta *em) : Effect(c, em) { AudioNoiseEffect::AudioNoiseEffect(Clip* c, const EffectMeta *em) : Effect(c, em) {
amount_val = add_row("Amount:")->add_field(EFFECT_FIELD_DOUBLE, "amount"); amount_val = add_row("Amount")->add_field(EFFECT_FIELD_DOUBLE, "amount");
amount_val->set_double_minimum_value(0); amount_val->set_double_minimum_value(0);
amount_val->set_double_maximum_value(100); amount_val->set_double_maximum_value(100);
amount_val->set_double_default_value(20); amount_val->set_double_default_value(20);
mix_val = add_row("Mix:")->add_field(EFFECT_FIELD_BOOL, "mix"); mix_val = add_row("Mix")->add_field(EFFECT_FIELD_BOOL, "mix");
mix_val->set_bool_value(true); mix_val->set_bool_value(true);
srand(QDateTime::currentMSecsSinceEpoch()); srand(QDateTime::currentMSecsSinceEpoch());
} }
void AudioNoiseEffect::process_audio(double timecode_start, double timecode_end, quint8 *samples, int nb_bytes, int) { void AudioNoiseEffect::process_audio(double timecode_start, double timecode_end, quint8 *samples, int nb_bytes, int) {
+39 -39
View File
@@ -5,59 +5,59 @@
#include "debug.h" #include "debug.h"
CornerPinEffect::CornerPinEffect(Clip *c, const EffectMeta *em) : Effect(c, em) { CornerPinEffect::CornerPinEffect(Clip *c, const EffectMeta *em) : Effect(c, em) {
enable_coords = true; enable_coords = true;
enable_shader = true; enable_shader = true;
EffectRow* top_left = add_row("Top Left:"); EffectRow* top_left = add_row("Top Left");
top_left_x = top_left->add_field(EFFECT_FIELD_DOUBLE, "topleftx"); top_left_x = top_left->add_field(EFFECT_FIELD_DOUBLE, "topleftx");
top_left_y = top_left->add_field(EFFECT_FIELD_DOUBLE, "toplefty"); top_left_y = top_left->add_field(EFFECT_FIELD_DOUBLE, "toplefty");
EffectRow* top_right = add_row("Top Right:"); EffectRow* top_right = add_row("Top Right");
top_right_x = top_right->add_field(EFFECT_FIELD_DOUBLE, "toprightx"); top_right_x = top_right->add_field(EFFECT_FIELD_DOUBLE, "toprightx");
top_right_y = top_right->add_field(EFFECT_FIELD_DOUBLE, "toprighty"); top_right_y = top_right->add_field(EFFECT_FIELD_DOUBLE, "toprighty");
EffectRow* bottom_left = add_row("Bottom Left:"); EffectRow* bottom_left = add_row("Bottom Left");
bottom_left_x = bottom_left->add_field(EFFECT_FIELD_DOUBLE, "bottomleftx"); bottom_left_x = bottom_left->add_field(EFFECT_FIELD_DOUBLE, "bottomleftx");
bottom_left_y = bottom_left->add_field(EFFECT_FIELD_DOUBLE, "bottomlefty"); bottom_left_y = bottom_left->add_field(EFFECT_FIELD_DOUBLE, "bottomlefty");
EffectRow* bottom_right = add_row("Bottom Right:"); EffectRow* bottom_right = add_row("Bottom Right");
bottom_right_x = bottom_right->add_field(EFFECT_FIELD_DOUBLE, "bottomrightx"); bottom_right_x = bottom_right->add_field(EFFECT_FIELD_DOUBLE, "bottomrightx");
bottom_right_y = bottom_right->add_field(EFFECT_FIELD_DOUBLE, "bottomrighty"); bottom_right_y = bottom_right->add_field(EFFECT_FIELD_DOUBLE, "bottomrighty");
perspective = add_row("Perspective:")->add_field(EFFECT_FIELD_BOOL, "perspective"); perspective = add_row("Perspective")->add_field(EFFECT_FIELD_BOOL, "perspective");
perspective->set_bool_value(true); perspective->set_bool_value(true);
top_left_gizmo = add_gizmo(GIZMO_TYPE_DOT); top_left_gizmo = add_gizmo(GIZMO_TYPE_DOT);
top_left_gizmo->x_field1 = top_left_x; top_left_gizmo->x_field1 = top_left_x;
top_left_gizmo->y_field1 = top_left_y; top_left_gizmo->y_field1 = top_left_y;
top_right_gizmo = add_gizmo(GIZMO_TYPE_DOT); top_right_gizmo = add_gizmo(GIZMO_TYPE_DOT);
top_right_gizmo->x_field1 = top_right_x; top_right_gizmo->x_field1 = top_right_x;
top_right_gizmo->y_field1 = top_right_y; top_right_gizmo->y_field1 = top_right_y;
bottom_left_gizmo = add_gizmo(GIZMO_TYPE_DOT); bottom_left_gizmo = add_gizmo(GIZMO_TYPE_DOT);
bottom_left_gizmo->x_field1 = bottom_left_x; bottom_left_gizmo->x_field1 = bottom_left_x;
bottom_left_gizmo->y_field1 = bottom_left_y; bottom_left_gizmo->y_field1 = bottom_left_y;
bottom_right_gizmo = add_gizmo(GIZMO_TYPE_DOT); bottom_right_gizmo = add_gizmo(GIZMO_TYPE_DOT);
bottom_right_gizmo->x_field1 = bottom_right_x; bottom_right_gizmo->x_field1 = bottom_right_x;
bottom_right_gizmo->y_field1 = bottom_right_y; bottom_right_gizmo->y_field1 = bottom_right_y;
vertPath = "cornerpin.vert"; vertPath = "cornerpin.vert";
fragPath = "cornerpin.frag"; fragPath = "cornerpin.frag";
} }
void CornerPinEffect::process_coords(double timecode, GLTextureCoords &coords, int data) { void CornerPinEffect::process_coords(double timecode, GLTextureCoords &coords, int data) {
coords.vertexTopLeftX += top_left_x->get_double_value(timecode); coords.vertexTopLeftX += top_left_x->get_double_value(timecode);
coords.vertexTopLeftY += top_left_y->get_double_value(timecode); coords.vertexTopLeftY += top_left_y->get_double_value(timecode);
coords.vertexTopRightX += top_right_x->get_double_value(timecode); coords.vertexTopRightX += top_right_x->get_double_value(timecode);
coords.vertexTopRightY += top_right_y->get_double_value(timecode); coords.vertexTopRightY += top_right_y->get_double_value(timecode);
coords.vertexBottomLeftX += bottom_left_x->get_double_value(timecode); coords.vertexBottomLeftX += bottom_left_x->get_double_value(timecode);
coords.vertexBottomLeftY += bottom_left_y->get_double_value(timecode); coords.vertexBottomLeftY += bottom_left_y->get_double_value(timecode);
coords.vertexBottomRightX += bottom_right_x->get_double_value(timecode); coords.vertexBottomRightX += bottom_right_x->get_double_value(timecode);
coords.vertexBottomRightY += bottom_right_y->get_double_value(timecode); coords.vertexBottomRightY += bottom_right_y->get_double_value(timecode);
} }
@@ -66,12 +66,12 @@ void CornerPinEffect::process_shader(double timecode, GLTextureCoords &coords) {
glslProgram->setUniformValue("p1", (GLfloat) coords.vertexBottomRightX, (GLfloat) coords.vertexBottomRightY); glslProgram->setUniformValue("p1", (GLfloat) coords.vertexBottomRightX, (GLfloat) coords.vertexBottomRightY);
glslProgram->setUniformValue("p2", (GLfloat) coords.vertexTopLeftX, (GLfloat) coords.vertexTopLeftY); glslProgram->setUniformValue("p2", (GLfloat) coords.vertexTopLeftX, (GLfloat) coords.vertexTopLeftY);
glslProgram->setUniformValue("p3", (GLfloat) coords.vertexTopRightX, (GLfloat) coords.vertexTopRightY); glslProgram->setUniformValue("p3", (GLfloat) coords.vertexTopRightX, (GLfloat) coords.vertexTopRightY);
glslProgram->setUniformValue("perspective", perspective->get_bool_value(timecode)); glslProgram->setUniformValue("perspective", perspective->get_bool_value(timecode));
} }
void CornerPinEffect::gizmo_draw(double timecode, GLTextureCoords &coords) { void CornerPinEffect::gizmo_draw(double timecode, GLTextureCoords &coords) {
top_left_gizmo->world_pos[0] = QPoint(coords.vertexTopLeftX, coords.vertexTopLeftY); top_left_gizmo->world_pos[0] = QPoint(coords.vertexTopLeftX, coords.vertexTopLeftY);
top_right_gizmo->world_pos[0] = QPoint(coords.vertexTopRightX, coords.vertexTopRightY); top_right_gizmo->world_pos[0] = QPoint(coords.vertexTopRightX, coords.vertexTopRightY);
bottom_right_gizmo->world_pos[0] = QPoint(coords.vertexBottomRightX, coords.vertexBottomRightY); bottom_right_gizmo->world_pos[0] = QPoint(coords.vertexBottomRightX, coords.vertexBottomRightY);
bottom_left_gizmo->world_pos[0] = QPoint(coords.vertexBottomLeftX, coords.vertexBottomLeftY); bottom_left_gizmo->world_pos[0] = QPoint(coords.vertexBottomLeftX, coords.vertexBottomLeftY);
} }
+4 -4
View File
@@ -9,13 +9,13 @@
#include "ui/collapsiblewidget.h" #include "ui/collapsiblewidget.h"
PanEffect::PanEffect(Clip* c, const EffectMeta *em) : Effect(c, em) { PanEffect::PanEffect(Clip* c, const EffectMeta *em) : Effect(c, em) {
EffectRow* pan_row = add_row("Pan:"); EffectRow* pan_row = add_row("Pan");
pan_val = pan_row->add_field(EFFECT_FIELD_DOUBLE, "pan"); pan_val = pan_row->add_field(EFFECT_FIELD_DOUBLE, "pan");
pan_val->set_double_minimum_value(-100); pan_val->set_double_minimum_value(-100);
pan_val->set_double_maximum_value(100); pan_val->set_double_maximum_value(100);
// set defaults // set defaults
pan_val->set_double_default_value(0); pan_val->set_double_default_value(0);
} }
void PanEffect::process_audio(double timecode_start, double timecode_end, quint8* samples, int nb_bytes, int) { void PanEffect::process_audio(double timecode_start, double timecode_end, quint8* samples, int nb_bytes, int) {
+7 -7
View File
@@ -16,19 +16,19 @@
ShakeEffect::ShakeEffect(Clip *c, const EffectMeta *em) : Effect(c, em) { ShakeEffect::ShakeEffect(Clip *c, const EffectMeta *em) : Effect(c, em) {
enable_coords = true; enable_coords = true;
EffectRow* intensity_row = add_row("Intensity:"); EffectRow* intensity_row = add_row("Intensity");
intensity_val = intensity_row->add_field(EFFECT_FIELD_DOUBLE, "intensity"); intensity_val = intensity_row->add_field(EFFECT_FIELD_DOUBLE, "intensity");
intensity_val->set_double_minimum_value(0); intensity_val->set_double_minimum_value(0);
EffectRow* rotation_row = add_row("Rotation:"); EffectRow* rotation_row = add_row("Rotation");
rotation_val = rotation_row->add_field(EFFECT_FIELD_DOUBLE, "rotation"); rotation_val = rotation_row->add_field(EFFECT_FIELD_DOUBLE, "rotation");
rotation_val->set_double_minimum_value(0); rotation_val->set_double_minimum_value(0);
EffectRow* frequency_row = add_row("Frequency:"); EffectRow* frequency_row = add_row("Frequency");
frequency_val = frequency_row->add_field(EFFECT_FIELD_DOUBLE, "frequency"); frequency_val = frequency_row->add_field(EFFECT_FIELD_DOUBLE, "frequency");
frequency_val->set_double_minimum_value(0); frequency_val->set_double_minimum_value(0);
// set defaults // set defaults
intensity_val->set_double_default_value(25); intensity_val->set_double_default_value(25);
rotation_val->set_double_default_value(10); rotation_val->set_double_default_value(10);
frequency_val->set_double_default_value(5); frequency_val->set_double_default_value(5);
+45 -45
View File
@@ -21,36 +21,36 @@
SolidEffect::SolidEffect(Clip* c, const EffectMeta* em) : Effect(c, em) { SolidEffect::SolidEffect(Clip* c, const EffectMeta* em) : Effect(c, em) {
enable_superimpose = true; enable_superimpose = true;
solid_type = add_row("Type:")->add_field(EFFECT_FIELD_COMBO, "type"); solid_type = add_row("Type")->add_field(EFFECT_FIELD_COMBO, "type");
solid_type->add_combo_item("Solid Color", SOLID_TYPE_COLOR); solid_type->add_combo_item("Solid Color", SOLID_TYPE_COLOR);
solid_type->add_combo_item("SMPTE Bars", SOLID_TYPE_BARS); solid_type->add_combo_item("SMPTE Bars", SOLID_TYPE_BARS);
solid_type->add_combo_item("Checkerboard", SOLID_TYPE_CHECKERBOARD); solid_type->add_combo_item("Checkerboard", SOLID_TYPE_CHECKERBOARD);
opacity_field = add_row("Opacity:")->add_field(EFFECT_FIELD_DOUBLE, "opacity"); opacity_field = add_row("Opacity")->add_field(EFFECT_FIELD_DOUBLE, "opacity");
opacity_field->set_double_minimum_value(0); opacity_field->set_double_minimum_value(0);
opacity_field->set_double_maximum_value(100); opacity_field->set_double_maximum_value(100);
opacity_field->set_double_default_value(100); opacity_field->set_double_default_value(100);
solid_color_field = add_row("Color:")->add_field(EFFECT_FIELD_COLOR, "color"); solid_color_field = add_row("Color")->add_field(EFFECT_FIELD_COLOR, "color");
solid_color_field->set_color_value(Qt::red); solid_color_field->set_color_value(Qt::red);
checkerboard_size_field = add_row("Checkerboard Size:")->add_field(EFFECT_FIELD_DOUBLE, "checker_size"); checkerboard_size_field = add_row("Checkerboard Size")->add_field(EFFECT_FIELD_DOUBLE, "checker_size");
checkerboard_size_field->set_double_minimum_value(1); checkerboard_size_field->set_double_minimum_value(1);
checkerboard_size_field->set_double_default_value(10); checkerboard_size_field->set_double_default_value(10);
// hacky but eh // hacky but eh
QComboBox* solid_type_combo = static_cast<QComboBox*>(solid_type->get_ui_element()); QComboBox* solid_type_combo = static_cast<QComboBox*>(solid_type->get_ui_element());
connect(solid_type_combo, SIGNAL(currentIndexChanged(int)), this, SLOT(ui_update(int))); connect(solid_type_combo, SIGNAL(currentIndexChanged(int)), this, SLOT(ui_update(int)));
ui_update(solid_type_combo->currentIndex()); ui_update(solid_type_combo->currentIndex());
/*vertPath = ":/shaders/common.vert"; /*vertPath = ":/shaders/common.vert";
fragPath = ":/shaders/solideffect.frag";*/ fragPath = ":/shaders/solideffect.frag";*/
} }
void SolidEffect::redraw(double timecode) { void SolidEffect::redraw(double timecode) {
int w = img.width(); int w = img.width();
int h = img.height(); int h = img.height();
int alpha = qRound(opacity_field->get_double_value(timecode)*2.55); int alpha = qRound(opacity_field->get_double_value(timecode)*2.55);
switch (solid_type->get_combo_data(timecode).toInt()) { switch (solid_type->get_combo_data(timecode).toInt()) {
case SOLID_TYPE_COLOR: case SOLID_TYPE_COLOR:
{ {
@@ -141,37 +141,37 @@ void SolidEffect::redraw(double timecode) {
third_color.setAlpha(alpha); third_color.setAlpha(alpha);
p.fillRect(QRect(bar_x, third_bar_y, third_bar_width, third_bar_height), third_color); p.fillRect(QRect(bar_x, third_bar_y, third_bar_width, third_bar_height), third_color);
} }
} }
break; break;
case SOLID_TYPE_CHECKERBOARD: case SOLID_TYPE_CHECKERBOARD:
{ {
// draw checkboard // draw checkboard
QPainter p(&img); QPainter p(&img);
img.fill(Qt::transparent); img.fill(Qt::transparent);
int checker_width = qCeil(checkerboard_size_field->get_double_value(timecode)); int checker_width = qCeil(checkerboard_size_field->get_double_value(timecode));
int checker_x, checker_y; int checker_x, checker_y;
int checkerboard_size_w = qCeil(double(w)/checker_width); int checkerboard_size_w = qCeil(double(w)/checker_width);
int checkerboard_size_h = qCeil(double(h)/checker_width); int checkerboard_size_h = qCeil(double(h)/checker_width);
QColor checker_odd(QColor(0, 0, 0, alpha)); QColor checker_odd(QColor(0, 0, 0, alpha));
QColor checker_even(solid_color_field->get_color_value(timecode)); QColor checker_even(solid_color_field->get_color_value(timecode));
checker_even.setAlpha(alpha); checker_even.setAlpha(alpha);
QVector<QColor> checker_color{checker_odd, checker_even}; QVector<QColor> checker_color{checker_odd, checker_even};
for(int i = 0; i < checkerboard_size_w; i++){ for(int i = 0; i < checkerboard_size_w; i++){
checker_x = checker_width*i; checker_x = checker_width*i;
for(int j = 0; j < checkerboard_size_h; j++){ for(int j = 0; j < checkerboard_size_h; j++){
checker_y = checker_width*j; checker_y = checker_width*j;
p.fillRect(QRect(checker_x, checker_y, checker_width, checker_width), checker_color[(i + j)%2]); p.fillRect(QRect(checker_x, checker_y, checker_width, checker_width), checker_color[(i + j)%2]);
} }
} }
} }
break; break;
} }
} }
void SolidEffect::ui_update(int i) { void SolidEffect::ui_update(int i) {
solid_color_field->set_enabled(i == SOLID_TYPE_COLOR || i == SOLID_TYPE_CHECKERBOARD); solid_color_field->set_enabled(i == SOLID_TYPE_COLOR || i == SOLID_TYPE_CHECKERBOARD);
checkerboard_size_field->set_enabled(i == SOLID_TYPE_CHECKERBOARD); checkerboard_size_field->set_enabled(i == SOLID_TYPE_CHECKERBOARD);
} }
+25 -25
View File
@@ -24,43 +24,43 @@ TextEffect::TextEffect(Clip *c, const EffectMeta* em) :
Effect(c, em) Effect(c, em)
{ {
enable_superimpose = true; enable_superimpose = true;
enable_shader = true; enable_shader = true;
text_val = add_row("Text:")->add_field(EFFECT_FIELD_STRING, "text", 2); text_val = add_row("Text")->add_field(EFFECT_FIELD_STRING, "text", 2);
set_font_combobox = add_row("Font:")->add_field(EFFECT_FIELD_FONT, "font", 2); set_font_combobox = add_row("Font")->add_field(EFFECT_FIELD_FONT, "font", 2);
size_val = add_row("Size:")->add_field(EFFECT_FIELD_DOUBLE, "size", 2); size_val = add_row("Size")->add_field(EFFECT_FIELD_DOUBLE, "size", 2);
size_val->set_double_minimum_value(0); size_val->set_double_minimum_value(0);
set_color_button = add_row("Color:")->add_field(EFFECT_FIELD_COLOR, "color", 2); set_color_button = add_row("Color")->add_field(EFFECT_FIELD_COLOR, "color", 2);
EffectRow* alignment_row = add_row("Alignment:"); EffectRow* alignment_row = add_row("Alignment");
halign_field = alignment_row->add_field(EFFECT_FIELD_COMBO, "halign"); halign_field = alignment_row->add_field(EFFECT_FIELD_COMBO, "halign");
halign_field->add_combo_item("Left", Qt::AlignLeft); halign_field->add_combo_item("Left", Qt::AlignLeft);
halign_field->add_combo_item("Center", Qt::AlignHCenter); halign_field->add_combo_item("Center", Qt::AlignHCenter);
halign_field->add_combo_item("Right", Qt::AlignRight); halign_field->add_combo_item("Right", Qt::AlignRight);
halign_field->add_combo_item("Justify", Qt::AlignJustify); halign_field->add_combo_item("Justify", Qt::AlignJustify);
valign_field = alignment_row->add_field(EFFECT_FIELD_COMBO, "valign"); valign_field = alignment_row->add_field(EFFECT_FIELD_COMBO, "valign");
valign_field->add_combo_item("Top", Qt::AlignTop); valign_field->add_combo_item("Top", Qt::AlignTop);
valign_field->add_combo_item("Center", Qt::AlignVCenter); valign_field->add_combo_item("Center", Qt::AlignVCenter);
valign_field->add_combo_item("Bottom", Qt::AlignBottom); valign_field->add_combo_item("Bottom", Qt::AlignBottom);
word_wrap_field = add_row("Word Wrap:")->add_field(EFFECT_FIELD_BOOL, "wordwrap", 2); word_wrap_field = add_row("Word Wrap")->add_field(EFFECT_FIELD_BOOL, "wordwrap", 2);
outline_bool = add_row("Outline:")->add_field(EFFECT_FIELD_BOOL, "outline", 2); outline_bool = add_row("Outline")->add_field(EFFECT_FIELD_BOOL, "outline", 2);
outline_color = add_row("Outline Color:")->add_field(EFFECT_FIELD_COLOR, "outlinecolor", 2); outline_color = add_row("Outline Color")->add_field(EFFECT_FIELD_COLOR, "outlinecolor", 2);
outline_width = add_row("Outline Width:")->add_field(EFFECT_FIELD_DOUBLE, "outlinewidth", 2); outline_width = add_row("Outline Width")->add_field(EFFECT_FIELD_DOUBLE, "outlinewidth", 2);
outline_width->set_double_minimum_value(0); outline_width->set_double_minimum_value(0);
shadow_bool = add_row("Shadow:")->add_field(EFFECT_FIELD_BOOL, "shadow", 2); shadow_bool = add_row("Shadow")->add_field(EFFECT_FIELD_BOOL, "shadow", 2);
shadow_color = add_row("Shadow Color:")->add_field(EFFECT_FIELD_COLOR, "shadowcolor", 2); shadow_color = add_row("Shadow Color")->add_field(EFFECT_FIELD_COLOR, "shadowcolor", 2);
shadow_distance = add_row("Shadow Distance:")->add_field(EFFECT_FIELD_DOUBLE, "shadowdistance", 2); shadow_distance = add_row("Shadow Distance")->add_field(EFFECT_FIELD_DOUBLE, "shadowdistance", 2);
shadow_distance->set_double_minimum_value(0); shadow_distance->set_double_minimum_value(0);
shadow_softness = add_row("Shadow Softness:")->add_field(EFFECT_FIELD_DOUBLE, "shadowsoftness", 2); shadow_softness = add_row("Shadow Softness")->add_field(EFFECT_FIELD_DOUBLE, "shadowsoftness", 2);
shadow_softness->set_double_minimum_value(0); shadow_softness->set_double_minimum_value(0);
shadow_opacity = add_row("Shadow Opacity:")->add_field(EFFECT_FIELD_DOUBLE, "shadowopacity", 2); shadow_opacity = add_row("Shadow Opacity")->add_field(EFFECT_FIELD_DOUBLE, "shadowopacity", 2);
shadow_opacity->set_double_minimum_value(0); shadow_opacity->set_double_minimum_value(0);
shadow_opacity->set_double_maximum_value(100); shadow_opacity->set_double_maximum_value(100);
@@ -78,13 +78,13 @@ TextEffect::TextEffect(Clip *c, const EffectMeta* em) :
outline_width->set_double_default_value(20); outline_width->set_double_default_value(20);
outline_enable(false); outline_enable(false);
shadow_enable(false); shadow_enable(false);
connect(shadow_bool, SIGNAL(toggled(bool)), this, SLOT(shadow_enable(bool))); connect(shadow_bool, SIGNAL(toggled(bool)), this, SLOT(shadow_enable(bool)));
connect(outline_bool, SIGNAL(toggled(bool)), this, SLOT(outline_enable(bool))); connect(outline_bool, SIGNAL(toggled(bool)), this, SLOT(outline_enable(bool)));
vertPath = "common.vert"; vertPath = "common.vert";
fragPath = "dropshadow.frag"; fragPath = "dropshadow.frag";
} }
void TextEffect::redraw(double timecode) { void TextEffect::redraw(double timecode) {
@@ -170,7 +170,7 @@ void TextEffect::redraw(double timecode) {
} }
path.addText(text_x, text_y, font, lines.at(i)); path.addText(text_x, text_y, font, lines.at(i));
} }
// draw outline // draw outline
int outline_width_val = outline_width->get_double_value(timecode); int outline_width_val = outline_width->get_double_value(timecode);
@@ -185,7 +185,7 @@ void TextEffect::redraw(double timecode) {
// draw "master" text // draw "master" text
p.setPen(Qt::NoPen); p.setPen(Qt::NoPen);
p.setBrush(set_color_button->get_color_value(timecode)); p.setBrush(set_color_button->get_color_value(timecode));
p.drawPath(path); p.drawPath(path);
} }
void TextEffect::shadow_enable(bool e) { void TextEffect::shadow_enable(bool e) {
+51 -51
View File
@@ -24,82 +24,82 @@
#include "playback/playback.h" #include "playback/playback.h"
TimecodeEffect::TimecodeEffect(Clip *c, const EffectMeta* em) : TimecodeEffect::TimecodeEffect(Clip *c, const EffectMeta* em) :
Effect(c, em) Effect(c, em)
{ {
enable_always_update = true; enable_always_update = true;
enable_superimpose = true; enable_superimpose = true;
EffectRow* tc_row = add_row("Timecode:"); EffectRow* tc_row = add_row("Timecode");
tc_select = tc_row->add_field(EFFECT_FIELD_COMBO, "tc_selector"); tc_select = tc_row->add_field(EFFECT_FIELD_COMBO, "tc_selector");
tc_select->add_combo_item("Sequence", true); tc_select->add_combo_item("Sequence", true);
tc_select->add_combo_item("Media", false); tc_select->add_combo_item("Media", false);
tc_select->set_combo_index(0); tc_select->set_combo_index(0);
scale_val = add_row("Scale:")->add_field(EFFECT_FIELD_DOUBLE, "scale", 2); scale_val = add_row("Scale")->add_field(EFFECT_FIELD_DOUBLE, "scale", 2);
scale_val->set_double_minimum_value(1); scale_val->set_double_minimum_value(1);
scale_val->set_double_default_value(100); scale_val->set_double_default_value(100);
scale_val->set_double_maximum_value(1000); scale_val->set_double_maximum_value(1000);
color_val = add_row("Color:")->add_field(EFFECT_FIELD_COLOR, "color", 2); color_val = add_row("Color")->add_field(EFFECT_FIELD_COLOR, "color", 2);
color_val->set_color_value(Qt::white); color_val->set_color_value(Qt::white);
color_bg_val = add_row("Background Color:")->add_field(EFFECT_FIELD_COLOR, "bgcolor", 2); color_bg_val = add_row("Background Color")->add_field(EFFECT_FIELD_COLOR, "bgcolor", 2);
color_bg_val->set_color_value(Qt::black); color_bg_val->set_color_value(Qt::black);
bg_alpha = add_row("Background Opacity:")->add_field(EFFECT_FIELD_DOUBLE, "bgalpha", 2); bg_alpha = add_row("Background Opacity")->add_field(EFFECT_FIELD_DOUBLE, "bgalpha", 2);
bg_alpha->set_double_minimum_value(0); bg_alpha->set_double_minimum_value(0);
bg_alpha->set_double_maximum_value(100); bg_alpha->set_double_maximum_value(100);
bg_alpha->set_double_default_value(50); bg_alpha->set_double_default_value(50);
EffectRow* offset = add_row("Offset:"); EffectRow* offset = add_row("Offset");
offset_x_val = offset->add_field(EFFECT_FIELD_DOUBLE, "offsetx"); offset_x_val = offset->add_field(EFFECT_FIELD_DOUBLE, "offsetx");
offset_y_val = offset->add_field(EFFECT_FIELD_DOUBLE, "offsety"); offset_y_val = offset->add_field(EFFECT_FIELD_DOUBLE, "offsety");
prepend_text = add_row("Prepend:")->add_field(EFFECT_FIELD_STRING, "prepend", 2); prepend_text = add_row("Prepend")->add_field(EFFECT_FIELD_STRING, "prepend", 2);
} }
void TimecodeEffect::redraw(double timecode) { void TimecodeEffect::redraw(double timecode) {
if (tc_select->get_combo_data(timecode).toBool()){ if (tc_select->get_combo_data(timecode).toBool()){
display_timecode = prepend_text->get_string_value(timecode) + frame_to_timecode(sequence->playhead, config.timecode_view, sequence->frame_rate);} display_timecode = prepend_text->get_string_value(timecode) + frame_to_timecode(sequence->playhead, config.timecode_view, sequence->frame_rate);}
else { else {
double media_rate = parent_clip->getMediaFrameRate(); double media_rate = parent_clip->getMediaFrameRate();
display_timecode = prepend_text->get_string_value(timecode) + frame_to_timecode(timecode * media_rate, config.timecode_view, media_rate);} display_timecode = prepend_text->get_string_value(timecode) + frame_to_timecode(timecode * media_rate, config.timecode_view, media_rate);}
img.fill(Qt::transparent); img.fill(Qt::transparent);
QPainter p(&img); QPainter p(&img);
p.setRenderHint(QPainter::Antialiasing); p.setRenderHint(QPainter::Antialiasing);
int width = img.width(); int width = img.width();
int height = img.height(); int height = img.height();
// set font // set font
font.setStyleHint(QFont::Helvetica, QFont::PreferAntialias); font.setStyleHint(QFont::Helvetica, QFont::PreferAntialias);
font.setFamily("Helvetica"); font.setFamily("Helvetica");
font.setPixelSize(qCeil(scale_val->get_double_value(timecode)*.01*(height/10))); font.setPixelSize(qCeil(scale_val->get_double_value(timecode)*.01*(height/10)));
p.setFont(font); p.setFont(font);
QFontMetrics fm(font); QFontMetrics fm(font);
QPainterPath path; QPainterPath path;
int text_x, text_y, rect_y, offset_x, offset_y; int text_x, text_y, rect_y, offset_x, offset_y;
int text_height = fm.height(); int text_height = fm.height();
int text_width = fm.width(display_timecode); int text_width = fm.width(display_timecode);
QColor background_color = color_bg_val->get_color_value(timecode); QColor background_color = color_bg_val->get_color_value(timecode);
int alpha_val = bg_alpha->get_double_value(timecode)*2.55; int alpha_val = bg_alpha->get_double_value(timecode)*2.55;
background_color.setAlpha(alpha_val); background_color.setAlpha(alpha_val);
offset_x = int(offset_x_val->get_double_value(timecode)); offset_x = int(offset_x_val->get_double_value(timecode));
offset_y = int(offset_y_val->get_double_value(timecode)); offset_y = int(offset_y_val->get_double_value(timecode));
text_x = offset_x + (width/2) - (text_width/2); text_x = offset_x + (width/2) - (text_width/2);
text_y = offset_y + height - height/10; text_y = offset_y + height - height/10;
rect_y = text_y + fm.descent()/2 - text_height; rect_y = text_y + fm.descent()/2 - text_height;
path.addText(text_x, text_y, font, display_timecode); path.addText(text_x, text_y, font, display_timecode);
p.setPen(Qt::NoPen); p.setPen(Qt::NoPen);
p.setBrush(background_color); p.setBrush(background_color);
p.drawRect(QRect(text_x-fm.descent()/2, rect_y, text_width+fm.descent(), text_height)); p.drawRect(QRect(text_x-fm.descent()/2, rect_y, text_width+fm.descent(), text_height));
p.setBrush(color_val->get_color_value(timecode)); p.setBrush(color_val->get_color_value(timecode));
p.drawPath(path); p.drawPath(path);
} }
+5 -5
View File
@@ -9,21 +9,21 @@
#include "debug.h" #include "debug.h"
ToneEffect::ToneEffect(Clip* c, const EffectMeta *em) : Effect(c, em), sinX(INT_MIN) { ToneEffect::ToneEffect(Clip* c, const EffectMeta *em) : Effect(c, em), sinX(INT_MIN) {
type_val = add_row("Type:")->add_field(EFFECT_FIELD_COMBO, "type"); type_val = add_row("Type")->add_field(EFFECT_FIELD_COMBO, "type");
type_val->add_combo_item("Sine", TONE_TYPE_SINE); type_val->add_combo_item("Sine", TONE_TYPE_SINE);
freq_val = add_row("Frequency:")->add_field(EFFECT_FIELD_DOUBLE, "frequency"); freq_val = add_row("Frequency")->add_field(EFFECT_FIELD_DOUBLE, "frequency");
freq_val->set_double_minimum_value(20); freq_val->set_double_minimum_value(20);
freq_val->set_double_maximum_value(20000); freq_val->set_double_maximum_value(20000);
freq_val->set_double_default_value(1000); freq_val->set_double_default_value(1000);
amount_val = add_row("Amount:")->add_field(EFFECT_FIELD_DOUBLE, "amount"); amount_val = add_row("Amount")->add_field(EFFECT_FIELD_DOUBLE, "amount");
amount_val->set_double_minimum_value(0); amount_val->set_double_minimum_value(0);
amount_val->set_double_maximum_value(100); amount_val->set_double_maximum_value(100);
amount_val->set_double_default_value(25); amount_val->set_double_default_value(25);
mix_val = add_row("Mix:")->add_field(EFFECT_FIELD_BOOL, "mix"); mix_val = add_row("Mix")->add_field(EFFECT_FIELD_BOOL, "mix");
mix_val->set_bool_value(true); mix_val->set_bool_value(true);
} }
void ToneEffect::process_audio(double timecode_start, double timecode_end, quint8 *samples, int nb_bytes, int) { void ToneEffect::process_audio(double timecode_start, double timecode_end, quint8 *samples, int nb_bytes, int) {
+115 -115
View File
@@ -28,104 +28,104 @@
#define BLEND_MODE_MULTIPLY 2 #define BLEND_MODE_MULTIPLY 2
#define BLEND_MODE_OVERLAY 3 #define BLEND_MODE_OVERLAY 3
TransformEffect::TransformEffect(Clip* c, const EffectMeta* em) : Effect(c, em) { TransformEffect::TransformEffect(Clip* c, const EffectMeta* em) : Effect(c, em) {
enable_coords = true; enable_coords = true;
EffectRow* position_row = add_row("Position:"); EffectRow* position_row = add_row("Position");
position_x = position_row->add_field(EFFECT_FIELD_DOUBLE, "posx"); // position X position_x = position_row->add_field(EFFECT_FIELD_DOUBLE, "posx"); // position X
position_y = position_row->add_field(EFFECT_FIELD_DOUBLE, "posy"); // position Y position_y = position_row->add_field(EFFECT_FIELD_DOUBLE, "posy"); // position Y
EffectRow* scale_row = add_row("Scale:"); EffectRow* scale_row = add_row("Scale");
scale_x = scale_row->add_field(EFFECT_FIELD_DOUBLE, "scalex"); // scale X (and Y is uniform scale is selected) scale_x = scale_row->add_field(EFFECT_FIELD_DOUBLE, "scalex"); // scale X (and Y is uniform scale is selected)
scale_x->set_double_minimum_value(0); scale_x->set_double_minimum_value(0);
scale_x->set_double_maximum_value(3000); scale_x->set_double_maximum_value(3000);
scale_y = scale_row->add_field(EFFECT_FIELD_DOUBLE, "scaley"); // scale Y (disabled if uniform scale is selected) scale_y = scale_row->add_field(EFFECT_FIELD_DOUBLE, "scaley"); // scale Y (disabled if uniform scale is selected)
scale_y->set_double_minimum_value(0); scale_y->set_double_minimum_value(0);
scale_y->set_double_maximum_value(3000); scale_y->set_double_maximum_value(3000);
EffectRow* uniform_scale_row = add_row("Uniform Scale:"); EffectRow* uniform_scale_row = add_row("Uniform Scale");
uniform_scale_field = uniform_scale_row->add_field(EFFECT_FIELD_BOOL, "uniformscale"); // uniform scale option uniform_scale_field = uniform_scale_row->add_field(EFFECT_FIELD_BOOL, "uniformscale"); // uniform scale option
EffectRow* rotation_row = add_row("Rotation:"); EffectRow* rotation_row = add_row("Rotation");
rotation = rotation_row->add_field(EFFECT_FIELD_DOUBLE, "rotation"); rotation = rotation_row->add_field(EFFECT_FIELD_DOUBLE, "rotation");
EffectRow* anchor_point_row = add_row("Anchor Point:"); EffectRow* anchor_point_row = add_row("Anchor Point");
anchor_x_box = anchor_point_row->add_field(EFFECT_FIELD_DOUBLE, "anchorx"); // anchor point X anchor_x_box = anchor_point_row->add_field(EFFECT_FIELD_DOUBLE, "anchorx"); // anchor point X
anchor_y_box = anchor_point_row->add_field(EFFECT_FIELD_DOUBLE, "anchory"); // anchor point Y anchor_y_box = anchor_point_row->add_field(EFFECT_FIELD_DOUBLE, "anchory"); // anchor point Y
EffectRow* opacity_row = add_row("Opacity:"); EffectRow* opacity_row = add_row("Opacity");
opacity = opacity_row->add_field(EFFECT_FIELD_DOUBLE, "opacity"); // opacity opacity = opacity_row->add_field(EFFECT_FIELD_DOUBLE, "opacity"); // opacity
opacity->set_double_minimum_value(0); opacity->set_double_minimum_value(0);
opacity->set_double_maximum_value(100); opacity->set_double_maximum_value(100);
EffectRow* blend_mode_row = add_row("Blend Mode:"); EffectRow* blend_mode_row = add_row("Blend Mode");
blend_mode_box = blend_mode_row->add_field(EFFECT_FIELD_COMBO, "blendmode"); // blend mode blend_mode_box = blend_mode_row->add_field(EFFECT_FIELD_COMBO, "blendmode"); // blend mode
blend_mode_box->add_combo_item("Normal", BLEND_MODE_NORMAL); blend_mode_box->add_combo_item("Normal", BLEND_MODE_NORMAL);
blend_mode_box->add_combo_item("Overlay", BLEND_MODE_OVERLAY); blend_mode_box->add_combo_item("Overlay", BLEND_MODE_OVERLAY);
blend_mode_box->add_combo_item("Screen", BLEND_MODE_SCREEN); blend_mode_box->add_combo_item("Screen", BLEND_MODE_SCREEN);
blend_mode_box->add_combo_item("Multiply", BLEND_MODE_MULTIPLY); blend_mode_box->add_combo_item("Multiply", BLEND_MODE_MULTIPLY);
// set up gizmos // set up gizmos
top_left_gizmo = add_gizmo(GIZMO_TYPE_DOT); top_left_gizmo = add_gizmo(GIZMO_TYPE_DOT);
top_left_gizmo->set_cursor(Qt::SizeFDiagCursor); top_left_gizmo->set_cursor(Qt::SizeFDiagCursor);
top_left_gizmo->x_field1 = scale_x; top_left_gizmo->x_field1 = scale_x;
top_center_gizmo = add_gizmo(GIZMO_TYPE_DOT); top_center_gizmo = add_gizmo(GIZMO_TYPE_DOT);
top_center_gizmo->set_cursor(Qt::SizeVerCursor); top_center_gizmo->set_cursor(Qt::SizeVerCursor);
top_center_gizmo->y_field1 = scale_x; top_center_gizmo->y_field1 = scale_x;
top_right_gizmo = add_gizmo(GIZMO_TYPE_DOT); top_right_gizmo = add_gizmo(GIZMO_TYPE_DOT);
top_right_gizmo->set_cursor(Qt::SizeBDiagCursor); top_right_gizmo->set_cursor(Qt::SizeBDiagCursor);
top_right_gizmo->x_field1 = scale_x; top_right_gizmo->x_field1 = scale_x;
bottom_left_gizmo = add_gizmo(GIZMO_TYPE_DOT); bottom_left_gizmo = add_gizmo(GIZMO_TYPE_DOT);
bottom_left_gizmo->set_cursor(Qt::SizeBDiagCursor); bottom_left_gizmo->set_cursor(Qt::SizeBDiagCursor);
bottom_left_gizmo->x_field1 = scale_x; bottom_left_gizmo->x_field1 = scale_x;
bottom_center_gizmo = add_gizmo(GIZMO_TYPE_DOT); bottom_center_gizmo = add_gizmo(GIZMO_TYPE_DOT);
bottom_center_gizmo->set_cursor(Qt::SizeVerCursor); bottom_center_gizmo->set_cursor(Qt::SizeVerCursor);
bottom_center_gizmo->y_field1 = scale_x; bottom_center_gizmo->y_field1 = scale_x;
bottom_right_gizmo = add_gizmo(GIZMO_TYPE_DOT); bottom_right_gizmo = add_gizmo(GIZMO_TYPE_DOT);
bottom_right_gizmo->set_cursor(Qt::SizeFDiagCursor); bottom_right_gizmo->set_cursor(Qt::SizeFDiagCursor);
bottom_right_gizmo->x_field1 = scale_x; bottom_right_gizmo->x_field1 = scale_x;
left_center_gizmo = add_gizmo(GIZMO_TYPE_DOT); left_center_gizmo = add_gizmo(GIZMO_TYPE_DOT);
left_center_gizmo->set_cursor(Qt::SizeHorCursor); left_center_gizmo->set_cursor(Qt::SizeHorCursor);
left_center_gizmo->x_field1 = scale_x; left_center_gizmo->x_field1 = scale_x;
right_center_gizmo = add_gizmo(GIZMO_TYPE_DOT); right_center_gizmo = add_gizmo(GIZMO_TYPE_DOT);
right_center_gizmo->set_cursor(Qt::SizeHorCursor); right_center_gizmo->set_cursor(Qt::SizeHorCursor);
right_center_gizmo->x_field1 = scale_x; right_center_gizmo->x_field1 = scale_x;
anchor_gizmo = add_gizmo(GIZMO_TYPE_TARGET); anchor_gizmo = add_gizmo(GIZMO_TYPE_TARGET);
anchor_gizmo->set_cursor(Qt::SizeAllCursor); anchor_gizmo->set_cursor(Qt::SizeAllCursor);
anchor_gizmo->x_field1 = anchor_x_box; anchor_gizmo->x_field1 = anchor_x_box;
anchor_gizmo->y_field1 = anchor_y_box; anchor_gizmo->y_field1 = anchor_y_box;
anchor_gizmo->x_field2 = position_x; anchor_gizmo->x_field2 = position_x;
anchor_gizmo->y_field2 = position_y; anchor_gizmo->y_field2 = position_y;
rotate_gizmo = add_gizmo(GIZMO_TYPE_DOT); rotate_gizmo = add_gizmo(GIZMO_TYPE_DOT);
rotate_gizmo->color = Qt::green; rotate_gizmo->color = Qt::green;
rotate_gizmo->set_cursor(Qt::SizeAllCursor); rotate_gizmo->set_cursor(Qt::SizeAllCursor);
rotate_gizmo->x_field1 = rotation; rotate_gizmo->x_field1 = rotation;
rect_gizmo = add_gizmo(GIZMO_TYPE_POLY); rect_gizmo = add_gizmo(GIZMO_TYPE_POLY);
rect_gizmo->x_field1 = position_x; rect_gizmo->x_field1 = position_x;
rect_gizmo->y_field1 = position_y; rect_gizmo->y_field1 = position_y;
connect(uniform_scale_field, SIGNAL(toggled(bool)), this, SLOT(toggle_uniform_scale(bool))); connect(uniform_scale_field, SIGNAL(toggled(bool)), this, SLOT(toggle_uniform_scale(bool)));
// set defaults // set defaults
uniform_scale_field->set_bool_value(true); uniform_scale_field->set_bool_value(true);
blend_mode_box->set_combo_index(0); blend_mode_box->set_combo_index(0);
refresh(); refresh();
} }
void TransformEffect::refresh() { void TransformEffect::refresh() {
if (parent_clip != NULL && parent_clip->sequence != NULL) { if (parent_clip != NULL && parent_clip->sequence != NULL) {
double default_pos_x = parent_clip->sequence->width/2; double default_pos_x = parent_clip->sequence->width/2;
double default_pos_y = parent_clip->sequence->height/2; double default_pos_y = parent_clip->sequence->height/2;
position_x->set_double_default_value(default_pos_x); position_x->set_double_default_value(default_pos_x);
position_y->set_double_default_value(default_pos_y); position_y->set_double_default_value(default_pos_y);
@@ -140,35 +140,35 @@ void TransformEffect::refresh() {
anchor_x_box->set_double_default_value(default_anchor_x); anchor_x_box->set_double_default_value(default_anchor_x);
anchor_y_box->set_double_default_value(default_anchor_y); anchor_y_box->set_double_default_value(default_anchor_y);
opacity->set_double_default_value(100); opacity->set_double_default_value(100);
double x_percent_multipler = 200.0 / parent_clip->sequence->width; double x_percent_multipler = 200.0 / parent_clip->sequence->width;
double y_percent_multipler = 200.0 / parent_clip->sequence->height; double y_percent_multipler = 200.0 / parent_clip->sequence->height;
top_left_gizmo->x_field_multi1 = -x_percent_multipler; top_left_gizmo->x_field_multi1 = -x_percent_multipler;
top_left_gizmo->y_field_multi1 = -y_percent_multipler; top_left_gizmo->y_field_multi1 = -y_percent_multipler;
top_center_gizmo->y_field_multi1 = -y_percent_multipler; top_center_gizmo->y_field_multi1 = -y_percent_multipler;
top_right_gizmo->x_field_multi1 = x_percent_multipler; top_right_gizmo->x_field_multi1 = x_percent_multipler;
top_right_gizmo->y_field_multi1 = -y_percent_multipler; top_right_gizmo->y_field_multi1 = -y_percent_multipler;
bottom_left_gizmo->x_field_multi1 = -x_percent_multipler; bottom_left_gizmo->x_field_multi1 = -x_percent_multipler;
bottom_left_gizmo->y_field_multi1 = y_percent_multipler; bottom_left_gizmo->y_field_multi1 = y_percent_multipler;
bottom_center_gizmo->y_field_multi1 = y_percent_multipler; bottom_center_gizmo->y_field_multi1 = y_percent_multipler;
bottom_right_gizmo->x_field_multi1 = x_percent_multipler; bottom_right_gizmo->x_field_multi1 = x_percent_multipler;
bottom_right_gizmo->y_field_multi1 = y_percent_multipler; bottom_right_gizmo->y_field_multi1 = y_percent_multipler;
left_center_gizmo->x_field_multi1 = -x_percent_multipler; left_center_gizmo->x_field_multi1 = -x_percent_multipler;
right_center_gizmo->x_field_multi1 = x_percent_multipler; right_center_gizmo->x_field_multi1 = x_percent_multipler;
rotate_gizmo->x_field_multi1 = x_percent_multipler; rotate_gizmo->x_field_multi1 = x_percent_multipler;
} }
} }
void TransformEffect::toggle_uniform_scale(bool enabled) { void TransformEffect::toggle_uniform_scale(bool enabled) {
scale_y->set_enabled(!enabled); scale_y->set_enabled(!enabled);
top_center_gizmo->y_field1 = enabled ? scale_x : scale_y; top_center_gizmo->y_field1 = enabled ? scale_x : scale_y;
bottom_center_gizmo->y_field1 = enabled ? scale_x : scale_y; bottom_center_gizmo->y_field1 = enabled ? scale_x : scale_y;
top_left_gizmo->y_field1 = enabled ? NULL : scale_y; top_left_gizmo->y_field1 = enabled ? NULL : scale_y;
top_right_gizmo->y_field1 = enabled ? NULL : scale_y; top_right_gizmo->y_field1 = enabled ? NULL : scale_y;
bottom_left_gizmo->y_field1 = enabled ? NULL : scale_y; bottom_left_gizmo->y_field1 = enabled ? NULL : scale_y;
bottom_right_gizmo->y_field1 = enabled ? NULL : scale_y; bottom_right_gizmo->y_field1 = enabled ? NULL : scale_y;
} }
void TransformEffect::process_coords(double timecode, GLTextureCoords& coords, int data) { void TransformEffect::process_coords(double timecode, GLTextureCoords& coords, int data) {
@@ -188,51 +188,51 @@ void TransformEffect::process_coords(double timecode, GLTextureCoords& coords, i
coords.vertexBottomRightY -= anchor_y_offset; coords.vertexBottomRightY -= anchor_y_offset;
// rotation // rotation
glRotatef(rotation->get_double_value(timecode), 0, 0, 1); glRotatef(rotation->get_double_value(timecode), 0, 0, 1);
// scale // scale
float sx = scale_x->get_double_value(timecode)*0.01; float sx = scale_x->get_double_value(timecode)*0.01;
float sy = (uniform_scale_field->get_bool_value(timecode)) ? sx : scale_y->get_double_value(timecode)*0.01; float sy = (uniform_scale_field->get_bool_value(timecode)) ? sx : scale_y->get_double_value(timecode)*0.01;
glScalef(sx, sy, 1); glScalef(sx, sy, 1);
// blend mode // blend mode
switch (blend_mode_box->get_combo_data(timecode).toInt()) { switch (blend_mode_box->get_combo_data(timecode).toInt()) {
case BLEND_MODE_NORMAL: case BLEND_MODE_NORMAL:
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
break; break;
case BLEND_MODE_OVERLAY: case BLEND_MODE_OVERLAY:
glBlendFunc(GL_SRC_ALPHA, GL_ONE); glBlendFunc(GL_SRC_ALPHA, GL_ONE);
break; break;
case BLEND_MODE_SCREEN: case BLEND_MODE_SCREEN:
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_COLOR); glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_COLOR);
break; break;
case BLEND_MODE_MULTIPLY: case BLEND_MODE_MULTIPLY:
glBlendFunc(GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA);
break; break;
default: default:
dout << "[ERROR] Invalid blend mode. This is a bug - please contact developers"; dout << "[ERROR] Invalid blend mode. This is a bug - please contact developers";
} }
// opacity // opacity
float color[4]; float color[4];
glGetFloatv(GL_CURRENT_COLOR, color); glGetFloatv(GL_CURRENT_COLOR, color);
glColor4f(1.0, 1.0, 1.0, color[3]*(opacity->get_double_value(timecode)*0.01)); glColor4f(1.0, 1.0, 1.0, color[3]*(opacity->get_double_value(timecode)*0.01));
} }
void TransformEffect::gizmo_draw(double timecode, GLTextureCoords& coords) { void TransformEffect::gizmo_draw(double timecode, GLTextureCoords& coords) {
top_left_gizmo->world_pos[0] = QPoint(coords.vertexTopLeftX, coords.vertexTopLeftY); top_left_gizmo->world_pos[0] = QPoint(coords.vertexTopLeftX, coords.vertexTopLeftY);
top_center_gizmo->world_pos[0] = QPoint(lerp(coords.vertexTopLeftX, coords.vertexTopRightX, 0.5), lerp(coords.vertexTopLeftY, coords.vertexTopRightY, 0.5)); top_center_gizmo->world_pos[0] = QPoint(lerp(coords.vertexTopLeftX, coords.vertexTopRightX, 0.5), lerp(coords.vertexTopLeftY, coords.vertexTopRightY, 0.5));
top_right_gizmo->world_pos[0] = QPoint(coords.vertexTopRightX, coords.vertexTopRightY); top_right_gizmo->world_pos[0] = QPoint(coords.vertexTopRightX, coords.vertexTopRightY);
right_center_gizmo->world_pos[0] = QPoint(lerp(coords.vertexTopRightX, coords.vertexBottomRightX, 0.5), lerp(coords.vertexTopRightY, coords.vertexBottomRightY, 0.5)); right_center_gizmo->world_pos[0] = QPoint(lerp(coords.vertexTopRightX, coords.vertexBottomRightX, 0.5), lerp(coords.vertexTopRightY, coords.vertexBottomRightY, 0.5));
bottom_right_gizmo->world_pos[0] = QPoint(coords.vertexBottomRightX, coords.vertexBottomRightY); bottom_right_gizmo->world_pos[0] = QPoint(coords.vertexBottomRightX, coords.vertexBottomRightY);
bottom_center_gizmo->world_pos[0] = QPoint(lerp(coords.vertexBottomRightX, coords.vertexBottomLeftX, 0.5), lerp(coords.vertexBottomRightY, coords.vertexBottomLeftY, 0.5)); bottom_center_gizmo->world_pos[0] = QPoint(lerp(coords.vertexBottomRightX, coords.vertexBottomLeftX, 0.5), lerp(coords.vertexBottomRightY, coords.vertexBottomLeftY, 0.5));
bottom_left_gizmo->world_pos[0] = QPoint(coords.vertexBottomLeftX, coords.vertexBottomLeftY); bottom_left_gizmo->world_pos[0] = QPoint(coords.vertexBottomLeftX, coords.vertexBottomLeftY);
left_center_gizmo->world_pos[0] = QPoint(lerp(coords.vertexBottomLeftX, coords.vertexTopLeftX, 0.5), lerp(coords.vertexBottomLeftY, coords.vertexTopLeftY, 0.5)); left_center_gizmo->world_pos[0] = QPoint(lerp(coords.vertexBottomLeftX, coords.vertexTopLeftX, 0.5), lerp(coords.vertexBottomLeftY, coords.vertexTopLeftY, 0.5));
rotate_gizmo->world_pos[0] = QPoint(lerp(top_center_gizmo->world_pos[0].x(), bottom_center_gizmo->world_pos[0].x(), -0.1), lerp(top_center_gizmo->world_pos[0].y(), bottom_center_gizmo->world_pos[0].y(), -0.1)); rotate_gizmo->world_pos[0] = QPoint(lerp(top_center_gizmo->world_pos[0].x(), bottom_center_gizmo->world_pos[0].x(), -0.1), lerp(top_center_gizmo->world_pos[0].y(), bottom_center_gizmo->world_pos[0].y(), -0.1));
rect_gizmo->world_pos[0] = QPoint(coords.vertexTopLeftX, coords.vertexTopLeftY); rect_gizmo->world_pos[0] = QPoint(coords.vertexTopLeftX, coords.vertexTopLeftY);
rect_gizmo->world_pos[1] = QPoint(coords.vertexTopRightX, coords.vertexTopRightY); rect_gizmo->world_pos[1] = QPoint(coords.vertexTopRightX, coords.vertexTopRightY);
rect_gizmo->world_pos[2] = QPoint(coords.vertexBottomRightX, coords.vertexBottomRightY); rect_gizmo->world_pos[2] = QPoint(coords.vertexBottomRightX, coords.vertexBottomRightY);
rect_gizmo->world_pos[3] = QPoint(coords.vertexBottomLeftX, coords.vertexBottomLeftY); rect_gizmo->world_pos[3] = QPoint(coords.vertexBottomLeftX, coords.vertexBottomLeftY);
} }
+3 -3
View File
@@ -9,12 +9,12 @@
#include "ui/collapsiblewidget.h" #include "ui/collapsiblewidget.h"
VolumeEffect::VolumeEffect(Clip* c, const EffectMeta *em) : Effect(c, em) { VolumeEffect::VolumeEffect(Clip* c, const EffectMeta *em) : Effect(c, em) {
EffectRow* volume_row = add_row("Volume:"); EffectRow* volume_row = add_row("Volume");
volume_val = volume_row->add_field(EFFECT_FIELD_DOUBLE, "volume"); volume_val = volume_row->add_field(EFFECT_FIELD_DOUBLE, "volume");
volume_val->set_double_minimum_value(0); volume_val->set_double_minimum_value(0);
// set defaults // set defaults
volume_val->set_double_default_value(100); volume_val->set_double_default_value(100);
} }
void VolumeEffect::process_audio(double timecode_start, double timecode_end, quint8* samples, int nb_bytes, int) { void VolumeEffect::process_audio(double timecode_start, double timecode_end, quint8* samples, int nb_bytes, int) {
+42 -3
View File
@@ -1,15 +1,54 @@
#include "math.h" #include "math.h"
#include <QtMath> #include <QtMath>
#include <QVector>
#include "debug.h"
int lerp(int a, int b, double t) { int lerp(int a, int b, double t) {
return qRound(((1.0 - t) * a) + (t * b)); return qRound(((1.0 - t) * a) + (t * b));
} }
float float_lerp(float a, float b, float t) { float float_lerp(float a, float b, float t) {
return ((1.0F - t) * a) + (t * b); return ((1.0F - t) * a) + (t * b);
} }
double double_lerp(double a, double b, double t) { double double_lerp(double a, double b, double t) {
return ((1.0 - t) * a) + (t * b); return ((1.0 - t) * a) + (t * b);
}
double quad_from_t(double a, double b, double c, double t) {
return qPow(1.0 - t, 2)*a + 2*(1.0 - t)*t*b + qPow(t, 2)*c;
}
double quad_t_from_x(double x, double a, double b, double c) {
return (a - b + qSqrt(a*x + c*x - 2*b*x + qPow(b, 2) - a*c))/(a - 2*b + c);
// alt: return (a - b - qSqrt(a*x + c*x - 2*b*x + qPow(b, 2) - a*c))/(a - 2*b + c);
}
double cubic_from_t(double a, double b, double c, double d, double t) {
return qPow(1.0 - t, 3)*a + 3*qPow(1.0 - t, 2)*t*b + 3*(1.0 - t)*qPow(t, 2)*c + qPow(t, 3)*d;
}
double cubic_t_from_x(double x_target, double a, double b, double c, double d) {
double tolerance = 0.0001;
double lower = 0.0;
double upper = 1.0;
double percent = 0.5;
double x = cubic_from_t(a, b, c, d, percent);
while (qAbs(x_target - x) > tolerance) {
if (x_target > x) {
lower = percent;
} else {
upper = percent;
}
percent = (upper + lower) / 2.0;
x = cubic_from_t(a, b, c, d, percent);
}
return percent;
} }
+5
View File
@@ -4,5 +4,10 @@
int lerp(int a, int b, double t); int lerp(int a, int b, double t);
float float_lerp(float a, float b, float t); float float_lerp(float a, float b, float t);
double double_lerp(double a, double b, double t); double double_lerp(double a, double b, double t);
double quad_from_t(double a, double b, double c, double t);
double quad_t_from_x(double x, double a, double b, double c);
double cubic_from_t(double a, double b, double c, double d, double t);
double cubic_t_from_x(double x_target, double a, double b, double c, double d);
double solveCubicBezier(double p0, double p1, double p2, double p3, double x);
#endif // MATH_H #endif // MATH_H
+41 -6
View File
@@ -59,10 +59,13 @@ GraphEditor::GraphEditor(QWidget* parent) : QDockWidget(parent), row(NULL) {
left_tool_layout->addStretch(); left_tool_layout->addStretch();
linear_button = new QPushButton("Linear"); linear_button = new QPushButton("Linear");
linear_button->setProperty("type", KEYFRAME_TYPE_LINEAR);
linear_button->setCheckable(true); linear_button->setCheckable(true);
bezier_button = new QPushButton("Bezier"); bezier_button = new QPushButton("Bezier");
bezier_button->setProperty("type", KEYFRAME_TYPE_BEZIER);
bezier_button->setCheckable(true); bezier_button->setCheckable(true);
hold_button = new QPushButton("Hold"); hold_button = new QPushButton("Hold");
hold_button->setProperty("type", KEYFRAME_TYPE_HOLD);
hold_button->setCheckable(true); hold_button->setCheckable(true);
center_tool_layout->addStretch(); center_tool_layout->addStretch();
@@ -91,9 +94,6 @@ GraphEditor::GraphEditor(QWidget* parent) : QDockWidget(parent), row(NULL) {
value_widget->setLayout(values); value_widget->setLayout(values);
values->addStretch(); values->addStretch();
current_row_desc = new QLabel();
values->addWidget(current_row_desc);
QWidget* central_value_widget = new QWidget(); QWidget* central_value_widget = new QWidget();
value_layout = new QHBoxLayout(); value_layout = new QHBoxLayout();
value_layout->setMargin(0); value_layout->setMargin(0);
@@ -103,9 +103,18 @@ GraphEditor::GraphEditor(QWidget* parent) : QDockWidget(parent), row(NULL) {
values->addStretch(); values->addStretch();
layout->addWidget(value_widget); layout->addWidget(value_widget);
current_row_desc = new QLabel();
current_row_desc->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Maximum);
current_row_desc->setAlignment(Qt::AlignCenter);
layout->addWidget(current_row_desc);
connect(view, SIGNAL(zoom_changed(double)), header, SLOT(update_zoom(double))); connect(view, SIGNAL(zoom_changed(double)), header, SLOT(update_zoom(double)));
connect(view, SIGNAL(x_scroll_changed(int)), header, SLOT(set_scroll(int))); connect(view, SIGNAL(x_scroll_changed(int)), header, SLOT(set_scroll(int)));
connect(view, SIGNAL(selection_changed(bool)), this, SLOT(set_key_button_enabled(bool))); connect(view, SIGNAL(selection_changed(bool, int)), this, SLOT(set_key_button_enabled(bool, int)));
connect(linear_button, SIGNAL(clicked(bool)), this, SLOT(set_keyframe_type()));
connect(bezier_button, SIGNAL(clicked(bool)), this, SLOT(set_keyframe_type()));
connect(hold_button, SIGNAL(clicked(bool)), this, SLOT(set_keyframe_type()));
} }
void GraphEditor::update_panel() { void GraphEditor::update_panel() {
@@ -129,8 +138,10 @@ void GraphEditor::update_panel() {
void GraphEditor::set_row(EffectRow *r) { void GraphEditor::set_row(EffectRow *r) {
for (int i=0;i<slider_proxies.size();i++) { for (int i=0;i<slider_proxies.size();i++) {
delete slider_proxies.at(i); delete slider_proxies.at(i);
delete slider_proxy_buttons.at(i);
} }
slider_proxies.clear(); slider_proxies.clear();
slider_proxy_buttons.clear();
slider_proxy_sources.clear(); slider_proxy_sources.clear();
if (row != NULL) { if (row != NULL) {
@@ -146,10 +157,20 @@ void GraphEditor::set_row(EffectRow *r) {
for (int i=0;i<r->fieldCount();i++) { for (int i=0;i<r->fieldCount();i++) {
EffectField* field = r->field(i); EffectField* field = r->field(i);
if (field->type == EFFECT_FIELD_DOUBLE) { if (field->type == EFFECT_FIELD_DOUBLE) {
QPushButton* slider_button = new QPushButton();
slider_button->setCheckable(true);
slider_button->setChecked(true);
slider_button->setIcon(QIcon(":/icons/record.png"));
slider_button->setProperty("field", i);
slider_button->setIconSize(QSize(8, 8));
slider_button->setMaximumSize(QSize(12, 12));
connect(slider_button, SIGNAL(toggled(bool)), this, SLOT(set_field_visibility(bool)));
slider_proxy_buttons.append(slider_button);
value_layout->addWidget(slider_button);
LabelSlider* slider = new LabelSlider(); LabelSlider* slider = new LabelSlider();
slider->set_color(get_curve_color(i, r->fieldCount()).name()); slider->set_color(get_curve_color(i, r->fieldCount()).name());
connect(slider, SIGNAL(valueChanged()), this, SLOT(passthrough_slider_value())); connect(slider, SIGNAL(valueChanged()), this, SLOT(passthrough_slider_value()));
slider_proxies.append(slider); slider_proxies.append(slider);
value_layout->addWidget(slider); value_layout->addWidget(slider);
@@ -175,10 +196,13 @@ void GraphEditor::set_row(EffectRow *r) {
update_panel(); update_panel();
} }
void GraphEditor::set_key_button_enabled(bool e) { void GraphEditor::set_key_button_enabled(bool e, int type) {
linear_button->setEnabled(e); linear_button->setEnabled(e);
linear_button->setChecked(type == KEYFRAME_TYPE_LINEAR);
bezier_button->setEnabled(e); bezier_button->setEnabled(e);
bezier_button->setChecked(type == KEYFRAME_TYPE_BEZIER);
hold_button->setEnabled(e); hold_button->setEnabled(e);
hold_button->setChecked(type == KEYFRAME_TYPE_HOLD);
} }
void GraphEditor::passthrough_slider_value() { void GraphEditor::passthrough_slider_value() {
@@ -188,3 +212,14 @@ void GraphEditor::passthrough_slider_value() {
} }
} }
} }
void GraphEditor::set_keyframe_type() {
linear_button->setChecked(linear_button == sender());
bezier_button->setChecked(bezier_button == sender());
hold_button->setChecked(hold_button == sender());
view->set_selected_keyframe_type(sender()->property("type").toInt());
}
void GraphEditor::set_field_visibility(bool b) {
view->set_field_visibility(sender()->property("field").toInt(), b);
}
+4 -1
View File
@@ -23,6 +23,7 @@ private:
TimelineHeader* header; TimelineHeader* header;
QHBoxLayout* value_layout; QHBoxLayout* value_layout;
QVector<LabelSlider*> slider_proxies; QVector<LabelSlider*> slider_proxies;
QVector<QPushButton*> slider_proxy_buttons;
QVector<LabelSlider*> slider_proxy_sources; QVector<LabelSlider*> slider_proxy_sources;
QLabel* current_row_desc; QLabel* current_row_desc;
EffectRow* row; EffectRow* row;
@@ -31,8 +32,10 @@ private:
QPushButton* bezier_button; QPushButton* bezier_button;
QPushButton* hold_button; QPushButton* hold_button;
private slots: private slots:
void set_key_button_enabled(bool e); void set_key_button_enabled(bool e, int type);
void passthrough_slider_value(); void passthrough_slider_value();
void set_keyframe_type();
void set_field_visibility(bool b);
}; };
#endif // GRAPHEDITOR_H #endif // GRAPHEDITOR_H
+193 -193
View File
@@ -52,14 +52,14 @@ Effect* create_effect(Clip* c, const EffectMeta* em) {
switch (em->internal) { switch (em->internal) {
case EFFECT_INTERNAL_TRANSFORM: return new TransformEffect(c, em); case EFFECT_INTERNAL_TRANSFORM: return new TransformEffect(c, em);
case EFFECT_INTERNAL_TEXT: return new TextEffect(c, em); case EFFECT_INTERNAL_TEXT: return new TextEffect(c, em);
case EFFECT_INTERNAL_TIMECODE: return new TimecodeEffect(c, em); case EFFECT_INTERNAL_TIMECODE: return new TimecodeEffect(c, em);
case EFFECT_INTERNAL_SOLID: return new SolidEffect(c, em); case EFFECT_INTERNAL_SOLID: return new SolidEffect(c, em);
case EFFECT_INTERNAL_NOISE: return new AudioNoiseEffect(c, em); case EFFECT_INTERNAL_NOISE: return new AudioNoiseEffect(c, em);
case EFFECT_INTERNAL_VOLUME: return new VolumeEffect(c, em); case EFFECT_INTERNAL_VOLUME: return new VolumeEffect(c, em);
case EFFECT_INTERNAL_PAN: return new PanEffect(c, em); case EFFECT_INTERNAL_PAN: return new PanEffect(c, em);
case EFFECT_INTERNAL_TONE: return new ToneEffect(c, em); case EFFECT_INTERNAL_TONE: return new ToneEffect(c, em);
case EFFECT_INTERNAL_SHAKE: return new ShakeEffect(c, em); case EFFECT_INTERNAL_SHAKE: return new ShakeEffect(c, em);
case EFFECT_INTERNAL_CORNERPIN: return new CornerPinEffect(c, em); case EFFECT_INTERNAL_CORNERPIN: return new CornerPinEffect(c, em);
} }
} else { } else {
dout << "[ERROR] Invalid effect data"; dout << "[ERROR] Invalid effect data";
@@ -69,12 +69,12 @@ Effect* create_effect(Clip* c, const EffectMeta* em) {
} }
const EffectMeta* get_internal_meta(int internal_id, int type) { const EffectMeta* get_internal_meta(int internal_id, int type) {
for (int i=0;i<effects.size();i++) { for (int i=0;i<effects.size();i++) {
if (effects.at(i).internal == internal_id && effects.at(i).type == type) { if (effects.at(i).internal == internal_id && effects.at(i).type == type) {
return &effects.at(i); return &effects.at(i);
} }
} }
return NULL; return NULL;
} }
void load_internal_effects() { void load_internal_effects() {
@@ -82,77 +82,77 @@ void load_internal_effects() {
// internal effects // internal effects
em.type = EFFECT_TYPE_EFFECT; em.type = EFFECT_TYPE_EFFECT;
em.subtype = EFFECT_TYPE_AUDIO; em.subtype = EFFECT_TYPE_AUDIO;
em.name = "Volume"; em.name = "Volume";
em.internal = EFFECT_INTERNAL_VOLUME; em.internal = EFFECT_INTERNAL_VOLUME;
effects.append(em); effects.append(em);
em.name = "Pan"; em.name = "Pan";
em.internal = EFFECT_INTERNAL_PAN; em.internal = EFFECT_INTERNAL_PAN;
effects.append(em); effects.append(em);
em.name = "Tone"; em.name = "Tone";
em.internal = EFFECT_INTERNAL_TONE; em.internal = EFFECT_INTERNAL_TONE;
effects.append(em); effects.append(em);
em.name = "Noise"; em.name = "Noise";
em.internal = EFFECT_INTERNAL_NOISE; em.internal = EFFECT_INTERNAL_NOISE;
effects.append(em); effects.append(em);
em.subtype = EFFECT_TYPE_VIDEO; em.subtype = EFFECT_TYPE_VIDEO;
em.name = "Transform"; em.name = "Transform";
em.category = "Distort"; em.category = "Distort";
em.internal = EFFECT_INTERNAL_TRANSFORM; em.internal = EFFECT_INTERNAL_TRANSFORM;
effects.append(em); effects.append(em);
em.name = "Corner Pin"; em.name = "Corner Pin";
em.internal = EFFECT_INTERNAL_CORNERPIN; em.internal = EFFECT_INTERNAL_CORNERPIN;
effects.append(em); effects.append(em);
em.name = "Mask"; em.name = "Mask";
em.internal = EFFECT_INTERNAL_MASK; em.internal = EFFECT_INTERNAL_MASK;
effects.append(em); effects.append(em);
em.name = "Shake"; em.name = "Shake";
em.internal = EFFECT_INTERNAL_SHAKE; em.internal = EFFECT_INTERNAL_SHAKE;
effects.append(em); effects.append(em);
em.name = "Text"; em.name = "Text";
em.category = "Render"; em.category = "Render";
em.internal = EFFECT_INTERNAL_TEXT; em.internal = EFFECT_INTERNAL_TEXT;
effects.append(em); effects.append(em);
em.name = "Timecode"; em.name = "Timecode";
em.internal = EFFECT_INTERNAL_TIMECODE; em.internal = EFFECT_INTERNAL_TIMECODE;
effects.append(em); effects.append(em);
em.name = "Solid"; em.name = "Solid";
em.internal = EFFECT_INTERNAL_SOLID; em.internal = EFFECT_INTERNAL_SOLID;
effects.append(em); effects.append(em);
// internal transitions // internal transitions
em.type = EFFECT_TYPE_TRANSITION; em.type = EFFECT_TYPE_TRANSITION;
em.category = ""; em.category = "";
em.name = "Cross Dissolve"; em.name = "Cross Dissolve";
em.internal = TRANSITION_INTERNAL_CROSSDISSOLVE; em.internal = TRANSITION_INTERNAL_CROSSDISSOLVE;
effects.append(em); effects.append(em);
em.subtype = EFFECT_TYPE_AUDIO; em.subtype = EFFECT_TYPE_AUDIO;
em.name = "Linear Fade"; em.name = "Linear Fade";
em.internal = TRANSITION_INTERNAL_LINEARFADE; em.internal = TRANSITION_INTERNAL_LINEARFADE;
effects.append(em); effects.append(em);
em.name = "Exponential Fade"; em.name = "Exponential Fade";
em.internal = TRANSITION_INTERNAL_EXPONENTIALFADE; em.internal = TRANSITION_INTERNAL_EXPONENTIALFADE;
effects.append(em); effects.append(em);
em.name = "Logarithmic Fade"; em.name = "Logarithmic Fade";
em.internal = TRANSITION_INTERNAL_LOGARITHMICFADE; em.internal = TRANSITION_INTERNAL_LOGARITHMICFADE;
effects.append(em); effects.append(em);
} }
void load_shader_effects() { void load_shader_effects() {
@@ -236,29 +236,29 @@ void EffectInit::run() {
Effect::Effect(Clip* c, const EffectMeta *em) : Effect::Effect(Clip* c, const EffectMeta *em) :
parent_clip(c), parent_clip(c),
meta(em), meta(em),
enable_shader(false), enable_shader(false),
enable_coords(false), enable_coords(false),
enable_superimpose(false), enable_superimpose(false),
enable_image(false), enable_image(false),
glslProgram(NULL), glslProgram(NULL),
texture(NULL), texture(NULL),
isOpen(false), isOpen(false),
bound(false), bound(false),
enable_always_update(false) enable_always_update(false)
{ {
// set up base UI // set up base UI
container = new CollapsibleWidget(); container = new CollapsibleWidget();
connect(container->enabled_check, SIGNAL(clicked(bool)), this, SLOT(field_changed())); connect(container->enabled_check, SIGNAL(clicked(bool)), this, SLOT(field_changed()));
ui = new QWidget(); ui = new QWidget();
ui_layout = new QGridLayout(); ui_layout = new QGridLayout();
ui_layout->setSpacing(4); ui_layout->setSpacing(4);
ui->setLayout(ui_layout); ui->setLayout(ui_layout);
container->setContents(ui); container->setContents(ui);
connect(container->title_bar, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(show_context_menu(const QPoint&))); connect(container->title_bar, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(show_context_menu(const QPoint&)));
// set up UI from effect file // set up UI from effect file
container->setText(em->name); container->setText(em->name);
if (!em->filename.isEmpty()) { if (!em->filename.isEmpty()) {
@@ -277,7 +277,7 @@ Effect::Effect(Clip* c, const EffectMeta *em) :
} }
} }
if (!row_name.isEmpty()) { if (!row_name.isEmpty()) {
EffectRow* row = add_row(row_name + ":"); EffectRow* row = add_row(row_name);
while (!reader.atEnd() && !(reader.name() == "row" && reader.isEndElement())) { while (!reader.atEnd() && !(reader.name() == "row" && reader.isEndElement())) {
reader.readNext(); reader.readNext();
if (reader.name() == "field" && reader.isStartElement()) { if (reader.name() == "field" && reader.isStartElement()) {
@@ -311,7 +311,7 @@ Effect::Effect(Clip* c, const EffectMeta *em) :
if (id.isEmpty()) { if (id.isEmpty()) {
dout << "[ERROR] Couldn't load field from" << em->filename << "- ID cannot be empty."; dout << "[ERROR] Couldn't load field from" << em->filename << "- ID cannot be empty.";
} else if (type > -1) { } else if (type > -1) {
EffectField* field = row->add_field(type, id); EffectField* field = row->add_field(type, id);
connect(field, SIGNAL(changed()), this, SLOT(field_changed())); connect(field, SIGNAL(changed()), this, SLOT(field_changed()));
switch (type) { switch (type) {
case EFFECT_FIELD_DOUBLE: case EFFECT_FIELD_DOUBLE:
@@ -447,27 +447,27 @@ Effect::~Effect() {
for (int i=0;i<rows.size();i++) { for (int i=0;i<rows.size();i++) {
delete rows.at(i); delete rows.at(i);
} }
for (int i=0;i<gizmos.size();i++) { for (int i=0;i<gizmos.size();i++) {
delete gizmos.at(i); delete gizmos.at(i);
} }
} }
void Effect::copy_field_keyframes(Effect* e) { void Effect::copy_field_keyframes(Effect* e) {
for (int i=0;i<rows.size();i++) { for (int i=0;i<rows.size();i++) {
EffectRow* row = rows.at(i); EffectRow* row = rows.at(i);
EffectRow* copy_row = e->rows.at(i); EffectRow* copy_row = e->rows.at(i);
copy_row->setKeyframing(row->isKeyframing()); copy_row->setKeyframing(row->isKeyframing());
for (int j=0;j<row->fieldCount();j++) { for (int j=0;j<row->fieldCount();j++) {
EffectField* field = row->field(j); EffectField* field = row->field(j);
EffectField* copy_field = copy_row->field(j); EffectField* copy_field = copy_row->field(j);
copy_field->keyframes = field->keyframes; copy_field->keyframes = field->keyframes;
} }
} }
} }
EffectRow* Effect::add_row(const QString& name, bool savable) { EffectRow* Effect::add_row(const QString& name, bool savable) {
EffectRow* row = new EffectRow(this, savable, ui_layout, name, rows.size()); EffectRow* row = new EffectRow(this, savable, ui_layout, name, rows.size());
rows.append(row); rows.append(row);
return row; return row;
} }
@@ -476,53 +476,53 @@ EffectRow* Effect::row(int i) {
} }
int Effect::row_count() { int Effect::row_count() {
return rows.size(); return rows.size();
} }
EffectGizmo *Effect::add_gizmo(int type) { EffectGizmo *Effect::add_gizmo(int type) {
EffectGizmo* gizmo = new EffectGizmo(type); EffectGizmo* gizmo = new EffectGizmo(type);
gizmos.append(gizmo); gizmos.append(gizmo);
return gizmo; return gizmo;
} }
EffectGizmo *Effect::gizmo(int i) { EffectGizmo *Effect::gizmo(int i) {
return gizmos.at(i); return gizmos.at(i);
} }
int Effect::gizmo_count(){ int Effect::gizmo_count(){
return gizmos.size(); return gizmos.size();
} }
void Effect::refresh() {} void Effect::refresh() {}
void Effect::field_changed() { void Effect::field_changed() {
panel_sequence_viewer->viewer_widget->update(); panel_sequence_viewer->viewer_widget->update();
panel_graph_editor->update_panel(); panel_graph_editor->update_panel();
} }
void Effect::show_context_menu(const QPoint& pos) { void Effect::show_context_menu(const QPoint& pos) {
if (meta->type == EFFECT_TYPE_EFFECT) { if (meta->type == EFFECT_TYPE_EFFECT) {
QMenu menu(mainWindow); QMenu menu(mainWindow);
int index = get_index_in_clip(); int index = get_index_in_clip();
if (index > 0) { if (index > 0) {
QAction* move_up = menu.addAction("Move &Up"); QAction* move_up = menu.addAction("Move &Up");
connect(move_up, SIGNAL(triggered(bool)), this, SLOT(move_up())); connect(move_up, SIGNAL(triggered(bool)), this, SLOT(move_up()));
} }
if (index < parent_clip->effects.size() - 1) { if (index < parent_clip->effects.size() - 1) {
QAction* move_down = menu.addAction("Move &Down"); QAction* move_down = menu.addAction("Move &Down");
connect(move_down, SIGNAL(triggered(bool)), this, SLOT(move_down())); connect(move_down, SIGNAL(triggered(bool)), this, SLOT(move_down()));
} }
menu.addSeparator(); menu.addSeparator();
QAction* del_action = menu.addAction("D&elete"); QAction* del_action = menu.addAction("D&elete");
connect(del_action, SIGNAL(triggered(bool)), this, SLOT(delete_self())); connect(del_action, SIGNAL(triggered(bool)), this, SLOT(delete_self()));
menu.exec(container->title_bar->mapToGlobal(pos)); menu.exec(container->title_bar->mapToGlobal(pos));
} }
} }
void Effect::delete_self() { void Effect::delete_self() {
@@ -572,24 +572,24 @@ void Effect::set_enabled(bool b) {
QVariant load_data_from_string(int type, const QString& string) { QVariant load_data_from_string(int type, const QString& string) {
switch (type) { switch (type) {
case EFFECT_FIELD_DOUBLE: return string.toDouble(); case EFFECT_FIELD_DOUBLE: return string.toDouble();
case EFFECT_FIELD_COLOR: return QColor(string); case EFFECT_FIELD_COLOR: return QColor(string);
case EFFECT_FIELD_STRING: return string; case EFFECT_FIELD_STRING: return string;
case EFFECT_FIELD_BOOL: return (string == "1"); case EFFECT_FIELD_BOOL: return (string == "1");
case EFFECT_FIELD_COMBO: return string.toInt(); case EFFECT_FIELD_COMBO: return string.toInt();
case EFFECT_FIELD_FONT: return string; case EFFECT_FIELD_FONT: return string;
} }
return QVariant(); return QVariant();
} }
QString save_data_to_string(int type, const QVariant& data) { QString save_data_to_string(int type, const QVariant& data) {
switch (type) { switch (type) {
case EFFECT_FIELD_DOUBLE: return QString::number(data.toDouble()); case EFFECT_FIELD_DOUBLE: return QString::number(data.toDouble());
case EFFECT_FIELD_COLOR: return data.value<QColor>().name(); case EFFECT_FIELD_COLOR: return data.value<QColor>().name();
case EFFECT_FIELD_STRING: return data.toString(); case EFFECT_FIELD_STRING: return data.toString();
case EFFECT_FIELD_BOOL: return QString::number(data.toBool()); case EFFECT_FIELD_BOOL: return QString::number(data.toBool());
case EFFECT_FIELD_COMBO: return QString::number(data.toInt()); case EFFECT_FIELD_COMBO: return QString::number(data.toInt());
case EFFECT_FIELD_FONT: return data.toString(); case EFFECT_FIELD_FONT: return data.toString();
} }
return QString(); return QString();
} }
@@ -610,7 +610,7 @@ void Effect::load(QXmlStreamReader& stream) {
stream.readNext(); stream.readNext();
// read keyframes // read keyframes
/*if (stream.name() == "keyframes" && stream.isStartElement()) { /*if (stream.name() == "keyframes" && stream.isStartElement()) {
for (int k=0;k<stream.attributes().size();k++) { for (int k=0;k<stream.attributes().size();k++) {
const QXmlStreamAttribute& attr = stream.attributes().at(k); const QXmlStreamAttribute& attr = stream.attributes().at(k);
if (attr.name() == "enabled") { if (attr.name() == "enabled") {
@@ -631,19 +631,19 @@ void Effect::load(QXmlStreamReader& stream) {
keyframe_type = attr.value().toInt(); keyframe_type = attr.value().toInt();
} }
} }
for (int k=0;k<row->fieldCount();k++) { for (int k=0;k<row->fieldCount();k++) {
EffectField* field = row->field(k); EffectField* field = row->field(k);
EffectKeyframe key; EffectKeyframe key;
key.time = keyframe_frame; key.time = keyframe_frame;
key.type = keyframe_type; key.type = keyframe_type;
field->keyframes.append(key); field->keyframes.append(key);
} }
} }
stream.readNext(); stream.readNext();
} }
} }
stream.readNext(); stream.readNext();
}*/ }*/
// read field // read field
if (stream.name() == "field" && stream.isStartElement()) { if (stream.name() == "field" && stream.isStartElement()) {
@@ -683,22 +683,22 @@ void Effect::load(QXmlStreamReader& stream) {
while (!stream.atEnd() && !(stream.name() == "field" && stream.isEndElement())) { while (!stream.atEnd() && !(stream.name() == "field" && stream.isEndElement())) {
stream.readNext(); stream.readNext();
// read keyframes // read keyframes
if (stream.name() == "key" && stream.isStartElement()) { if (stream.name() == "key" && stream.isStartElement()) {
row->setKeyframing(true); row->setKeyframing(true);
EffectKeyframe key; EffectKeyframe key;
for (int k=0;k<stream.attributes().size();k++) { for (int k=0;k<stream.attributes().size();k++) {
const QXmlStreamAttribute& attr = stream.attributes().at(k); const QXmlStreamAttribute& attr = stream.attributes().at(k);
if (attr.name() == "value") { if (attr.name() == "value") {
key.data = load_data_from_string(field->type, attr.value().toString()); key.data = load_data_from_string(field->type, attr.value().toString());
} else if (attr.name() == "frame") { } else if (attr.name() == "frame") {
key.time = attr.value().toLong(); key.time = attr.value().toLong();
} else if (attr.name() == "type") { } else if (attr.name() == "type") {
key.type = attr.value().toInt(); key.type = attr.value().toInt();
} }
} }
field->keyframes.append(key); field->keyframes.append(key);
} }
} }
} else { } else {
@@ -718,29 +718,29 @@ void Effect::load(QXmlStreamReader& stream) {
void Effect::save(QXmlStreamWriter& stream) { void Effect::save(QXmlStreamWriter& stream) {
stream.writeAttribute("name", meta->name); stream.writeAttribute("name", meta->name);
stream.writeAttribute("enabled", QString::number(is_enabled())); stream.writeAttribute("enabled", QString::number(is_enabled()));
for (int i=0;i<rows.size();i++) { for (int i=0;i<rows.size();i++) {
EffectRow* row = rows.at(i); EffectRow* row = rows.at(i);
if (row->savable) { if (row->savable) {
stream.writeStartElement("row"); // row stream.writeStartElement("row"); // row
for (int j=0;j<row->fieldCount();j++) { for (int j=0;j<row->fieldCount();j++) {
EffectField* field = row->field(j); EffectField* field = row->field(j);
stream.writeStartElement("field"); // field stream.writeStartElement("field"); // field
stream.writeAttribute("id", field->id); stream.writeAttribute("id", field->id);
stream.writeAttribute("value", save_data_to_string(field->type, field->get_current_data())); stream.writeAttribute("value", save_data_to_string(field->type, field->get_current_data()));
for (int k=0;k<field->keyframes.size();k++) { for (int k=0;k<field->keyframes.size();k++) {
const EffectKeyframe& key = field->keyframes.at(k); const EffectKeyframe& key = field->keyframes.at(k);
stream.writeStartElement("key"); stream.writeStartElement("key");
stream.writeAttribute("value", save_data_to_string(field->type, key.data)); stream.writeAttribute("value", save_data_to_string(field->type, key.data));
stream.writeAttribute("frame", QString::number(key.time)); stream.writeAttribute("frame", QString::number(key.time));
stream.writeAttribute("type", QString::number(key.type)); stream.writeAttribute("type", QString::number(key.type));
stream.writeEndElement(); // key stream.writeEndElement(); // key
} }
stream.writeEndElement(); // field stream.writeEndElement(); // field
} }
stream.writeEndElement(); // row stream.writeEndElement(); // row
} }
} }
} }
@@ -790,16 +790,16 @@ void Effect::startEffect() {
void Effect::endEffect() { void Effect::endEffect() {
if (bound) glslProgram->release(); if (bound) glslProgram->release();
bound = false; bound = false;
} }
void Effect::process_image(double, uint8_t *, int) {} void Effect::process_image(double, uint8_t *, int) {}
Effect* Effect::copy(Clip* c) { Effect* Effect::copy(Clip* c) {
Effect* copy = create_effect(c, meta); Effect* copy = create_effect(c, meta);
copy->set_enabled(is_enabled()); copy->set_enabled(is_enabled());
copy_field_keyframes(copy); copy_field_keyframes(copy);
return copy; return copy;
} }
void Effect::process_shader(double timecode, GLTextureCoords&) { void Effect::process_shader(double timecode, GLTextureCoords&) {
@@ -844,7 +844,7 @@ GLuint Effect::process_superimpose(double timecode) {
recreate_texture = true; recreate_texture = true;
} }
if (valueHasChanged(timecode) || recreate_texture || enable_always_update) { if (valueHasChanged(timecode) || recreate_texture || enable_always_update) {
redraw(timecode); redraw(timecode);
} }
@@ -865,78 +865,78 @@ GLuint Effect::process_superimpose(double timecode) {
void Effect::process_audio(double, double, quint8*, int, int) { void Effect::process_audio(double, double, quint8*, int, int) {
// only volume/pan, hand off to AU and VST for all other cases // only volume/pan, hand off to AU and VST for all other cases
/*double interval = (timecode_end-timecode_start)/nb_bytes; /*double interval = (timecode_end-timecode_start)/nb_bytes;
for (int i=0;i<nb_bytes;i+=2) { for (int i=0;i<nb_bytes;i+=2) {
qint32 samp = (qint16) (((samples[i+1] & 0xFF) << 8) | (samples[i] & 0xFF)); qint32 samp = (qint16) (((samples[i+1] & 0xFF) << 8) | (samples[i] & 0xFF));
jsEngine.globalObject().setProperty("sample", samp); jsEngine.globalObject().setProperty("sample", samp);
jsEngine.globalObject().setProperty("volume", row(0)->field(0)->get_double_value(timecode_start+(interval*i), true)); jsEngine.globalObject().setProperty("volume", row(0)->field(0)->get_double_value(timecode_start+(interval*i), true));
QJSValue result = eval.call(); QJSValue result = eval.call();
samp = result.toInt(); samp = result.toInt();
QJSValueList args; QJSValueList args;
args << samples << nb_bytes; args << samples << nb_bytes;
samples[i+1] = (quint8) (samp >> 8); samples[i+1] = (quint8) (samp >> 8);
samples[i] = (quint8) samp; samples[i] = (quint8) samp;
}*/ }*/
} }
void Effect::gizmo_draw(double, GLTextureCoords &) {} void Effect::gizmo_draw(double, GLTextureCoords &) {}
void Effect::gizmo_move(EffectGizmo* gizmo, int x_movement, int y_movement, double timecode, bool done) { void Effect::gizmo_move(EffectGizmo* gizmo, int x_movement, int y_movement, double timecode, bool done) {
for (int i=0;i<gizmos.size();i++) { for (int i=0;i<gizmos.size();i++) {
if (gizmos.at(i) == gizmo) { if (gizmos.at(i) == gizmo) {
ComboAction* ca = NULL; ComboAction* ca = NULL;
if (done) ca = new ComboAction(); if (done) ca = new ComboAction();
if (gizmo->x_field1 != NULL) { if (gizmo->x_field1 != NULL) {
gizmo->x_field1->set_double_value(gizmo->x_field1->get_double_value(timecode) + x_movement*gizmo->x_field_multi1); gizmo->x_field1->set_double_value(gizmo->x_field1->get_double_value(timecode) + x_movement*gizmo->x_field_multi1);
gizmo->x_field1->make_key_from_change(ca); gizmo->x_field1->make_key_from_change(ca);
} }
if (gizmo->y_field1 != NULL) { if (gizmo->y_field1 != NULL) {
gizmo->y_field1->set_double_value(gizmo->y_field1->get_double_value(timecode) + y_movement*gizmo->y_field_multi1); gizmo->y_field1->set_double_value(gizmo->y_field1->get_double_value(timecode) + y_movement*gizmo->y_field_multi1);
gizmo->y_field1->make_key_from_change(ca); gizmo->y_field1->make_key_from_change(ca);
} }
if (gizmo->x_field2 != NULL) { if (gizmo->x_field2 != NULL) {
gizmo->x_field2->set_double_value(gizmo->x_field2->get_double_value(timecode) + x_movement*gizmo->x_field_multi2); gizmo->x_field2->set_double_value(gizmo->x_field2->get_double_value(timecode) + x_movement*gizmo->x_field_multi2);
gizmo->x_field2->make_key_from_change(ca); gizmo->x_field2->make_key_from_change(ca);
} }
if (gizmo->y_field2 != NULL) { if (gizmo->y_field2 != NULL) {
gizmo->y_field2->set_double_value(gizmo->y_field2->get_double_value(timecode) + y_movement*gizmo->y_field_multi2); gizmo->y_field2->set_double_value(gizmo->y_field2->get_double_value(timecode) + y_movement*gizmo->y_field_multi2);
gizmo->y_field2->make_key_from_change(ca); gizmo->y_field2->make_key_from_change(ca);
} }
if (done) undo_stack.push(ca); if (done) undo_stack.push(ca);
break; break;
} }
} }
} }
void Effect::gizmo_world_to_screen() { void Effect::gizmo_world_to_screen() {
GLfloat view_val[16]; GLfloat view_val[16];
GLfloat projection_val[16]; GLfloat projection_val[16];
glGetFloatv(GL_MODELVIEW_MATRIX, view_val); glGetFloatv(GL_MODELVIEW_MATRIX, view_val);
glGetFloatv(GL_PROJECTION_MATRIX, projection_val); glGetFloatv(GL_PROJECTION_MATRIX, projection_val);
QMatrix4x4 view_matrix(view_val); QMatrix4x4 view_matrix(view_val);
QMatrix4x4 projection_matrix(projection_val); QMatrix4x4 projection_matrix(projection_val);
for (int i=0;i<gizmos.size();i++) { for (int i=0;i<gizmos.size();i++) {
EffectGizmo* g = gizmos.at(i); EffectGizmo* g = gizmos.at(i);
for (int j=0;j<g->get_point_count();j++) { for (int j=0;j<g->get_point_count();j++) {
QVector4D screen_pos = QVector4D(g->world_pos[j].x(), g->world_pos[j].y(), 0, 1.0) * (view_matrix * projection_matrix); QVector4D screen_pos = QVector4D(g->world_pos[j].x(), g->world_pos[j].y(), 0, 1.0) * (view_matrix * projection_matrix);
int adjusted_sx1 = qRound(((screen_pos.x()*0.5f)+0.5f)*parent_clip->sequence->width); int adjusted_sx1 = qRound(((screen_pos.x()*0.5f)+0.5f)*parent_clip->sequence->width);
int adjusted_sy1 = qRound((1.0f-((screen_pos.y()*0.5f)+0.5f))*parent_clip->sequence->height); int adjusted_sy1 = qRound((1.0f-((screen_pos.y()*0.5f)+0.5f))*parent_clip->sequence->height);
g->screen_pos[j] = QPoint(adjusted_sx1, adjusted_sy1); g->screen_pos[j] = QPoint(adjusted_sx1, adjusted_sy1);
} }
} }
} }
bool Effect::are_gizmos_enabled() { bool Effect::are_gizmos_enabled() {
return (gizmos.size() > 0); return (gizmos.size() > 0);
} }
void Effect::redraw(double) { void Effect::redraw(double) {
+261 -248
View File
@@ -15,353 +15,366 @@
#include "project/sequence.h" #include "project/sequence.h"
#include "io/math.h" #include "io/math.h"
#include <QtMath> #include <QDateTime>
#include "debug.h"
EffectField::EffectField(EffectRow *parent, int t, const QString &i) : EffectField::EffectField(EffectRow *parent, int t, const QString &i) :
parent_row(parent), parent_row(parent),
type(t), type(t),
id(i) id(i)
{ {
switch (t) { switch (t) {
case EFFECT_FIELD_DOUBLE: case EFFECT_FIELD_DOUBLE:
{ {
LabelSlider* ls = new LabelSlider(); LabelSlider* ls = new LabelSlider();
ui_element = ls; ui_element = ls;
connect(ls, SIGNAL(valueChanged()), this, SLOT(ui_element_change())); connect(ls, SIGNAL(valueChanged()), this, SLOT(ui_element_change()));
connect(ls, SIGNAL(clicked()), this, SIGNAL(clicked())); connect(ls, SIGNAL(clicked()), this, SIGNAL(clicked()));
} }
break; break;
case EFFECT_FIELD_COLOR: case EFFECT_FIELD_COLOR:
{ {
ColorButton* cb = new ColorButton(); ColorButton* cb = new ColorButton();
ui_element = cb; ui_element = cb;
connect(cb, SIGNAL(color_changed()), this, SLOT(ui_element_change())); connect(cb, SIGNAL(color_changed()), this, SLOT(ui_element_change()));
} }
break; break;
case EFFECT_FIELD_STRING: case EFFECT_FIELD_STRING:
{ {
TextEditEx* edit = new TextEditEx(); TextEditEx* edit = new TextEditEx();
edit->setUndoRedoEnabled(true); edit->setUndoRedoEnabled(true);
ui_element = edit; ui_element = edit;
connect(edit, SIGNAL(textChanged()), this, SLOT(ui_element_change())); connect(edit, SIGNAL(textChanged()), this, SLOT(ui_element_change()));
} }
break; break;
case EFFECT_FIELD_BOOL: case EFFECT_FIELD_BOOL:
{ {
CheckboxEx* cb = new CheckboxEx(); CheckboxEx* cb = new CheckboxEx();
ui_element = cb; ui_element = cb;
connect(cb, SIGNAL(clicked(bool)), this, SLOT(ui_element_change())); connect(cb, SIGNAL(clicked(bool)), this, SLOT(ui_element_change()));
connect(cb, SIGNAL(toggled(bool)), this, SIGNAL(toggled(bool))); connect(cb, SIGNAL(toggled(bool)), this, SIGNAL(toggled(bool)));
} }
break; break;
case EFFECT_FIELD_COMBO: case EFFECT_FIELD_COMBO:
{ {
ComboBoxEx* cb = new ComboBoxEx(); ComboBoxEx* cb = new ComboBoxEx();
ui_element = cb; ui_element = cb;
connect(cb, SIGNAL(activated(int)), this, SLOT(ui_element_change())); connect(cb, SIGNAL(activated(int)), this, SLOT(ui_element_change()));
} }
break; break;
case EFFECT_FIELD_FONT: case EFFECT_FIELD_FONT:
{ {
FontCombobox* fcb = new FontCombobox(); FontCombobox* fcb = new FontCombobox();
ui_element = fcb; ui_element = fcb;
connect(fcb, SIGNAL(activated(int)), this, SLOT(ui_element_change())); connect(fcb, SIGNAL(activated(int)), this, SLOT(ui_element_change()));
} }
break; break;
} }
} }
QVariant EffectField::get_previous_data() { QVariant EffectField::get_previous_data() {
switch (type) { switch (type) {
case EFFECT_FIELD_DOUBLE: return static_cast<LabelSlider*>(ui_element)->getPreviousValue(); case EFFECT_FIELD_DOUBLE: return static_cast<LabelSlider*>(ui_element)->getPreviousValue();
case EFFECT_FIELD_COLOR: return static_cast<ColorButton*>(ui_element)->getPreviousValue(); case EFFECT_FIELD_COLOR: return static_cast<ColorButton*>(ui_element)->getPreviousValue();
case EFFECT_FIELD_STRING: return static_cast<TextEditEx*>(ui_element)->getPreviousValue(); case EFFECT_FIELD_STRING: return static_cast<TextEditEx*>(ui_element)->getPreviousValue();
case EFFECT_FIELD_BOOL: return !static_cast<QCheckBox*>(ui_element)->isChecked(); case EFFECT_FIELD_BOOL: return !static_cast<QCheckBox*>(ui_element)->isChecked();
case EFFECT_FIELD_COMBO: return static_cast<ComboBoxEx*>(ui_element)->getPreviousIndex(); case EFFECT_FIELD_COMBO: return static_cast<ComboBoxEx*>(ui_element)->getPreviousIndex();
case EFFECT_FIELD_FONT: return static_cast<FontCombobox*>(ui_element)->getPreviousValue(); case EFFECT_FIELD_FONT: return static_cast<FontCombobox*>(ui_element)->getPreviousValue();
} }
return QVariant(); return QVariant();
} }
QVariant EffectField::get_current_data() { QVariant EffectField::get_current_data() {
switch (type) { switch (type) {
case EFFECT_FIELD_DOUBLE: return static_cast<LabelSlider*>(ui_element)->value(); case EFFECT_FIELD_DOUBLE: return static_cast<LabelSlider*>(ui_element)->value();
case EFFECT_FIELD_COLOR: return static_cast<ColorButton*>(ui_element)->get_color(); case EFFECT_FIELD_COLOR: return static_cast<ColorButton*>(ui_element)->get_color();
case EFFECT_FIELD_STRING: return static_cast<TextEditEx*>(ui_element)->getPlainTextEx(); case EFFECT_FIELD_STRING: return static_cast<TextEditEx*>(ui_element)->getPlainTextEx();
case EFFECT_FIELD_BOOL: return static_cast<QCheckBox*>(ui_element)->isChecked(); case EFFECT_FIELD_BOOL: return static_cast<QCheckBox*>(ui_element)->isChecked();
case EFFECT_FIELD_COMBO: return static_cast<ComboBoxEx*>(ui_element)->currentIndex(); case EFFECT_FIELD_COMBO: return static_cast<ComboBoxEx*>(ui_element)->currentIndex();
case EFFECT_FIELD_FONT: return static_cast<FontCombobox*>(ui_element)->currentText(); case EFFECT_FIELD_FONT: return static_cast<FontCombobox*>(ui_element)->currentText();
} }
return QVariant(); return QVariant();
} }
double EffectField::frameToTimecode(long frame) { double EffectField::frameToTimecode(long frame) {
return ((double) frame / parent_row->parent_effect->parent_clip->sequence->frame_rate); return ((double) frame / parent_row->parent_effect->parent_clip->sequence->frame_rate);
} }
long EffectField::timecodeToFrame(double timecode) { long EffectField::timecodeToFrame(double timecode) {
return qRound(timecode * parent_row->parent_effect->parent_clip->sequence->frame_rate); return qRound(timecode * parent_row->parent_effect->parent_clip->sequence->frame_rate);
} }
void EffectField::set_current_data(const QVariant& data) { void EffectField::set_current_data(const QVariant& data) {
switch (type) { switch (type) {
case EFFECT_FIELD_DOUBLE: return static_cast<LabelSlider*>(ui_element)->set_value(data.toDouble(), false); case EFFECT_FIELD_DOUBLE: return static_cast<LabelSlider*>(ui_element)->set_value(data.toDouble(), false);
case EFFECT_FIELD_COLOR: return static_cast<ColorButton*>(ui_element)->set_color(data.value<QColor>()); case EFFECT_FIELD_COLOR: return static_cast<ColorButton*>(ui_element)->set_color(data.value<QColor>());
case EFFECT_FIELD_STRING: return static_cast<TextEditEx*>(ui_element)->setPlainTextEx(data.toString()); case EFFECT_FIELD_STRING: return static_cast<TextEditEx*>(ui_element)->setPlainTextEx(data.toString());
case EFFECT_FIELD_BOOL: return static_cast<QCheckBox*>(ui_element)->setChecked(data.toBool()); case EFFECT_FIELD_BOOL: return static_cast<QCheckBox*>(ui_element)->setChecked(data.toBool());
case EFFECT_FIELD_COMBO: return static_cast<ComboBoxEx*>(ui_element)->setCurrentIndexEx(data.toInt()); case EFFECT_FIELD_COMBO: return static_cast<ComboBoxEx*>(ui_element)->setCurrentIndexEx(data.toInt());
case EFFECT_FIELD_FONT: return static_cast<FontCombobox*>(ui_element)->setCurrentTextEx(data.toString()); case EFFECT_FIELD_FONT: return static_cast<FontCombobox*>(ui_element)->setCurrentTextEx(data.toString());
} }
} }
void EffectField::get_keyframe_data(double timecode, int &before, int &after, double &progress) { void EffectField::get_keyframe_data(double timecode, int &before, int &after, double &progress) {
int before_keyframe_index = -1; int before_keyframe_index = -1;
int after_keyframe_index = -1; int after_keyframe_index = -1;
long before_keyframe_time = LONG_MIN; long before_keyframe_time = LONG_MIN;
long after_keyframe_time = LONG_MAX; long after_keyframe_time = LONG_MAX;
long frame = timecodeToFrame(timecode); long frame = timecodeToFrame(timecode);
for (int i=0;i<keyframes.size();i++) { for (int i=0;i<keyframes.size();i++) {
long eval_keyframe_time = keyframes.at(i).time; long eval_keyframe_time = keyframes.at(i).time;
if (eval_keyframe_time == frame) { if (eval_keyframe_time == frame) {
before = i; before = i;
after = i; after = i;
return; return;
} else if (eval_keyframe_time < frame && eval_keyframe_time > before_keyframe_time) { } else if (eval_keyframe_time < frame && eval_keyframe_time > before_keyframe_time) {
before_keyframe_index = i; before_keyframe_index = i;
before_keyframe_time = eval_keyframe_time; before_keyframe_time = eval_keyframe_time;
} else if (eval_keyframe_time > frame && eval_keyframe_time < after_keyframe_time) { } else if (eval_keyframe_time > frame && eval_keyframe_time < after_keyframe_time) {
after_keyframe_index = i; after_keyframe_index = i;
after_keyframe_time = eval_keyframe_time; after_keyframe_time = eval_keyframe_time;
} }
} }
if ((type == EFFECT_FIELD_DOUBLE || type == EFFECT_FIELD_COLOR) && (before_keyframe_index > -1 && after_keyframe_index > -1)) { if ((type == EFFECT_FIELD_DOUBLE || type == EFFECT_FIELD_COLOR) && (before_keyframe_index > -1 && after_keyframe_index > -1)) {
// interpolate // interpolate
before = before_keyframe_index; before = before_keyframe_index;
after = after_keyframe_index; after = after_keyframe_index;
progress = (timecode-frameToTimecode(before_keyframe_time))/(frameToTimecode(after_keyframe_time)-frameToTimecode(before_keyframe_time));
if (keyframes.at(before).type == KEYFRAME_TYPE_HOLD) { } else if (before_keyframe_index > -1) {
progress = 0; before = before_keyframe_index;
} else { after = before_keyframe_index;
// TODO replace with bezier function } else {
progress = (timecode-frameToTimecode(before_keyframe_time))/(frameToTimecode(after_keyframe_time)-frameToTimecode(before_keyframe_time)); before = after_keyframe_index;
} after = after_keyframe_index;
} else if (before_keyframe_index > -1) { }
before = before_keyframe_index;
after = before_keyframe_index;
} else {
before = after_keyframe_index;
after = after_keyframe_index;
}
} }
bool EffectField::hasKeyframes() { bool EffectField::hasKeyframes() {
return (parent_row->isKeyframing() && keyframes.size() > 0); return (parent_row->isKeyframing() && keyframes.size() > 0);
} }
QVariant EffectField::validate_keyframe_data(double timecode, bool async) { QVariant EffectField::validate_keyframe_data(double timecode, bool async) {
if (hasKeyframes()) { if (hasKeyframes()) {
int before_keyframe; int before_keyframe;
int after_keyframe; int after_keyframe;
double progress; double progress;
get_keyframe_data(timecode, before_keyframe, after_keyframe, progress); get_keyframe_data(timecode, before_keyframe, after_keyframe, progress);
/*int kf_type = (progress < 0.5) ? parent_row->keyframe_types.at(before_keyframe) : parent_row->keyframe_types.at(after_keyframe); const QVariant& before_data = keyframes.at(before_keyframe).data;
if (kf_type == KEYFRAME_TYPE_BEZIER) { switch (type) {
double x = (8.0 * progress) - 4.0; case EFFECT_FIELD_DOUBLE:
progress = 1.0 / (1.0 + qPow(M_E, -x)); {
progress *= 1.0373; double value;
progress -= 0.01865; if (before_keyframe == after_keyframe) {
}*/ value = keyframes.at(before_keyframe).data.toDouble();
} else {
const EffectKeyframe& before_key = keyframes.at(before_keyframe);
const EffectKeyframe& after_key = keyframes.at(after_keyframe);
const QVariant& before_data = keyframes.at(before_keyframe).data; double before_dbl = before_key.data.toDouble();
switch (type) { double after_dbl = after_key.data.toDouble();
case EFFECT_FIELD_DOUBLE:
{ if (before_key.type == KEYFRAME_TYPE_HOLD) {
double value; // hold
if (before_keyframe == after_keyframe) { value = before_dbl;
value = keyframes.at(before_keyframe).data.toDouble(); } else if (before_key.type == KEYFRAME_TYPE_BEZIER || after_key.type == KEYFRAME_TYPE_BEZIER) {
} else { // bezier interpolation
double before_dbl = keyframes.at(before_keyframe).data.toDouble(); if (before_key.type == KEYFRAME_TYPE_BEZIER && after_key.type == KEYFRAME_TYPE_BEZIER) {
double after_dbl = keyframes.at(after_keyframe).data.toDouble(); // cubic bezier
value = double_lerp(before_dbl, after_dbl, progress); double t = cubic_t_from_x(timecode*parent_row->parent_effect->parent_clip->sequence->frame_rate, before_key.time, before_key.time+before_key.post_handle_x, after_key.time+after_key.pre_handle_x, after_key.time);
} value = cubic_from_t(before_dbl, before_dbl+before_key.post_handle_y, after_dbl+after_key.pre_handle_y, after_dbl, t);
if (async) { } else if (after_key.type == KEYFRAME_TYPE_LINEAR) { // quadratic bezier
return value; // last keyframe is the bezier one
} double t = quad_t_from_x(timecode*parent_row->parent_effect->parent_clip->sequence->frame_rate, before_key.time, before_key.time+before_key.post_handle_x, after_key.time);
static_cast<LabelSlider*>(ui_element)->set_value(value, false); value = quad_from_t(before_dbl, before_dbl+before_key.post_handle_y, after_dbl, t);
} } else {
break; // this keyframe is the bezier one
case EFFECT_FIELD_COLOR: double t = quad_t_from_x(timecode*parent_row->parent_effect->parent_clip->sequence->frame_rate, before_key.time, after_key.time+after_key.pre_handle_x, after_key.time);
{ value = quad_from_t(before_dbl, after_dbl+after_key.pre_handle_y, after_dbl, t);
QColor value; }
if (before_keyframe == after_keyframe) { } else {
value = keyframes.at(before_keyframe).data.value<QColor>(); // linear
} else { value = double_lerp(before_dbl, after_dbl, progress);
QColor before_data = keyframes.at(before_keyframe).data.value<QColor>(); }
QColor after_data = keyframes.at(after_keyframe).data.value<QColor>(); }
value = QColor(lerp(before_data.red(), after_data.red(), progress), lerp(before_data.green(), after_data.green(), progress), lerp(before_data.blue(), after_data.blue(), progress)); if (async) {
} return value;
if (async) { }
return value; static_cast<LabelSlider*>(ui_element)->set_value(value, false);
} }
static_cast<ColorButton*>(ui_element)->set_color(value); break;
} case EFFECT_FIELD_COLOR:
break; {
case EFFECT_FIELD_STRING: QColor value;
if (async) { if (before_keyframe == after_keyframe) {
return before_data; value = keyframes.at(before_keyframe).data.value<QColor>();
} } else {
static_cast<TextEditEx*>(ui_element)->setPlainTextEx(before_data.toString()); QColor before_data = keyframes.at(before_keyframe).data.value<QColor>();
break; QColor after_data = keyframes.at(after_keyframe).data.value<QColor>();
case EFFECT_FIELD_BOOL: value = QColor(lerp(before_data.red(), after_data.red(), progress), lerp(before_data.green(), after_data.green(), progress), lerp(before_data.blue(), after_data.blue(), progress));
if (async) { }
return before_data; if (async) {
} return value;
static_cast<QCheckBox*>(ui_element)->setChecked(before_data.toBool()); }
break; static_cast<ColorButton*>(ui_element)->set_color(value);
case EFFECT_FIELD_COMBO: }
if (async) { break;
return before_data; case EFFECT_FIELD_STRING:
} if (async) {
static_cast<ComboBoxEx*>(ui_element)->setCurrentIndexEx(before_data.toInt()); return before_data;
break; }
case EFFECT_FIELD_FONT: static_cast<TextEditEx*>(ui_element)->setPlainTextEx(before_data.toString());
if (async) { break;
return before_data; case EFFECT_FIELD_BOOL:
} if (async) {
static_cast<FontCombobox*>(ui_element)->setCurrentTextEx(before_data.toString()); return before_data;
break; }
} static_cast<QCheckBox*>(ui_element)->setChecked(before_data.toBool());
} break;
return QVariant(); case EFFECT_FIELD_COMBO:
if (async) {
return before_data;
}
static_cast<ComboBoxEx*>(ui_element)->setCurrentIndexEx(before_data.toInt());
break;
case EFFECT_FIELD_FONT:
if (async) {
return before_data;
}
static_cast<FontCombobox*>(ui_element)->setCurrentTextEx(before_data.toString());
break;
}
}
return QVariant();
} }
void EffectField::ui_element_change() { void EffectField::ui_element_change() {
bool dragging_double = (type == EFFECT_FIELD_DOUBLE && static_cast<LabelSlider*>(ui_element)->is_dragging()); bool dragging_double = (type == EFFECT_FIELD_DOUBLE && static_cast<LabelSlider*>(ui_element)->is_dragging());
ComboAction* ca = NULL; ComboAction* ca = NULL;
if (!dragging_double) ca = new ComboAction(); if (!dragging_double) ca = new ComboAction();
make_key_from_change(ca); make_key_from_change(ca);
if (!dragging_double) undo_stack.push(ca); if (!dragging_double) undo_stack.push(ca);
emit changed(); emit changed();
} }
void EffectField::make_key_from_change(ComboAction* ca) { void EffectField::make_key_from_change(ComboAction* ca) {
if (parent_row->isKeyframing()) { if (parent_row->isKeyframing()) {
parent_row->set_keyframe_now(ca); parent_row->set_keyframe_now(ca);
} else if (ca != NULL) { } else if (ca != NULL) {
// set undo // set undo
ca->append(new EffectFieldUndo(this)); ca->append(new EffectFieldUndo(this));
} }
} }
QWidget* EffectField::get_ui_element() { QWidget* EffectField::get_ui_element() {
return ui_element; return ui_element;
} }
void EffectField::set_enabled(bool e) { void EffectField::set_enabled(bool e) {
ui_element->setEnabled(e); ui_element->setEnabled(e);
} }
double EffectField::get_double_value(double timecode, bool async) { double EffectField::get_double_value(double timecode, bool async) {
if (async && hasKeyframes()) { if (async && hasKeyframes()) {
return validate_keyframe_data(timecode, true).toDouble(); return validate_keyframe_data(timecode, true).toDouble();
} }
validate_keyframe_data(timecode); validate_keyframe_data(timecode);
return static_cast<LabelSlider*>(ui_element)->value(); return static_cast<LabelSlider*>(ui_element)->value();
} }
void EffectField::set_double_value(double v) { void EffectField::set_double_value(double v) {
static_cast<LabelSlider*>(ui_element)->set_value(v, false); static_cast<LabelSlider*>(ui_element)->set_value(v, false);
} }
void EffectField::set_double_default_value(double v) { void EffectField::set_double_default_value(double v) {
static_cast<LabelSlider*>(ui_element)->set_default_value(v); static_cast<LabelSlider*>(ui_element)->set_default_value(v);
} }
void EffectField::set_double_minimum_value(double v) { void EffectField::set_double_minimum_value(double v) {
static_cast<LabelSlider*>(ui_element)->set_minimum_value(v); static_cast<LabelSlider*>(ui_element)->set_minimum_value(v);
} }
void EffectField::set_double_maximum_value(double v) { void EffectField::set_double_maximum_value(double v) {
static_cast<LabelSlider*>(ui_element)->set_maximum_value(v); static_cast<LabelSlider*>(ui_element)->set_maximum_value(v);
} }
void EffectField::add_combo_item(const QString& name, const QVariant& data) { void EffectField::add_combo_item(const QString& name, const QVariant& data) {
static_cast<ComboBoxEx*>(ui_element)->addItem(name, data); static_cast<ComboBoxEx*>(ui_element)->addItem(name, data);
} }
int EffectField::get_combo_index(double timecode, bool async) { int EffectField::get_combo_index(double timecode, bool async) {
if (async && hasKeyframes()) { if (async && hasKeyframes()) {
return validate_keyframe_data(timecode, true).toInt(); return validate_keyframe_data(timecode, true).toInt();
} }
validate_keyframe_data(timecode); validate_keyframe_data(timecode);
return static_cast<ComboBoxEx*>(ui_element)->currentIndex(); return static_cast<ComboBoxEx*>(ui_element)->currentIndex();
} }
const QVariant EffectField::get_combo_data(double timecode) { const QVariant EffectField::get_combo_data(double timecode) {
validate_keyframe_data(timecode); validate_keyframe_data(timecode);
return static_cast<ComboBoxEx*>(ui_element)->currentData(); return static_cast<ComboBoxEx*>(ui_element)->currentData();
} }
const QString EffectField::get_combo_string(double timecode) { const QString EffectField::get_combo_string(double timecode) {
validate_keyframe_data(timecode); validate_keyframe_data(timecode);
return static_cast<ComboBoxEx*>(ui_element)->currentText(); return static_cast<ComboBoxEx*>(ui_element)->currentText();
} }
void EffectField::set_combo_index(int index) { void EffectField::set_combo_index(int index) {
static_cast<ComboBoxEx*>(ui_element)->setCurrentIndexEx(index); static_cast<ComboBoxEx*>(ui_element)->setCurrentIndexEx(index);
} }
void EffectField::set_combo_string(const QString& s) { void EffectField::set_combo_string(const QString& s) {
static_cast<ComboBoxEx*>(ui_element)->setCurrentTextEx(s); static_cast<ComboBoxEx*>(ui_element)->setCurrentTextEx(s);
} }
bool EffectField::get_bool_value(double timecode, bool async) { bool EffectField::get_bool_value(double timecode, bool async) {
if (async && hasKeyframes()) { if (async && hasKeyframes()) {
return validate_keyframe_data(timecode, true).toBool(); return validate_keyframe_data(timecode, true).toBool();
} }
validate_keyframe_data(timecode); validate_keyframe_data(timecode);
return static_cast<QCheckBox*>(ui_element)->isChecked(); return static_cast<QCheckBox*>(ui_element)->isChecked();
} }
void EffectField::set_bool_value(bool b) { void EffectField::set_bool_value(bool b) {
return static_cast<QCheckBox*>(ui_element)->setChecked(b); return static_cast<QCheckBox*>(ui_element)->setChecked(b);
} }
const QString EffectField::get_string_value(double timecode, bool async) { const QString EffectField::get_string_value(double timecode, bool async) {
if (async && hasKeyframes()) { if (async && hasKeyframes()) {
return validate_keyframe_data(timecode, true).toString(); return validate_keyframe_data(timecode, true).toString();
} }
validate_keyframe_data(timecode); validate_keyframe_data(timecode);
return static_cast<TextEditEx*>(ui_element)->getPlainTextEx(); return static_cast<TextEditEx*>(ui_element)->getPlainTextEx();
} }
void EffectField::set_string_value(const QString& s) { void EffectField::set_string_value(const QString& s) {
static_cast<TextEditEx*>(ui_element)->setPlainTextEx(s); static_cast<TextEditEx*>(ui_element)->setPlainTextEx(s);
} }
const QString EffectField::get_font_name(double timecode, bool async) { const QString EffectField::get_font_name(double timecode, bool async) {
if (async && hasKeyframes()) { if (async && hasKeyframes()) {
return validate_keyframe_data(timecode, true).toString(); return validate_keyframe_data(timecode, true).toString();
} }
validate_keyframe_data(timecode); validate_keyframe_data(timecode);
return static_cast<FontCombobox*>(ui_element)->currentText(); return static_cast<FontCombobox*>(ui_element)->currentText();
} }
void EffectField::set_font_name(const QString& s) { void EffectField::set_font_name(const QString& s) {
static_cast<FontCombobox*>(ui_element)->setCurrentText(s); static_cast<FontCombobox*>(ui_element)->setCurrentText(s);
} }
QColor EffectField::get_color_value(double timecode, bool async) { QColor EffectField::get_color_value(double timecode, bool async) {
if (async && hasKeyframes()) { if (async && hasKeyframes()) {
return validate_keyframe_data(timecode, true).value<QColor>(); return validate_keyframe_data(timecode, true).value<QColor>();
} }
validate_keyframe_data(timecode); validate_keyframe_data(timecode);
return static_cast<ColorButton*>(ui_element)->get_color(); return static_cast<ColorButton*>(ui_element)->get_color();
} }
void EffectField::set_color_value(QColor color) { void EffectField::set_color_value(QColor color) {
static_cast<ColorButton*>(ui_element)->set_color(color); static_cast<ColorButton*>(ui_element)->set_color(color);
} }
+2 -11
View File
@@ -12,20 +12,11 @@
#include <QVariant> #include <QVariant>
#include <QVector> #include <QVector>
#include "keyframe.h"
class EffectRow; class EffectRow;
class ComboAction; class ComboAction;
class EffectKeyframe {
public:
long time;
int type;
QVariant data;
// only for bezier type
QPointF pre_handle;
QPointF post_handle;
};
class EffectField : public QObject { class EffectField : public QObject {
Q_OBJECT Q_OBJECT
public: public:
+132 -132
View File
@@ -17,123 +17,123 @@
#include "ui/clickablelabel.h" #include "ui/clickablelabel.h"
EffectRow::EffectRow(Effect *parent, bool save, QGridLayout *uilayout, const QString &n, int row) : EffectRow::EffectRow(Effect *parent, bool save, QGridLayout *uilayout, const QString &n, int row) :
parent_effect(parent), parent_effect(parent),
savable(save), savable(save),
keyframing(false), keyframing(false),
ui(uilayout), ui(uilayout),
name(n), name(n),
ui_row(row), ui_row(row),
just_made_unsafe_keyframe(false) just_made_unsafe_keyframe(false)
{ {
label = new ClickableLabel(name); label = new ClickableLabel(name + ":");
ui->addWidget(label, row, 0); ui->addWidget(label, row, 0);
if (parent_effect->meta->type != EFFECT_TYPE_TRANSITION) { if (parent_effect->meta->type != EFFECT_TYPE_TRANSITION) {
connect(label, SIGNAL(clicked()), this, SLOT(focus_row())); connect(label, SIGNAL(clicked()), this, SLOT(focus_row()));
keyframe_nav = new KeyframeNavigator(); keyframe_nav = new KeyframeNavigator();
connect(keyframe_nav, SIGNAL(goto_previous_key()), this, SLOT(goto_previous_key())); connect(keyframe_nav, SIGNAL(goto_previous_key()), this, SLOT(goto_previous_key()));
connect(keyframe_nav, SIGNAL(toggle_key()), this, SLOT(toggle_key())); connect(keyframe_nav, SIGNAL(toggle_key()), this, SLOT(toggle_key()));
connect(keyframe_nav, SIGNAL(goto_next_key()), this, SLOT(goto_next_key())); connect(keyframe_nav, SIGNAL(goto_next_key()), this, SLOT(goto_next_key()));
connect(keyframe_nav, SIGNAL(keyframe_enabled_changed(bool)), this, SLOT(set_keyframe_enabled(bool))); connect(keyframe_nav, SIGNAL(keyframe_enabled_changed(bool)), this, SLOT(set_keyframe_enabled(bool)));
connect(keyframe_nav, SIGNAL(clicked()), this, SLOT(focus_row())); connect(keyframe_nav, SIGNAL(clicked()), this, SLOT(focus_row()));
ui->addWidget(keyframe_nav, row, 6); ui->addWidget(keyframe_nav, row, 6);
} }
} }
bool EffectRow::isKeyframing() { bool EffectRow::isKeyframing() {
return keyframing; return keyframing;
} }
void EffectRow::setKeyframing(bool b) { void EffectRow::setKeyframing(bool b) {
if (parent_effect->meta->type != EFFECT_TYPE_TRANSITION) { if (parent_effect->meta->type != EFFECT_TYPE_TRANSITION) {
keyframing = b; keyframing = b;
keyframe_nav->enable_keyframes(b); keyframe_nav->enable_keyframes(b);
} }
} }
void EffectRow::set_keyframe_enabled(bool enabled) { void EffectRow::set_keyframe_enabled(bool enabled) {
if (enabled) { if (enabled) {
ComboAction* ca = new ComboAction(); ComboAction* ca = new ComboAction();
set_keyframe_now(ca); set_keyframe_now(ca);
undo_stack.push(ca); undo_stack.push(ca);
} else { } else {
if (QMessageBox::question(panel_effect_controls, "Disable Keyframes", "Disabling keyframes will delete all current keyframes. Are you sure you want to do this?", QMessageBox::Yes, QMessageBox::No) == QMessageBox::Yes) { if (QMessageBox::question(panel_effect_controls, "Disable Keyframes", "Disabling keyframes will delete all current keyframes. Are you sure you want to do this?", QMessageBox::Yes, QMessageBox::No) == QMessageBox::Yes) {
// clear // clear
ComboAction* ca = new ComboAction(); ComboAction* ca = new ComboAction();
for (int i=0;i<fieldCount();i++) { for (int i=0;i<fieldCount();i++) {
EffectField* f = field(i); EffectField* f = field(i);
for (int j=0;j<f->keyframes.size();j++) { for (int j=0;j<f->keyframes.size();j++) {
ca->append(new KeyframeDelete(f, 0)); ca->append(new KeyframeDelete(f, 0));
} }
} }
undo_stack.push(ca); undo_stack.push(ca);
panel_effect_controls->update_keyframes(); panel_effect_controls->update_keyframes();
} else { } else {
setKeyframing(true); setKeyframing(true);
} }
} }
} }
void EffectRow::goto_previous_key() { void EffectRow::goto_previous_key() {
long key = LONG_MIN; long key = LONG_MIN;
Clip* c = parent_effect->parent_clip; Clip* c = parent_effect->parent_clip;
for (int i=0;i<fieldCount();i++) { for (int i=0;i<fieldCount();i++) {
EffectField* f = field(i); EffectField* f = field(i);
for (int j=0;j<f->keyframes.size();j++) { for (int j=0;j<f->keyframes.size();j++) {
long comp = f->keyframes.at(i).time - c->clip_in + c->timeline_in; long comp = f->keyframes.at(j).time - c->clip_in + c->timeline_in;
if (comp < sequence->playhead) { if (comp < sequence->playhead) {
key = qMax(comp, key); key = qMax(comp, key);
} }
} }
} }
if (key != LONG_MIN) panel_sequence_viewer->seek(key); if (key != LONG_MIN) panel_sequence_viewer->seek(key);
} }
void EffectRow::toggle_key() { void EffectRow::toggle_key() {
QVector<EffectField*> key_fields; QVector<EffectField*> key_fields;
QVector<int> key_field_index; QVector<int> key_field_index;
Clip* c = parent_effect->parent_clip; Clip* c = parent_effect->parent_clip;
for (int j=0;j<fieldCount();j++) { for (int j=0;j<fieldCount();j++) {
EffectField* f = field(j); EffectField* f = field(j);
for (int i=0;i<f->keyframes.size();i++) { for (int i=0;i<f->keyframes.size();i++) {
long comp = c->timeline_in - c->clip_in + f->keyframes.at(i).time; long comp = c->timeline_in - c->clip_in + f->keyframes.at(i).time;
if (comp == sequence->playhead) { if (comp == sequence->playhead) {
key_fields.append(f); key_fields.append(f);
key_field_index.append(i); key_field_index.append(i);
} }
} }
} }
ComboAction* ca = new ComboAction(); ComboAction* ca = new ComboAction();
if (key_fields.size() == 0) { if (key_fields.size() == 0) {
// keyframe doesn't exist, set one // keyframe doesn't exist, set one
set_keyframe_now(ca); set_keyframe_now(ca);
} else { } else {
for (int i=0;i<key_fields.size();i++) { for (int i=0;i<key_fields.size();i++) {
// TODO: these values must be sorted to work correctly // TODO: these values must be sorted to work correctly
ca->append(new KeyframeDelete(key_fields.at(i), key_field_index.at(i))); ca->append(new KeyframeDelete(key_fields.at(i), key_field_index.at(i)));
} }
} }
undo_stack.push(ca); undo_stack.push(ca);
panel_effect_controls->update_keyframes(); panel_effect_controls->update_keyframes();
panel_sequence_viewer->viewer_widget->update(); panel_sequence_viewer->viewer_widget->update();
} }
void EffectRow::goto_next_key() { void EffectRow::goto_next_key() {
long key = LONG_MAX; long key = LONG_MAX;
Clip* c = parent_effect->parent_clip; Clip* c = parent_effect->parent_clip;
for (int i=0;i<fieldCount();i++) { for (int i=0;i<fieldCount();i++) {
EffectField* f = field(i); EffectField* f = field(i);
for (int j=0;j<f->keyframes.size();j++) { for (int j=0;j<f->keyframes.size();j++) {
long comp = f->keyframes.at(i).time - c->clip_in + c->timeline_in; long comp = f->keyframes.at(j).time - c->clip_in + c->timeline_in;
if (comp > sequence->playhead) { if (comp > sequence->playhead) {
key = qMin(comp, key); key = qMin(comp, key);
} }
} }
} }
if (key != LONG_MAX) panel_sequence_viewer->seek(key); if (key != LONG_MAX) panel_sequence_viewer->seek(key);
} }
void EffectRow::focus_row() { void EffectRow::focus_row() {
@@ -141,58 +141,58 @@ void EffectRow::focus_row() {
} }
EffectField* EffectRow::add_field(int type, const QString& id, int colspan) { EffectField* EffectRow::add_field(int type, const QString& id, int colspan) {
EffectField* field = new EffectField(this, type, id); EffectField* field = new EffectField(this, type, id);
if (parent_effect->meta->type != EFFECT_TYPE_TRANSITION) connect(field, SIGNAL(clicked()), this, SLOT(focus_row())); if (parent_effect->meta->type != EFFECT_TYPE_TRANSITION) connect(field, SIGNAL(clicked()), this, SLOT(focus_row()));
fields.append(field); fields.append(field);
QWidget* element = field->get_ui_element(); QWidget* element = field->get_ui_element();
ui->addWidget(element, ui_row, fields.size(), 1, colspan); ui->addWidget(element, ui_row, fields.size(), 1, colspan);
connect(field, SIGNAL(changed()), parent_effect, SLOT(field_changed())); connect(field, SIGNAL(changed()), parent_effect, SLOT(field_changed()));
return field; return field;
} }
EffectRow::~EffectRow() { EffectRow::~EffectRow() {
for (int i=0;i<fields.size();i++) { for (int i=0;i<fields.size();i++) {
delete fields.at(i); delete fields.at(i);
} }
} }
void EffectRow::set_keyframe_now(ComboAction* ca) { void EffectRow::set_keyframe_now(ComboAction* ca) {
int index = -1; int index = -1;
long time = sequence->playhead-parent_effect->parent_clip->timeline_in+parent_effect->parent_clip->clip_in; long time = sequence->playhead-parent_effect->parent_clip->timeline_in+parent_effect->parent_clip->clip_in;
for (int j=0;j<fieldCount();j++) { for (int j=0;j<fieldCount();j++) {
EffectField* f = field(j); EffectField* f = field(j);
for (int i=0;i<f->keyframes.size();i++) { for (int i=0;i<f->keyframes.size();i++) {
if (f->keyframes.at(i).time == time) { if (f->keyframes.at(i).time == time) {
index = i; index = i;
break; break;
} }
} }
} }
KeyframeSet* ks = new KeyframeSet(this, index, time, just_made_unsafe_keyframe); KeyframeSet* ks = new KeyframeSet(this, index, time, just_made_unsafe_keyframe);
if (ca != NULL) { if (ca != NULL) {
just_made_unsafe_keyframe = false; just_made_unsafe_keyframe = false;
ca->append(ks); ca->append(ks);
} else { } else {
if (index == -1) just_made_unsafe_keyframe = true; if (index == -1) just_made_unsafe_keyframe = true;
ks->redo(); ks->redo();
delete ks; delete ks;
} }
panel_effect_controls->update_keyframes(); panel_effect_controls->update_keyframes();
} }
void EffectRow::delete_keyframe_at_time(ComboAction* ca, long time) { void EffectRow::delete_keyframe_at_time(ComboAction* ca, long time) {
for (int j=0;j<fieldCount();j++) { for (int j=0;j<fieldCount();j++) {
EffectField* f = field(j); EffectField* f = field(j);
for (int i=0;i<f->keyframes.size();i++) { for (int i=0;i<f->keyframes.size();i++) {
if (f->keyframes.at(i).time == time) { if (f->keyframes.at(i).time == time) {
ca->append(new KeyframeDelete(f, i)); ca->append(new KeyframeDelete(f, i));
break; break;
} }
} }
} }
} }
const QString &EffectRow::get_name() { const QString &EffectRow::get_name() {
@@ -200,9 +200,9 @@ const QString &EffectRow::get_name() {
} }
EffectField* EffectRow::field(int i) { EffectField* EffectRow::field(int i) {
return fields.at(i); return fields.at(i);
} }
int EffectRow::fieldCount() { int EffectRow::fieldCount() {
return fields.size(); return fields.size();
} }
+7
View File
@@ -1,2 +1,9 @@
#include "keyframe.h" #include "keyframe.h"
EffectKeyframe::EffectKeyframe() {
pre_handle_x = -40;
pre_handle_y = 0;
post_handle_x = 40;
post_handle_y = 0;
}
+11 -7
View File
@@ -1,17 +1,21 @@
#ifndef KEYFRAME_H #ifndef KEYFRAME_H
#define KEYFRAME_H #define KEYFRAME_H
#include <QVariant> #include <QVariant>
#include <QPoint>
class KeyframeData class EffectKeyframe {
{
public: public:
EffectKeyframe();
long time;
int type;
QVariant data; QVariant data;
QPoint handle_pre;
QPoint handle_post; // only for bezier type
double pre_handle_x;
double pre_handle_y;
double post_handle_x;
double post_handle_y;
}; };
#endif // KEYFRAME_H #endif // KEYFRAME_H
+20 -20
View File
@@ -738,20 +738,20 @@ void MediaRename::redo() {
} }
KeyframeDelete::KeyframeDelete(EffectField *ifield, int iindex) : KeyframeDelete::KeyframeDelete(EffectField *ifield, int iindex) :
field(ifield), field(ifield),
index(iindex), index(iindex),
old_project_changed(mainWindow->isWindowModified()) old_project_changed(mainWindow->isWindowModified())
{} {}
void KeyframeDelete::undo() { void KeyframeDelete::undo() {
field->keyframes.insert(index, deleted_key); field->keyframes.insert(index, deleted_key);
mainWindow->setWindowModified(old_project_changed); mainWindow->setWindowModified(old_project_changed);
} }
void KeyframeDelete::redo() { void KeyframeDelete::redo() {
deleted_key = field->keyframes.at(index); deleted_key = field->keyframes.at(index);
field->keyframes.removeAt(index); field->keyframes.removeAt(index);
mainWindow->setWindowModified(true); mainWindow->setWindowModified(true);
} }
KeyframeSet::KeyframeSet(EffectRow* r, int i, long t, bool justMadeKeyframe) : KeyframeSet::KeyframeSet(EffectRow* r, int i, long t, bool justMadeKeyframe) :
@@ -771,7 +771,7 @@ KeyframeSet::KeyframeSet(EffectRow* r, int i, long t, bool justMadeKeyframe) :
if (field->type == EFFECT_FIELD_DOUBLE) { if (field->type == EFFECT_FIELD_DOUBLE) {
old_values[i] = static_cast<LabelSlider*>(field->ui_element)->getPreviousValue(); old_values[i] = static_cast<LabelSlider*>(field->ui_element)->getPreviousValue();
} else { } else {
old_values[i] = field->keyframes.at(index).data; old_values[i] = field->keyframes.at(index).data;
} }
} }
new_values[i] = field->get_current_data(); new_values[i] = field->get_current_data();
@@ -781,12 +781,12 @@ KeyframeSet::KeyframeSet(EffectRow* r, int i, long t, bool justMadeKeyframe) :
void KeyframeSet::undo() { void KeyframeSet::undo() {
if (enable_keyframes) row->setKeyframing(false); if (enable_keyframes) row->setKeyframing(false);
bool append = (index == -1 || just_made_keyframe); bool append = (index == -1 || just_made_keyframe);
for (int i=0;i<row->fieldCount();i++) { for (int i=0;i<row->fieldCount();i++) {
if (append) { if (append) {
row->field(i)->keyframes.removeLast(); row->field(i)->keyframes.removeLast();
} else { } else {
row->field(i)->keyframes[index].data = old_values.at(i); row->field(i)->keyframes[index].data = old_values.at(i);
} }
} }
@@ -797,15 +797,15 @@ void KeyframeSet::undo() {
void KeyframeSet::redo() { void KeyframeSet::redo() {
bool append = (index == -1 || (just_made_keyframe && !done)); bool append = (index == -1 || (just_made_keyframe && !done));
for (int i=0;i<row->fieldCount();i++) { for (int i=0;i<row->fieldCount();i++) {
EffectField* f = row->field(i); EffectField* f = row->field(i);
if (append) { if (append) {
EffectKeyframe k; EffectKeyframe k;
k.data = new_values.at(i); k.data = new_values.at(i);
k.time = time; k.time = time;
k.type = (f->keyframes.size() > 0) ? f->keyframes.last().type : EFFECT_KEYFRAME_LINEAR; k.type = (f->keyframes.size() > 0) ? f->keyframes.last().type : EFFECT_KEYFRAME_LINEAR;
f->keyframes.append(k); f->keyframes.append(k);
} else { } else {
f->keyframes[index].data = new_values.at(i); f->keyframes[index].data = new_values.at(i);
} }
} }
row->setKeyframing(true); row->setKeyframing(true);
@@ -1229,9 +1229,9 @@ void RippleAction::redo() {
ca->redo(); ca->redo();
} }
SetDouble::SetDouble(double* pointer, double new_value) : SetDouble::SetDouble(double* pointer, double old_value, double new_value) :
p(pointer), p(pointer),
oldval(*pointer), oldval(old_value),
newval(new_value), newval(new_value),
old_project_changed(mainWindow->isWindowModified()) old_project_changed(mainWindow->isWindowModified())
{} {}
+8 -8
View File
@@ -331,21 +331,21 @@ private:
class KeyframeDelete : public QUndoCommand { class KeyframeDelete : public QUndoCommand {
public: public:
KeyframeDelete(EffectField* ifield, int iindex); KeyframeDelete(EffectField* ifield, int iindex);
void undo(); void undo();
void redo(); void redo();
private: private:
EffectField* field; EffectField* field;
int index; int index;
bool done; bool done;
EffectKeyframe deleted_key; EffectKeyframe deleted_key;
bool old_project_changed; bool old_project_changed;
}; };
class KeyframeSet : public QUndoCommand { class KeyframeSet : public QUndoCommand {
public: public:
KeyframeSet(EffectRow* r, int i, long t, bool justMadeKeyframe); KeyframeSet(EffectRow* r, int i, long t, bool justMadeKeyframe);
void undo(); void undo();
void redo(); void redo();
QVector<QVariant> old_values; QVector<QVariant> old_values;
@@ -523,7 +523,7 @@ private:
class SetDouble : public QUndoCommand { class SetDouble : public QUndoCommand {
public: public:
SetDouble(double* pointer, double new_value); SetDouble(double* pointer, double old_value, double new_value);
void undo(); void undo();
void redo(); void redo();
private: private:
+201 -68
View File
@@ -11,11 +11,17 @@
#include "project/effectfield.h" #include "project/effectfield.h"
#include "ui/keyframedrawing.h" #include "ui/keyframedrawing.h"
#include "project/undo.h" #include "project/undo.h"
#include "project/effect.h"
#include "debug.h" #include "debug.h"
#define GRAPH_ZOOM_SPEED 0.05 #define GRAPH_ZOOM_SPEED 0.05
#define GRAPH_SIZE 100 #define GRAPH_SIZE 100
#define BEZIER_HANDLE_SIZE 3
#define BEZIER_HANDLE_NONE 1
#define BEZIER_HANDLE_PRE 2
#define BEZIER_HANDLE_POST 3
QColor get_curve_color(int index, int length) { QColor get_curve_color(int index, int length) {
QColor c; QColor c;
@@ -31,7 +37,8 @@ GraphView::GraphView(QWidget* parent) :
mousedown(false), mousedown(false),
zoom(1.0), zoom(1.0),
row(NULL), row(NULL),
moved_keys(false) moved_keys(false),
current_handle(BEZIER_HANDLE_NONE)
{ {
setMouseTracking(true); setMouseTracking(true);
} }
@@ -40,7 +47,8 @@ void GraphView::paintEvent(QPaintEvent *event) {
QPainter p(this); QPainter p(this);
if (panel_sequence_viewer->seq != NULL) { if (panel_sequence_viewer->seq != NULL) {
// draw lines // draw grid lines
//int graph_size = GRAPH_SIZE*zoom; //int graph_size = GRAPH_SIZE*zoom;
bool draw_text = true;//(fontMetrics().height() < graph_size && fontMetrics().width("0000") < graph_size); bool draw_text = true;//(fontMetrics().height() < graph_size && fontMetrics().width("0000") < graph_size);
@@ -75,53 +83,100 @@ void GraphView::paintEvent(QPaintEvent *event) {
QPen line_pen; QPen line_pen;
line_pen.setWidth(2); line_pen.setWidth(2);
for (int i=0;i<row->fieldCount();i++) { for (int i=0;i<row->fieldCount();i++) {
EffectField* field = row->field(i); EffectField* field = row->field(i);
if (field->type == EFFECT_FIELD_DOUBLE) { if (field->type == EFFECT_FIELD_DOUBLE && field_visibility.at(i)) {
// sort keyframes by time // sort keyframes by time
QVector<int> sorted_keys; QVector<int> sorted_keys;
for (int k=0;k<field->keyframes.size();k++) { for (int k=0;k<field->keyframes.size();k++) {
bool inserted = false; bool inserted = false;
for (int j=0;j<sorted_keys.size();j++) { for (int j=0;j<sorted_keys.size();j++) {
if (field->keyframes.at(sorted_keys.at(j)).time > field->keyframes.at(k).time) { if (field->keyframes.at(sorted_keys.at(j)).time > field->keyframes.at(k).time) {
sorted_keys.insert(j, k); sorted_keys.insert(j, k);
inserted = true; inserted = true;
break; break;
} }
} }
if (!inserted) { if (!inserted) {
sorted_keys.append(i); sorted_keys.append(k);
} }
} }
int last_key_x, last_key_y; int last_key_x, last_key_y;
// draw lines
for (int j=0;j<sorted_keys.size();j++) { for (int j=0;j<sorted_keys.size();j++) {
// draw lines const EffectKeyframe& key = field->keyframes.at(sorted_keys.at(j));
int key_index = sorted_keys.at(j);
int key_x = get_screen_x(field->keyframes.at(key_index).time); int key_x = get_screen_x(key.time);
int key_y = get_screen_y(field->keyframes.at(key_index).data.toDouble()); int key_y = get_screen_y(key.data.toDouble());
line_pen.setColor(get_curve_color(i, row->fieldCount())); line_pen.setColor(get_curve_color(i, row->fieldCount()));
p.setPen(line_pen); p.setPen(line_pen);
if (key_index == 0) { if (j == 0) {
p.drawLine(0, key_y, key_x, key_y); p.drawLine(0, key_y, key_x, key_y);
} else { } else {
p.drawLine(last_key_x, last_key_y, key_x, key_y); const EffectKeyframe& last_key = field->keyframes.at(sorted_keys.at(j-1));
if (last_key.type == KEYFRAME_TYPE_HOLD) {
// hold
p.drawLine(last_key_x, last_key_y, key_x, last_key_y);
p.drawLine(key_x, last_key_y, key_x, key_y);
} else if (last_key.type == KEYFRAME_TYPE_BEZIER || key.type == KEYFRAME_TYPE_BEZIER) {
QPainterPath bezier_path;
bezier_path.moveTo(last_key_x, last_key_y);
if (last_key.type == KEYFRAME_TYPE_BEZIER && key.type == KEYFRAME_TYPE_BEZIER) {
// cubic bezier
bezier_path.cubicTo(
QPointF(last_key_x+last_key.post_handle_x, last_key_y+last_key.post_handle_y),
QPointF(key_x+key.pre_handle_x, key_y+key.pre_handle_y),
QPointF(key_x, key_y)
);
} else if (key.type == KEYFRAME_TYPE_LINEAR) { // quadratic bezier
// last keyframe is the bezier one
bezier_path.quadTo(
QPointF(last_key_x+last_key.post_handle_x, last_key_y+last_key.post_handle_y),
QPointF(key_x, key_y)
);
} else {
// this keyframe is the bezier one
bezier_path.quadTo(
QPointF(key_x+key.pre_handle_x, key_y+key.pre_handle_y),
QPointF(key_x, key_y)
);
}
p.drawPath(bezier_path);
} else {
// linear
p.drawLine(last_key_x, last_key_y, key_x, key_y);
}
} }
last_key_x = key_x; last_key_x = key_x;
last_key_y = key_y; last_key_y = key_y;
} }
// draw keys
for (int j=0;j<sorted_keys.size();j++) { for (int j=0;j<sorted_keys.size();j++) {
// draw keys const EffectKeyframe& key = field->keyframes.at(sorted_keys.at(j));
int key_index = sorted_keys.at(j);
int key_x = get_screen_x(field->keyframes.at(key_index).time); int key_x = get_screen_x(key.time);
int key_y = get_screen_y(field->keyframes.at(key_index).data.toDouble()); int key_y = get_screen_y(key.data.toDouble());
draw_keyframe(p, field->keyframes.at(key_index).type, key_x, key_y, (selected_keys.contains(key_index) && selected_keys_fields.contains(i))); if (key.type == KEYFRAME_TYPE_BEZIER) {
p.setPen(Qt::gray);
// pre handle line
QPointF pre_point(key_x + key.pre_handle_x*zoom, key_y + key.pre_handle_y*zoom);
p.drawLine(pre_point, QPointF(key_x, key_y));
p.drawEllipse(pre_point, BEZIER_HANDLE_SIZE, BEZIER_HANDLE_SIZE);
// post handle line
QPointF post_point(key_x + key.post_handle_x*zoom, key_y + key.post_handle_y*zoom);
p.drawLine(post_point, QPointF(key_x, key_y));
p.drawEllipse(post_point, BEZIER_HANDLE_SIZE, BEZIER_HANDLE_SIZE);
}
draw_keyframe(p, key.type, key_x, key_y, (selected_keys.contains(sorted_keys.at(j)) && selected_keys_fields.contains(i)));
} }
} }
} }
@@ -153,13 +208,15 @@ void GraphView::mousePressEvent(QMouseEvent *event) {
selected_keys.clear(); selected_keys.clear();
selected_keys_fields.clear(); selected_keys_fields.clear();
} }
current_handle = BEZIER_HANDLE_NONE;
if (row != NULL) { if (row != NULL) {
for (int i=0;i<row->fieldCount();i++) { for (int i=0;i<row->fieldCount();i++) {
EffectField* field = row->field(i); EffectField* field = row->field(i);
if (field->type == EFFECT_FIELD_DOUBLE) { if (field->type == EFFECT_FIELD_DOUBLE && field_visibility.at(i)) {
for (int j=0;j<field->keyframes.size();j++) { for (int j=0;j<field->keyframes.size();j++) {
int key_x = get_screen_x(field->keyframes.at(j).time); const EffectKeyframe& key = field->keyframes.at(j);
int key_y = get_screen_y(field->keyframes.at(j).data.toDouble()); int key_x = get_screen_x(key.time);
int key_y = get_screen_y(key.data.toDouble());
if (event->pos().x() > key_x-KEYFRAME_SIZE if (event->pos().x() > key_x-KEYFRAME_SIZE
&& event->pos().x() < key_x+KEYFRAME_SIZE && event->pos().x() < key_x+KEYFRAME_SIZE
&& event->pos().y() > key_y-KEYFRAME_SIZE && event->pos().y() > key_y-KEYFRAME_SIZE
@@ -167,6 +224,33 @@ void GraphView::mousePressEvent(QMouseEvent *event) {
sel_key = j; sel_key = j;
sel_key_field = i; sel_key_field = i;
break; break;
} else {
// selecting a handle
QPointF pre_point(key_x + key.pre_handle_x*zoom, key_y + key.pre_handle_y*zoom);
if (event->pos().x() > pre_point.x()-BEZIER_HANDLE_SIZE
&& event->pos().x() < pre_point.x()+BEZIER_HANDLE_SIZE
&& event->pos().y() > pre_point.y()-BEZIER_HANDLE_SIZE
&& event->pos().y() < pre_point.y()+BEZIER_HANDLE_SIZE) {
sel_key = j;
sel_key_field = i;
old_handle_x = key.pre_handle_x;
old_handle_y = key.pre_handle_y;
current_handle = BEZIER_HANDLE_PRE;
break;
} else {
QPointF post_point(key_x + key.post_handle_x*zoom, key_y + key.post_handle_y*zoom);
if (event->pos().x() > post_point.x()-BEZIER_HANDLE_SIZE
&& event->pos().x() < post_point.x()+BEZIER_HANDLE_SIZE
&& event->pos().y() > post_point.y()-BEZIER_HANDLE_SIZE
&& event->pos().y() < post_point.y()+BEZIER_HANDLE_SIZE) {
sel_key = j;
sel_key_field = i;
old_handle_x = key.post_handle_x;
old_handle_y = key.post_handle_y;
current_handle = BEZIER_HANDLE_POST;
break;
}
}
} }
} }
} }
@@ -179,16 +263,24 @@ void GraphView::mousePressEvent(QMouseEvent *event) {
selected_keys_old_vals.clear(); selected_keys_old_vals.clear();
selected_keys_old_doubles.clear(); selected_keys_old_doubles.clear();
int selected_key_type = -1;
for (int i=0;i<selected_keys.size();i++) { for (int i=0;i<selected_keys.size();i++) {
for (int j=0;j<selected_keys_fields.size();j++) { const EffectKeyframe& key = row->field(selected_keys_fields.at(i))->keyframes.at(selected_keys.at(i));
selected_keys_old_vals.append(row->field(selected_keys_fields.at(j))->keyframes.at(selected_keys.at(i)).time); selected_keys_old_vals.append(key.time);
selected_keys_old_doubles.append(row->field(selected_keys_fields.at(j))->keyframes.at(selected_keys.at(i)).data.toDouble()); selected_keys_old_doubles.append(key.data.toDouble());
if (selected_key_type == -1) {
selected_key_type = key.type;
} else if (selected_key_type != key.type) {
selected_key_type = -2;
} }
} }
update(); update();
emit selection_changed(selected_keys.size() > 0); emit selection_changed(selected_keys.size() > 0, selected_key_type);
} }
void GraphView::mouseMoveEvent(QMouseEvent *event) { void GraphView::mouseMoveEvent(QMouseEvent *event) {
@@ -200,39 +292,60 @@ void GraphView::mouseMoveEvent(QMouseEvent *event) {
start_y = event->pos().y(); start_y = event->pos().y();
update(); update();
} else { } else {
for (int i=0;i<selected_keys.size();i++) { switch (current_handle) {
for (int j=0;j<selected_keys_fields.size();j++) { case BEZIER_HANDLE_NONE:
int index = (i*selected_keys_fields.size())+j; for (int i=0;i<selected_keys.size();i++) {
row->field(selected_keys_fields.at(j))->keyframes[selected_keys.at(i)].time = selected_keys_old_vals.at(index) + (double(event->pos().x() - start_x)/zoom); row->field(selected_keys_fields.at(i))->keyframes[selected_keys.at(i)].time = qRound(selected_keys_old_vals.at(i) + (double(event->pos().x() - start_x)/zoom));
row->field(selected_keys_fields.at(j))->keyframes[selected_keys.at(i)].data = selected_keys_old_doubles.at(index) + (double(start_y - event->pos().y())/zoom); row->field(selected_keys_fields.at(i))->keyframes[selected_keys.at(i)].data = qRound(selected_keys_old_doubles.at(i) + (double(start_y - event->pos().y())/zoom));
} }
moved_keys = true;
update_ui(false);
break;
case BEZIER_HANDLE_PRE:
row->field(selected_keys_fields.last())->keyframes[selected_keys.last()].pre_handle_x = old_handle_x + double(event->pos().x() - start_x)/zoom;
row->field(selected_keys_fields.last())->keyframes[selected_keys.last()].pre_handle_y = old_handle_y + double(event->pos().y() - start_y)/zoom;
moved_keys = true;
update_ui(false);
break;
case BEZIER_HANDLE_POST:
row->field(selected_keys_fields.last())->keyframes[selected_keys.last()].post_handle_x = old_handle_x + double(event->pos().x() - start_x)/zoom;
row->field(selected_keys_fields.last())->keyframes[selected_keys.last()].post_handle_y = old_handle_y + double(event->pos().y() - start_y)/zoom;
moved_keys = true;
update_ui(false);
break;
} }
moved_keys = true;
update_ui(false);
} }
} }
} }
void GraphView::mouseReleaseEvent(QMouseEvent *event) { void GraphView::mouseReleaseEvent(QMouseEvent *event) {
if (moved_keys && selected_keys.size() > 0) { if (moved_keys && selected_keys.size() > 0) {
/*ComboAction* ca = new ComboAction(); ComboAction* ca = new ComboAction();
QVector<EffectRow*> rows; switch (current_handle) {
QVector<long> new_vals; case BEZIER_HANDLE_NONE:
for (int i=0;i<selected_keys.size();i++) {
for (int i=0;i<selected_keys.size();i++) { EffectKeyframe& key = row->field(selected_keys_fields.at(i))->keyframes[selected_keys.at(i)];
rows.append(row); ca->append(new SetLong(&key.time, selected_keys_old_vals.at(i), key.time));
new_vals.append(row->keyframe_times.at(selected_keys.at(i))); ca->append(new SetQVariant(&key.data, selected_keys_old_doubles.at(i), key.data));
for (int j=0;j<selected_keys_fields.size();j++) {
ca->append(new SetQVariant(&row->field(selected_keys_fields.at(j))->keyframe_data[selected_keys.at(i)],
selected_keys_old_doubles.at((i*selected_keys_fields.size())+j),
row->field(selected_keys_fields.at(j))->keyframe_data.at(selected_keys.at(i))));
} }
//ca->append(new KeyframeSet(row, selected_keys.at(i), 0, false)); break;
} case BEZIER_HANDLE_PRE:
{
ca->append(new KeyframeMove(rows, selected_keys, selected_keys_old_vals, new_vals)); EffectKeyframe& key = row->field(selected_keys_fields.last())->keyframes[selected_keys.last()];
undo_stack.push(ca);*/ ca->append(new SetDouble(&key.pre_handle_x, old_handle_x, key.pre_handle_x));
ca->append(new SetDouble(&key.pre_handle_y, old_handle_y, key.pre_handle_y));
}
break;
case BEZIER_HANDLE_POST:
{
EffectKeyframe& key = row->field(selected_keys_fields.last())->keyframes[selected_keys.last()];
ca->append(new SetDouble(&key.post_handle_x, old_handle_x, key.post_handle_x));
ca->append(new SetDouble(&key.post_handle_y, old_handle_y, key.post_handle_y));
}
break;
}
undo_stack.push(ca);
} }
moved_keys = false; moved_keys = false;
mousedown = false; mousedown = false;
@@ -269,19 +382,39 @@ void GraphView::set_row(EffectRow *r) {
selected_keys_fields.clear(); selected_keys_fields.clear();
selected_keys_old_vals.clear(); selected_keys_old_vals.clear();
selected_keys_old_doubles.clear(); selected_keys_old_doubles.clear();
emit selection_changed(false); emit selection_changed(false, -1);
row = r; row = r;
if (row != NULL) {
field_visibility.resize(row->fieldCount());
field_visibility.fill(true);
}
update();
}
void GraphView::set_selected_keyframe_type(int type) {
if (selected_keys.size() > 0) {
ComboAction* ca = new ComboAction();
for (int i=0;i<selected_keys.size();i++) {
EffectKeyframe& key = row->field(selected_keys_fields.at(i))->keyframes[selected_keys.at(i)];
ca->append(new SetInt(&key.type, type));
}
undo_stack.push(ca);
update_ui(false);
}
}
void GraphView::set_field_visibility(int field, bool b) {
field_visibility[field] = b;
update(); update();
} }
void GraphView::set_scroll_x(int s) { void GraphView::set_scroll_x(int s) {
x_scroll = s;//qMax(0, s); x_scroll = s;
dout << x_scroll;
emit x_scroll_changed(x_scroll); emit x_scroll_changed(x_scroll);
} }
void GraphView::set_scroll_y(int s) { void GraphView::set_scroll_y(int s) {
y_scroll = s;//qMax(0, s); y_scroll = s;
emit y_scroll_changed(y_scroll); emit y_scroll_changed(y_scroll);
} }
+11 -1
View File
@@ -20,11 +20,14 @@ public:
void wheelEvent(QWheelEvent *event); void wheelEvent(QWheelEvent *event);
void set_row(EffectRow* r); void set_row(EffectRow* r);
void set_selected_keyframe_type(int type);
void set_field_visibility(int field, bool b);
signals: signals:
void x_scroll_changed(int); void x_scroll_changed(int);
void y_scroll_changed(int); void y_scroll_changed(int);
void zoom_changed(double); void zoom_changed(double);
void selection_changed(bool); void selection_changed(bool, int);
private: private:
int x_scroll; int x_scroll;
int y_scroll; int y_scroll;
@@ -39,13 +42,20 @@ private:
int get_screen_x(double); int get_screen_x(double);
int get_screen_y(double); int get_screen_y(double);
QVector<bool> field_visibility;
QVector<int> selected_keys; QVector<int> selected_keys;
QVector<int> selected_keys_fields; QVector<int> selected_keys_fields;
QVector<long> selected_keys_old_vals; QVector<long> selected_keys_old_vals;
QVector<double> selected_keys_old_doubles; QVector<double> selected_keys_old_doubles;
double old_handle_x;
double old_handle_y;
bool moved_keys; bool moved_keys;
int current_handle;
EffectRow* row; EffectRow* row;
}; };
+75 -75
View File
@@ -44,13 +44,13 @@ KeyframeView::KeyframeView(QWidget *parent) :
} }
void KeyframeView::show_context_menu(const QPoint& pos) { void KeyframeView::show_context_menu(const QPoint& pos) {
if (selected_fields.size() > 0) { if (selected_fields.size() > 0) {
QMenu menu(this); QMenu menu(this);
QAction* linear = menu.addAction("Linear"); QAction* linear = menu.addAction("Linear");
linear->setData(KEYFRAME_TYPE_LINEAR); linear->setData(KEYFRAME_TYPE_LINEAR);
QAction* smooth = menu.addAction("Smooth"); QAction* bezier = menu.addAction("Bezier");
smooth->setData(KEYFRAME_TYPE_BEZIER); bezier->setData(KEYFRAME_TYPE_BEZIER);
QAction* hold = menu.addAction("Hold"); QAction* hold = menu.addAction("Hold");
hold->setData(KEYFRAME_TYPE_HOLD); hold->setData(KEYFRAME_TYPE_HOLD);
menu.addSeparator(); menu.addSeparator();
@@ -67,12 +67,12 @@ void KeyframeView::menu_set_key_type(QAction* a) {
panel_graph_editor->show(); panel_graph_editor->show();
} else { } else {
ComboAction* ca = new ComboAction(); ComboAction* ca = new ComboAction();
for (int i=0;i<selected_fields.size();i++) { for (int i=0;i<selected_fields.size();i++) {
EffectField* f = selected_fields.at(i); EffectField* f = selected_fields.at(i);
ca->append(new SetInt(&f->keyframes[selected_keyframes.at(i)].type, a->data().toInt())); ca->append(new SetInt(&f->keyframes[selected_keyframes.at(i)].type, a->data().toInt()));
} }
undo_stack.push(ca); undo_stack.push(ca);
update_keys(); update_ui(false);
} }
} }
@@ -103,19 +103,19 @@ void KeyframeView::paintEvent(QPaintEvent*) {
ClickableLabel* label = row->label; ClickableLabel* label = row->label;
QWidget* contents = e->container->contents; QWidget* contents = e->container->contents;
QVector<long> key_times; QVector<long> key_times;
int keyframe_y = label->y() + (label->height()>>1) + mapFrom(panel_effect_controls, contents->mapTo(panel_effect_controls, contents->pos())).y() - e->container->title_bar->height()/* - y_scroll*/; int keyframe_y = label->y() + (label->height()>>1) + mapFrom(panel_effect_controls, contents->mapTo(panel_effect_controls, contents->pos())).y() - e->container->title_bar->height()/* - y_scroll*/;
for (int l=0;l<row->fieldCount();l++) { for (int l=0;l<row->fieldCount();l++) {
EffectField* f = row->field(l); EffectField* f = row->field(l);
for (int k=0;k<f->keyframes.size();k++) { for (int k=0;k<f->keyframes.size();k++) {
if (!key_times.contains(f->keyframes.at(k).time)) { if (!key_times.contains(f->keyframes.at(k).time)) {
bool keyframe_selected = keyframeIsSelected(f, k); bool keyframe_selected = keyframeIsSelected(f, k);
long keyframe_frame = adjust_row_keyframe(row, f->keyframes.at(k).time); long keyframe_frame = adjust_row_keyframe(row, f->keyframes.at(k).time);
draw_keyframe(p, f->keyframes.at(k).type, getScreenPointFromFrame(panel_effect_controls->zoom, keyframe_frame) - x_scroll, keyframe_y, keyframe_selected); draw_keyframe(p, f->keyframes.at(k).type, getScreenPointFromFrame(panel_effect_controls->zoom, keyframe_frame) - x_scroll, keyframe_y, keyframe_selected);
key_times.append(f->keyframes.at(k).time); key_times.append(f->keyframes.at(k).time);
} }
} }
} }
rows.append(row); rows.append(row);
rowY.append(keyframe_y); rowY.append(keyframe_y);
@@ -150,8 +150,8 @@ void KeyframeView::paintEvent(QPaintEvent*) {
} }
bool KeyframeView::keyframeIsSelected(EffectField *field, int keyframe) { bool KeyframeView::keyframeIsSelected(EffectField *field, int keyframe) {
for (int i=0;i<selected_fields.size();i++) { for (int i=0;i<selected_fields.size();i++) {
if (selected_fields.at(i) == field && selected_keyframes.at(i) == keyframe) { if (selected_fields.at(i) == field && selected_keyframes.at(i) == keyframe) {
return true; return true;
} }
} }
@@ -164,22 +164,22 @@ void KeyframeView::update_keys() {
} }
void KeyframeView::delete_selected_keyframes() { void KeyframeView::delete_selected_keyframes() {
ComboAction* ca = new ComboAction(); ComboAction* ca = new ComboAction();
bool del = false; bool del = false;
for (int i=0;i<selected_keyframes.size();i++) { for (int i=0;i<selected_keyframes.size();i++) {
// TODO these need to be sorted // TODO these need to be sorted
ca->append(new KeyframeDelete(selected_fields.at(i), selected_keyframes.at(i))); ca->append(new KeyframeDelete(selected_fields.at(i), selected_keyframes.at(i)));
del = true; del = true;
} }
if (del) { if (del) {
undo_stack.push(ca); undo_stack.push(ca);
selected_keyframes.clear(); selected_keyframes.clear();
selected_fields.clear(); selected_fields.clear();
update_keys(); update_keys();
panel_sequence_viewer->viewer_widget->update(); panel_sequence_viewer->viewer_widget->update();
} else { } else {
delete ca; delete ca;
} }
} }
@@ -211,7 +211,7 @@ void KeyframeView::mousePressEvent(QMouseEvent *event) {
int mouse_x = event->x() + x_scroll; int mouse_x = event->x() + x_scroll;
int mouse_y = event->y(); int mouse_y = event->y();
int row_index = -1; int row_index = -1;
int field_index = -1; int field_index = -1;
int keyframe_index = -1; int keyframe_index = -1;
long frame_diff = 0; long frame_diff = 0;
long frame_min = getFrameFromScreenPoint(panel_effect_controls->zoom, mouse_x-KEYFRAME_SIZE); long frame_min = getFrameFromScreenPoint(panel_effect_controls->zoom, mouse_x-KEYFRAME_SIZE);
@@ -223,41 +223,41 @@ void KeyframeView::mousePressEvent(QMouseEvent *event) {
row->focus_row(); row->focus_row();
for (int k=0;k<row->fieldCount();k++) { for (int k=0;k<row->fieldCount();k++) {
EffectField* f = row->field(k); EffectField* f = row->field(k);
for (int j=0;j<f->keyframes.size();j++) { for (int j=0;j<f->keyframes.size();j++) {
long eval_keyframe_time = f->keyframes.at(j).time-row->parent_effect->parent_clip->clip_in+(row->parent_effect->parent_clip->timeline_in-visible_in); long eval_keyframe_time = f->keyframes.at(j).time-row->parent_effect->parent_clip->clip_in+(row->parent_effect->parent_clip->timeline_in-visible_in);
if (eval_keyframe_time >= frame_min && eval_keyframe_time <= frame_max) { if (eval_keyframe_time >= frame_min && eval_keyframe_time <= frame_max) {
long eval_frame_diff = qAbs(eval_keyframe_time - drag_frame_start); long eval_frame_diff = qAbs(eval_keyframe_time - drag_frame_start);
if (keyframe_index == -1 || eval_frame_diff < frame_diff) { if (keyframe_index == -1 || eval_frame_diff < frame_diff) {
row_index = i; row_index = i;
field_index = k; field_index = k;
keyframe_index = j; keyframe_index = j;
frame_diff = eval_frame_diff; frame_diff = eval_frame_diff;
} }
} }
} }
} }
break; break;
} }
} }
bool already_selected = false; bool already_selected = false;
keys_selected = false; keys_selected = false;
if (keyframe_index > -1) already_selected = keyframeIsSelected(rows.at(row_index)->field(field_index), keyframe_index); if (keyframe_index > -1) already_selected = keyframeIsSelected(rows.at(row_index)->field(field_index), keyframe_index);
if (!already_selected) { if (!already_selected) {
if (!(event->modifiers() & Qt::ShiftModifier)) { if (!(event->modifiers() & Qt::ShiftModifier)) {
selected_fields.clear(); selected_fields.clear();
selected_keyframes.clear(); selected_keyframes.clear();
} }
if (keyframe_index > -1) { if (keyframe_index > -1) {
selected_fields.append(rows.at(row_index)->field(field_index)); selected_fields.append(rows.at(row_index)->field(field_index));
selected_keyframes.append(keyframe_index); selected_keyframes.append(keyframe_index);
} }
} }
if (selected_fields.size() > 0) { if (selected_fields.size() > 0) {
for (int i=0;i<selected_fields.size();i++) { for (int i=0;i<selected_fields.size();i++) {
old_key_vals.append(selected_fields.at(i)->keyframes.at(selected_keyframes.at(i)).time); old_key_vals.append(selected_fields.at(i)->keyframes.at(selected_keyframes.at(i)).time);
} }
keys_selected = true; keys_selected = true;
@@ -291,8 +291,8 @@ void KeyframeView::mouseMoveEvent(QMouseEvent* event) {
panel_timeline->snapped = false; panel_timeline->snapped = false;
if (panel_timeline->snapping) { if (panel_timeline->snapping) {
for (int i=0;i<selected_keyframes.size();i++) { for (int i=0;i<selected_keyframes.size();i++) {
EffectField* field = selected_fields.at(i); EffectField* field = selected_fields.at(i);
Clip* c = field->parent_row->parent_effect->parent_clip; Clip* c = field->parent_row->parent_effect->parent_clip;
long key_time = old_key_vals.at(i) + frame_diff - c->clip_in + c->timeline_in; long key_time = old_key_vals.at(i) + frame_diff - c->clip_in + c->timeline_in;
long key_eval = key_time; long key_eval = key_time;
if (panel_timeline->snap_to_point(sequence->playhead, &key_eval)) { if (panel_timeline->snap_to_point(sequence->playhead, &key_eval)) {
@@ -303,11 +303,11 @@ void KeyframeView::mouseMoveEvent(QMouseEvent* event) {
} }
// validate frame_diff (make sure no keyframes overlap each other) // validate frame_diff (make sure no keyframes overlap each other)
for (int i=0;i<selected_fields.size();i++) { for (int i=0;i<selected_fields.size();i++) {
EffectField* field = selected_fields.at(i); EffectField* field = selected_fields.at(i);
long eval_key = old_key_vals.at(i); long eval_key = old_key_vals.at(i);
for (int j=0;j<field->keyframes.size();j++) { for (int j=0;j<field->keyframes.size();j++) {
while (!keyframeIsSelected(field, j) && field->keyframes.at(j).time == eval_key + frame_diff) { while (!keyframeIsSelected(field, j) && field->keyframes.at(j).time == eval_key + frame_diff) {
if (last_frame_diff > frame_diff) { if (last_frame_diff > frame_diff) {
frame_diff++; frame_diff++;
panel_timeline->snapped = false; panel_timeline->snapped = false;
@@ -321,8 +321,8 @@ void KeyframeView::mouseMoveEvent(QMouseEvent* event) {
// apply frame_diffs // apply frame_diffs
for (int i=0;i<selected_keyframes.size();i++) { for (int i=0;i<selected_keyframes.size();i++) {
EffectField* field = selected_fields.at(i); EffectField* field = selected_fields.at(i);
field->keyframes[selected_keyframes.at(i)].time = old_key_vals.at(i) + frame_diff; field->keyframes[selected_keyframes.at(i)].time = old_key_vals.at(i) + frame_diff;
} }
last_frame_diff = frame_diff; last_frame_diff = frame_diff;
@@ -346,16 +346,16 @@ void KeyframeView::mouseMoveEvent(QMouseEvent* event) {
for (int i=0;i<rowY.size();i++) { for (int i=0;i<rowY.size();i++) {
if (rowY.at(i) >= min_row && rowY.at(i) <= max_row) { if (rowY.at(i) >= min_row && rowY.at(i) <= max_row) {
EffectRow* row = rows.at(i); EffectRow* row = rows.at(i);
for (int k=0;k<row->fieldCount();k++) { for (int k=0;k<row->fieldCount();k++) {
EffectField* field = row->field(k); EffectField* field = row->field(k);
for (int j=0;j<field->keyframes.size();j++) { for (int j=0;j<field->keyframes.size();j++) {
long keyframe_frame = adjust_row_keyframe(row, field->keyframes.at(j).time); long keyframe_frame = adjust_row_keyframe(row, field->keyframes.at(j).time);
if (!keyframeIsSelected(field, j) && keyframe_frame >= min_frame && keyframe_frame <= max_frame) { if (!keyframeIsSelected(field, j) && keyframe_frame >= min_frame && keyframe_frame <= max_frame) {
selected_fields.append(field); selected_fields.append(field);
selected_keyframes.append(j); selected_keyframes.append(j);
} }
} }
} }
} }
} }
@@ -368,15 +368,15 @@ void KeyframeView::mouseMoveEvent(QMouseEvent* event) {
void KeyframeView::mouseReleaseEvent(QMouseEvent*) { void KeyframeView::mouseReleaseEvent(QMouseEvent*) {
if (dragging) { if (dragging) {
ComboAction* ca = new ComboAction(); ComboAction* ca = new ComboAction();
for (int i=0;i<selected_fields.size();i++) { for (int i=0;i<selected_fields.size();i++) {
ca->append(new SetLong( ca->append(new SetLong(
&selected_fields.at(i)->keyframes[selected_keyframes.at(i)].time, &selected_fields.at(i)->keyframes[selected_keyframes.at(i)].time,
old_key_vals.at(i), old_key_vals.at(i),
selected_fields.at(i)->keyframes.at(selected_keyframes.at(i)).time selected_fields.at(i)->keyframes.at(selected_keyframes.at(i)).time
)); ));
} }
undo_stack.push(ca); undo_stack.push(ca);
} }
select_rect = false; select_rect = false;