style: unify identifier naming per updated conventions

Automated with clang-tidy readability-identifier-naming (config added to
.clang-tidy) plus scripted passes, per the updated rules now documented
in CONTRIBUTING.md:

- types (class/struct/enum/alias/template params): PascalCase
- functions, variables, members: snake_case (incl. rational -> Rational)
- private/protected members: trailing underscore; static member
  variables likewise (instance_, available_themes_)
- constants and enum values: snake_case (kLinear -> k_linear,
  F32P -> f32p); ALL_CAPS reserved for macros
- macros: OAK_ prefix (OLIVE_ADD_TEST/OLIVE_ASSERT/OLIVE_CONFIG ->
  OAK_ADD_TEST/OAK_ASSERT/OAK_CONFIG, GL_PREAMBLE -> OAK_GL_PREAMBLE,
  include guards -> OAK_*)
- file names: all lowercase (Current/Plugin/OliveHost/OliveClip/
  OlivePluginInstance -> current/plugin/olivehost/oliveclip/
  oliveplugininstance)
- getters share the member name sans underscore, setters set_foo()
- Qt and third-party (OpenFX) virtual overrides and framework callbacks
  keep their original names (exempt in .clang-tidy)

Manual follow-ups required where automation could not reach:
- string-based QMetaObject/SIGNAL/SLOT references updated to renamed
  methods (AddTask, CreatedFile, DeleteSpecificFile, moveSelectionUp, ...)
- macro bodies referencing renamed methods (OLIVE_CONFIG,
  NODE_DEFAULT_DESTRUCTOR, MANAGEDDISPLAYWIDGET_*)
- self-shadowing locals renamed where signals/methods became same-named
  (size_changed, worker_count, selected_items, import param, filters)
- third_party OFX member/namespace usages restored (OFX::Host::*,
  _created, _clipPrefsDirty, createInstance, clearPersistentMessage)
- STL protocol aliases restored (const_iterator) with .clang-tidy
  ignore rules; qHash overloads restored

Full build and test suite pass: ctest 4/4, ~1960 gtest cases green.
This commit is contained in:
2026-07-19 16:10:54 +08:00
parent cb1718a103
commit bb40b4923e
1014 changed files with 44257 additions and 44220 deletions
@@ -28,7 +28,7 @@ CrossDissolveTransition::CrossDissolveTransition()
{
}
QString CrossDissolveTransition::Name() const
QString CrossDissolveTransition::name() const
{
return tr("Cross Dissolve");
}
@@ -38,23 +38,23 @@ QString CrossDissolveTransition::id() const
return QStringLiteral("org.olivevideoeditor.Olive.crossdissolve");
}
QVector<Node::CategoryID> CrossDissolveTransition::Category() const
QVector<Node::CategoryID> CrossDissolveTransition::category() const
{
return { kCategoryTransition };
return { k_category_transition };
}
QString CrossDissolveTransition::Description() const
QString CrossDissolveTransition::description() const
{
return tr("Smoothly transition between two clips.");
}
ShaderCode
CrossDissolveTransition::GetShaderCode(const ShaderRequest &request) const
CrossDissolveTransition::get_shader_code(const ShaderRequest &request) const
{
Q_UNUSED(request)
return ShaderCode(
FileFunctions::ReadFileAsString(":/shaders/crossdissolve.frag"),
FileFunctions::read_file_as_string(":/shaders/crossdissolve.frag"),
QString());
}
@@ -65,8 +65,8 @@ void CrossDissolveTransition::SampleJobEvent(const SampleBuffer &from_samples,
{
for (size_t i = 0; i < out_samples.sample_count(); i++) {
double this_sample_time =
out_samples.audio_params().samples_to_time(i).toDouble() + time_in;
double progress = GetTotalProgress(this_sample_time);
out_samples.audio_params().samples_to_time(i).to_double() + time_in;
double progress = get_total_progress(this_sample_time);
for (int j = 0; j < out_samples.audio_params().channel_count(); j++) {
out_samples.data(j)[i] = 0;
@@ -74,7 +74,7 @@ void CrossDissolveTransition::SampleJobEvent(const SampleBuffer &from_samples,
if (from_samples.is_allocated()) {
if (i < from_samples.sample_count()) {
out_samples.data(j)[i] += from_samples.data(j)[i] *
TransformCurve(1.0 - progress);
transform_curve(1.0 - progress);
}
}
@@ -85,7 +85,7 @@ void CrossDissolveTransition::SampleJobEvent(const SampleBuffer &from_samples,
if (i >= remain) {
qint64 in_index = i - remain;
out_samples.data(j)[i] +=
to_samples.data(j)[in_index] * TransformCurve(progress);
to_samples.data(j)[in_index] * transform_curve(progress);
}
}
}
@@ -19,8 +19,8 @@
***/
#ifndef CROSSDISSOLVETRANSITION_H
#define CROSSDISSOLVETRANSITION_H
#ifndef OAK_CROSSDISSOLVETRANSITION_H
#define OAK_CROSSDISSOLVETRANSITION_H
#include "node/block/transition/transition.h"
@@ -34,15 +34,15 @@ public:
NODE_DEFAULT_FUNCTIONS(CrossDissolveTransition)
virtual QString Name() const override;
virtual QString name() const override;
virtual QString id() const override;
virtual QVector<CategoryID> Category() const override;
virtual QString Description() const override;
virtual QVector<CategoryID> category() const override;
virtual QString description() const override;
//virtual void Retranslate() override;
virtual ShaderCode
GetShaderCode(const ShaderRequest &request) const override;
get_shader_code(const ShaderRequest &request) const override;
protected:
virtual void SampleJobEvent(const SampleBuffer &from_samples,
@@ -53,4 +53,4 @@ protected:
}
#endif // CROSSDISSOLVETRANSITION_H
#endif // OAK_CROSSDISSOLVETRANSITION_H
@@ -24,17 +24,17 @@
namespace olive
{
const QString DipToColorTransition::kColorInput = QStringLiteral("color_in");
const QString DipToColorTransition::k_color_input = QStringLiteral("color_in");
#define super TransitionBlock
DipToColorTransition::DipToColorTransition()
{
AddInput(kColorInput, NodeValue::kColor,
add_input(k_color_input, NodeValue::k_color,
QVariant::fromValue(Color(0, 0, 0)));
}
QString DipToColorTransition::Name() const
QString DipToColorTransition::name() const
{
return tr("Dip To Color");
}
@@ -44,37 +44,37 @@ QString DipToColorTransition::id() const
return QStringLiteral("org.olivevideoeditor.Olive.diptocolor");
}
QVector<Node::CategoryID> DipToColorTransition::Category() const
QVector<Node::CategoryID> DipToColorTransition::category() const
{
return { kCategoryTransition };
return { k_category_transition };
}
QString DipToColorTransition::Description() const
QString DipToColorTransition::description() const
{
return tr("Transition between clips by dipping to a color.");
}
ShaderCode
DipToColorTransition::GetShaderCode(const ShaderRequest &request) const
DipToColorTransition::get_shader_code(const ShaderRequest &request) const
{
Q_UNUSED(request)
return ShaderCode(
FileFunctions::ReadFileAsString(":/shaders/diptoblack.frag"),
FileFunctions::read_file_as_string(":/shaders/diptoblack.frag"),
QString());
}
void DipToColorTransition::Retranslate()
void DipToColorTransition::retranslate()
{
super::Retranslate();
super::retranslate();
SetInputName(kColorInput, tr("Color"));
set_input_name(k_color_input, tr("Color"));
}
void DipToColorTransition::ShaderJobEvent(const NodeValueRow &value,
ShaderJob *job) const
{
job->Insert(kColorInput, value);
job->insert(k_color_input, value);
}
}
@@ -19,8 +19,8 @@
***/
#ifndef DIPTOCOLORTRANSITION_H
#define DIPTOCOLORTRANSITION_H
#ifndef OAK_DIPTOCOLORTRANSITION_H
#define OAK_DIPTOCOLORTRANSITION_H
#include "node/block/transition/transition.h"
@@ -34,17 +34,17 @@ public:
NODE_DEFAULT_FUNCTIONS(DipToColorTransition)
virtual QString Name() const override;
virtual QString name() const override;
virtual QString id() const override;
virtual QVector<CategoryID> Category() const override;
virtual QString Description() const override;
virtual QVector<CategoryID> category() const override;
virtual QString description() const override;
virtual ShaderCode
GetShaderCode(const ShaderRequest &request) const override;
get_shader_code(const ShaderRequest &request) const override;
virtual void Retranslate() override;
virtual void retranslate() override;
static const QString kColorInput;
static const QString k_color_input;
protected:
virtual void ShaderJobEvent(const NodeValueRow &value,
@@ -53,4 +53,4 @@ protected:
}
#endif // DIPTOCOLORTRANSITION_H
#endif // OAK_DIPTOCOLORTRANSITION_H
+94 -94
View File
@@ -30,48 +30,48 @@ namespace olive
#define super Block
const QString TransitionBlock::kOutBlockInput = QStringLiteral("out_block_in");
const QString TransitionBlock::kInBlockInput = QStringLiteral("in_block_in");
const QString TransitionBlock::kCurveInput = QStringLiteral("curve_in");
const QString TransitionBlock::kCenterInput = QStringLiteral("center_in");
const QString TransitionBlock::k_out_block_input = QStringLiteral("out_block_in");
const QString TransitionBlock::k_in_block_input = QStringLiteral("in_block_in");
const QString TransitionBlock::k_curve_input = QStringLiteral("curve_in");
const QString TransitionBlock::k_center_input = QStringLiteral("center_in");
TransitionBlock::TransitionBlock()
: connected_out_block_(nullptr)
, connected_in_block_(nullptr)
{
AddInput(kOutBlockInput, NodeValue::kNone,
InputFlags(kInputFlagNotKeyframable));
add_input(k_out_block_input, NodeValue::k_none,
InputFlags(k_input_flag_not_keyframable));
AddInput(kInBlockInput, NodeValue::kNone,
InputFlags(kInputFlagNotKeyframable));
add_input(k_in_block_input, NodeValue::k_none,
InputFlags(k_input_flag_not_keyframable));
AddInput(kCurveInput, NodeValue::kCombo,
InputFlags(kInputFlagNotKeyframable | kInputFlagNotConnectable));
add_input(k_curve_input, NodeValue::k_combo,
InputFlags(k_input_flag_not_keyframable | k_input_flag_not_connectable));
AddInput(kCenterInput, NodeValue::kRational,
InputFlags(kInputFlagNotKeyframable | kInputFlagNotConnectable));
SetInputProperty(kCenterInput, QStringLiteral("view"),
RationalSlider::kTime);
SetInputProperty(kCenterInput, QStringLiteral("viewlock"), true);
add_input(k_center_input, NodeValue::k_rational,
InputFlags(k_input_flag_not_keyframable | k_input_flag_not_connectable));
set_input_property(k_center_input, QStringLiteral("view"),
RationalSlider::k_time);
set_input_property(k_center_input, QStringLiteral("viewlock"), true);
SetFlag(kDontShowInParamView, false);
set_flag(k_dont_show_in_param_view, false);
}
void TransitionBlock::Retranslate()
void TransitionBlock::retranslate()
{
super::Retranslate();
super::retranslate();
SetInputName(kOutBlockInput, tr("From"));
SetInputName(kInBlockInput, tr("To"));
SetInputName(kCurveInput, tr("Curve"));
SetInputName(kCenterInput, tr("Center Offset"));
set_input_name(k_out_block_input, tr("From"));
set_input_name(k_in_block_input, tr("To"));
set_input_name(k_curve_input, tr("Curve"));
set_input_name(k_center_input, tr("Center Offset"));
// These must correspond to the CurveType enum
SetComboBoxStrings(kCurveInput,
set_combo_box_strings(k_curve_input,
{ tr("Linear"), tr("Exponential"), tr("Logarithmic") });
}
rational TransitionBlock::in_offset() const
Rational TransitionBlock::in_offset() const
{
if (is_dual_transition()) {
return length() / 2 + offset_center();
@@ -82,7 +82,7 @@ rational TransitionBlock::in_offset() const
}
}
rational TransitionBlock::out_offset() const
Rational TransitionBlock::out_offset() const
{
if (is_dual_transition()) {
return length() / 2 - offset_center();
@@ -93,21 +93,21 @@ rational TransitionBlock::out_offset() const
}
}
rational TransitionBlock::offset_center() const
Rational TransitionBlock::offset_center() const
{
return GetStandardValue(kCenterInput).value<rational>();
return get_standard_value(k_center_input).value<Rational>();
}
void TransitionBlock::set_offset_center(const rational &r)
void TransitionBlock::set_offset_center(const Rational &r)
{
SetStandardValue(kCenterInput, QVariant::fromValue(r));
set_standard_value(k_center_input, QVariant::fromValue(r));
}
void TransitionBlock::set_offsets_and_length(const rational &in_offset,
const rational &out_offset)
void TransitionBlock::set_offsets_and_length(const Rational &in_offset,
const Rational &out_offset)
{
rational len = in_offset + out_offset;
rational center = len / 2 - in_offset;
Rational len = in_offset + out_offset;
Rational center = len / 2 - in_offset;
set_length_and_media_out(len);
set_offset_center(center);
@@ -123,101 +123,101 @@ Block *TransitionBlock::connected_in_block() const
return connected_in_block_;
}
double TransitionBlock::GetTotalProgress(const double &time) const
double TransitionBlock::get_total_progress(const double &time) const
{
return GetInternalTransitionTime(time) / length().toDouble();
return get_internal_transition_time(time) / length().to_double();
}
double TransitionBlock::GetOutProgress(const double &time) const
double TransitionBlock::get_out_progress(const double &time) const
{
if (out_offset() == 0) {
return 0;
}
return std::clamp(
1.0 - (GetInternalTransitionTime(time) / out_offset().toDouble()), 0.0,
1.0 - (get_internal_transition_time(time) / out_offset().to_double()), 0.0,
1.0);
}
double TransitionBlock::GetInProgress(const double &time) const
double TransitionBlock::get_in_progress(const double &time) const
{
if (in_offset() == 0) {
return 0;
}
return std::clamp(
(GetInternalTransitionTime(time) - out_offset().toDouble()) /
in_offset().toDouble(),
(get_internal_transition_time(time) - out_offset().to_double()) /
in_offset().to_double(),
0.0, 1.0);
}
double TransitionBlock::GetInternalTransitionTime(const double &time) const
double TransitionBlock::get_internal_transition_time(const double &time) const
{
return time;
}
void TransitionBlock::InsertTransitionTimes(AcceleratedJob *job,
void TransitionBlock::insert_transition_times(AcceleratedJob *job,
const double &time) const
{
// Provides total transition progress from 0.0 (start) - 1.0 (end)
job->Insert(QStringLiteral("ove_tprog_all"),
NodeValue(NodeValue::kFloat, GetTotalProgress(time), this));
job->insert(QStringLiteral("ove_tprog_all"),
NodeValue(NodeValue::k_float, get_total_progress(time), this));
// Provides progress of out section from 1.0 (start) - 0.0 (end)
job->Insert(QStringLiteral("ove_tprog_out"),
NodeValue(NodeValue::kFloat, GetOutProgress(time), this));
job->insert(QStringLiteral("ove_tprog_out"),
NodeValue(NodeValue::k_float, get_out_progress(time), this));
// Provides progress of in section from 0.0 (start) - 1.0 (end)
job->Insert(QStringLiteral("ove_tprog_in"),
NodeValue(NodeValue::kFloat, GetInProgress(time), this));
job->insert(QStringLiteral("ove_tprog_in"),
NodeValue(NodeValue::k_float, get_in_progress(time), this));
}
void TransitionBlock::Value(const NodeValueRow &value,
void TransitionBlock::value(const NodeValueRow &value,
const NodeGlobals &globals,
NodeValueTable *table) const
{
NodeValue out_buffer = value[kOutBlockInput];
NodeValue in_buffer = value[kInBlockInput];
NodeValue::Type data_type = (out_buffer.type() != NodeValue::kNone) ?
NodeValue out_buffer = value[k_out_block_input];
NodeValue in_buffer = value[k_in_block_input];
NodeValue::Type data_type = (out_buffer.type() != NodeValue::k_none) ?
out_buffer.type() :
in_buffer.type();
NodeValue::Type job_type = NodeValue::kNone;
NodeValue::Type job_type = NodeValue::k_none;
QVariant push_job;
if (data_type == NodeValue::kTexture) {
if (data_type == NodeValue::k_texture) {
// This must be a visual transition
ShaderJob job;
if (out_buffer.type() != NodeValue::kNone) {
job.Insert(kOutBlockInput, out_buffer);
if (out_buffer.type() != NodeValue::k_none) {
job.insert(k_out_block_input, out_buffer);
} else {
job.Insert(kOutBlockInput, NodeValue(NodeValue::kTexture, nullptr));
job.insert(k_out_block_input, NodeValue(NodeValue::k_texture, nullptr));
}
if (in_buffer.type() != NodeValue::kNone) {
job.Insert(kInBlockInput, in_buffer);
if (in_buffer.type() != NodeValue::k_none) {
job.insert(k_in_block_input, in_buffer);
} else {
job.Insert(kInBlockInput, NodeValue(NodeValue::kTexture, nullptr));
job.insert(k_in_block_input, NodeValue(NodeValue::k_texture, nullptr));
}
job.Insert(kCurveInput, value);
job.insert(k_curve_input, value);
double time = globals.time().in().toDouble();
InsertTransitionTimes(&job, time);
double time = globals.time().in().to_double();
insert_transition_times(&job, time);
ShaderJobEvent(value, &job);
job_type = NodeValue::kTexture;
push_job = QVariant::fromValue(Texture::Job(globals.vparams(), job));
} else if (data_type == NodeValue::kSamples) {
job_type = NodeValue::k_texture;
push_job = QVariant::fromValue(Texture::job(globals.vparams(), job));
} else if (data_type == NodeValue::k_samples) {
// This must be an audio transition
SampleBuffer from_samples = out_buffer.toSamples();
SampleBuffer to_samples = in_buffer.toSamples();
SampleBuffer from_samples = out_buffer.to_samples();
SampleBuffer to_samples = in_buffer.to_samples();
if (from_samples.is_allocated() || to_samples.is_allocated()) {
double time_in = globals.time().in().toDouble();
double time_out = globals.time().out().toDouble();
double time_in = globals.time().in().to_double();
double time_out = globals.time().out().to_double();
const AudioParams &params = (from_samples.is_allocated()) ?
from_samples.audio_params() :
@@ -232,41 +232,41 @@ void TransitionBlock::Value(const NodeValueRow &value,
SampleJobEvent(from_samples, to_samples, out_samples, time_in);
}
job_type = NodeValue::kSamples;
job_type = NodeValue::k_samples;
push_job = QVariant::fromValue(out_samples);
}
}
if (!push_job.isNull()) {
table->Push(job_type, push_job, this);
table->push(job_type, push_job, this);
}
}
void TransitionBlock::InvalidateCache(const TimeRange &range,
void TransitionBlock::invalidate_cache(const TimeRange &range,
const QString &from, int element,
InvalidateCacheOptions options)
{
TimeRange r = range;
if (from == kOutBlockInput || from == kInBlockInput) {
Block *n = dynamic_cast<Block *>(GetConnectedOutput(from));
if (from == k_out_block_input || from == k_in_block_input) {
Block *n = dynamic_cast<Block *>(get_connected_output(from));
if (n) {
r = Track::TransformRangeFromBlock(n, r);
r = Track::transform_range_from_block(n, r);
}
}
super::InvalidateCache(r, from, element, options);
super::invalidate_cache(r, from, element, options);
}
double TransitionBlock::TransformCurve(double linear) const
double TransitionBlock::transform_curve(double linear) const
{
switch (static_cast<CurveType>(GetStandardValue(kCurveInput).toInt())) {
case kLinear:
switch (static_cast<CurveType>(get_standard_value(k_curve_input).toInt())) {
case k_linear:
break;
case kExponential:
case k_exponential:
linear *= linear;
break;
case kLogarithmic:
case k_logarithmic:
linear = std::sqrt(linear);
break;
}
@@ -279,12 +279,12 @@ void TransitionBlock::InputConnectedEvent(const QString &input, int element,
{
Q_UNUSED(element)
if (input == kOutBlockInput) {
if (input == k_out_block_input) {
// If node is not a block, this will just be null
if ((connected_out_block_ = dynamic_cast<ClipBlock *>(output))) {
connected_out_block_->set_out_transition(this);
}
} else if (input == kInBlockInput) {
} else if (input == k_in_block_input) {
// If node is not a block, this will just be null
if ((connected_in_block_ = dynamic_cast<ClipBlock *>(output))) {
connected_in_block_->set_in_transition(this);
@@ -298,12 +298,12 @@ void TransitionBlock::InputDisconnectedEvent(const QString &input, int element,
Q_UNUSED(element)
Q_UNUSED(output)
if (input == kOutBlockInput) {
if (input == k_out_block_input) {
if (connected_out_block_) {
connected_out_block_->set_out_transition(nullptr);
connected_out_block_ = nullptr;
}
} else if (input == kInBlockInput) {
} else if (input == k_in_block_input) {
if (connected_in_block_) {
connected_in_block_->set_in_transition(nullptr);
connected_in_block_ = nullptr;
@@ -311,34 +311,34 @@ void TransitionBlock::InputDisconnectedEvent(const QString &input, int element,
}
}
TimeRange TransitionBlock::InputTimeAdjustment(const QString &input,
TimeRange TransitionBlock::input_time_adjustment(const QString &input,
int element,
const TimeRange &input_time,
bool clamp) const
{
if (input == kInBlockInput || input == kOutBlockInput) {
Block *block = dynamic_cast<Block *>(GetConnectedOutput(input));
if (input == k_in_block_input || input == k_out_block_input) {
Block *block = dynamic_cast<Block *>(get_connected_output(input));
if (block) {
// Retransform time as if it came from the track
return input_time + in() - block->in();
}
}
return super::InputTimeAdjustment(input, element, input_time, clamp);
return super::input_time_adjustment(input, element, input_time, clamp);
}
TimeRange
TransitionBlock::OutputTimeAdjustment(const QString &input, int element,
TransitionBlock::output_time_adjustment(const QString &input, int element,
const TimeRange &input_time) const
{
if (input == kInBlockInput || input == kOutBlockInput) {
Block *block = dynamic_cast<Block *>(GetConnectedOutput(input));
if (input == k_in_block_input || input == k_out_block_input) {
Block *block = dynamic_cast<Block *>(get_connected_output(input));
if (block) {
return input_time + block->in() - in();
}
}
return super::OutputTimeAdjustment(input, element, input_time);
return super::output_time_adjustment(input, element, input_time);
}
}
+25 -25
View File
@@ -19,8 +19,8 @@
***/
#ifndef TRANSITIONBLOCK_H
#define TRANSITIONBLOCK_H
#ifndef OAK_TRANSITIONBLOCK_H
#define OAK_TRANSITIONBLOCK_H
#include "node/block/block.h"
@@ -34,10 +34,10 @@ class TransitionBlock : public Block {
public:
TransitionBlock();
virtual void Retranslate() override;
virtual void retranslate() override;
rational in_offset() const;
rational out_offset() const;
Rational in_offset() const;
Rational out_offset() const;
/**
* @brief Return the "middle point" of the transition, relative to the transition
@@ -47,11 +47,11 @@ public:
* 0 means the center of the transition is right in the middle and the in and out offsets will
* be equal.
*/
rational offset_center() const;
void set_offset_center(const rational &r);
Rational offset_center() const;
void set_offset_center(const Rational &r);
void set_offsets_and_length(const rational &in_offset,
const rational &out_offset);
void set_offsets_and_length(const Rational &in_offset,
const Rational &out_offset);
bool is_dual_transition() const
{
@@ -61,21 +61,21 @@ public:
Block *connected_out_block() const;
Block *connected_in_block() const;
double GetTotalProgress(const double &time) const;
double GetOutProgress(const double &time) const;
double GetInProgress(const double &time) const;
double get_total_progress(const double &time) const;
double get_out_progress(const double &time) const;
double get_in_progress(const double &time) const;
virtual void Value(const NodeValueRow &value, const NodeGlobals &globals,
virtual void value(const NodeValueRow &value, const NodeGlobals &globals,
NodeValueTable *table) const override;
virtual void InvalidateCache(
virtual void invalidate_cache(
const TimeRange &range, const QString &from, int element = -1,
InvalidateCacheOptions options = InvalidateCacheOptions()) override;
static const QString kOutBlockInput;
static const QString kInBlockInput;
static const QString kCurveInput;
static const QString kCenterInput;
static const QString k_out_block_input;
static const QString k_in_block_input;
static const QString k_curve_input;
static const QString k_center_input;
protected:
virtual void ShaderJobEvent(const NodeValueRow &value, ShaderJob *job) const
@@ -88,7 +88,7 @@ protected:
{
}
double TransformCurve(double linear) const;
double transform_curve(double linear) const;
virtual void InputConnectedEvent(const QString &input, int element,
Node *output) override;
@@ -96,20 +96,20 @@ protected:
virtual void InputDisconnectedEvent(const QString &input, int element,
Node *output) override;
virtual TimeRange InputTimeAdjustment(const QString &input, int element,
virtual TimeRange input_time_adjustment(const QString &input, int element,
const TimeRange &input_time,
bool clamp) const override;
virtual TimeRange
OutputTimeAdjustment(const QString &input, int element,
output_time_adjustment(const QString &input, int element,
const TimeRange &input_time) const override;
private:
enum CurveType { kLinear, kExponential, kLogarithmic };
enum CurveType { k_linear, k_exponential, k_logarithmic };
double GetInternalTransitionTime(const double &time) const;
double get_internal_transition_time(const double &time) const;
void InsertTransitionTimes(AcceleratedJob *job, const double &time) const;
void insert_transition_times(AcceleratedJob *job, const double &time) const;
ClipBlock *connected_out_block_;
@@ -118,4 +118,4 @@ private:
}
#endif // TRANSITIONBLOCK_H
#endif // OAK_TRANSITIONBLOCK_H