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

Squashed commit of the following:

Browse Source 
commit 8619bb044081da81b4eef238d138bd051e678a4c
Merge: 1a767e0c2 1c30c4d36
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Sun Mar 27 23:59:10 2022 -0700

    Merge branch 'master' into gizmo-rework

commit 1a767e0c2279cac3baf96a9028c1b78ec0491e00
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Sun Mar 27 17:23:07 2022 -0700

    implement custom html parser/exporter

commit bbd9361d345ce864d198f4340b3d59f526e642e5
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Wed Mar 9 22:27:17 2022 -0800

    textgizmo: further improved behavior

commit 27634d5d377f03cab009bca418765d73764893f2
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Wed Mar 9 22:26:19 2022 -0800

    textgizmo: improved double click behavior

commit 0897ebfa36e676461c7a47305a3c1bf66e7a9fd1
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Wed Mar 9 10:20:57 2022 -0800

    text: added more features and improvements

commit 9d6446a25d977ea0c66e5f5c69239aed0e92fe83
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Wed Mar 9 10:14:59 2022 -0800

    text: don't create color input

commit d1d3b9d46e74d8197ba3485a8e965068eb245166
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Wed Mar 9 09:10:23 2022 -0800

    text: convert to reference space

commit 3ba1565129a0bdd74b860b1869fec5ef30025abb
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Mon Mar 7 17:57:26 2022 -0800

    finally got scaling to work

    holy shit I never thought it'd be this easy

commit 081368cfac9b49a171db6c1d576e134903dffac0
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Mon Mar 7 11:25:58 2022 -0800

    improved text behavior

commit f3eda52eee29b7cd354d7d90b3ae1a819e1b1cf2
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Mon Mar 7 11:08:31 2022 -0800

    implemented font styles (weights and italics)

commit 0898b613ec9b473ac93996536d00541e0a2a3f74
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Mon Mar 7 01:26:13 2022 -0800

    implemented beginnings of text gizmo

commit bffb8ede2d425e7391d16bc03e613d4d90367add
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Sun Mar 6 17:55:03 2022 -0800

    conformed transform node to new gizmos

commit 1a1f86fa9bec9ea6b67f77032748c04b6b4c95fd
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Sat Mar 5 11:16:34 2022 -0800

    update polygon node

commit 2388dd69164e8c57e0a1d221c7680a0d39173c2c
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Fri Mar 4 15:31:39 2022 -0800

    implement glsl hack for corner pin

commit e96df6cb326fb278cc6555890ff0ac1d37ebf4bf
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Thu Mar 3 17:06:14 2022 -0800

    updated corner pin

commit c70aa0e72d4e83045c84259294608c1380e8929b
Merge: 5afed6383 780342881
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Thu Mar 3 17:04:40 2022 -0800

    Merge branch 'master' into gizmo-rework

commit 5afed6383952d7d936b5eeda2556339c854610af
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Thu Mar 3 16:55:57 2022 -0800

    use float points for more precise math

commit 159ade0d2812d556dee57f99e3f733ef1e838d01
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Thu Mar 3 16:55:40 2022 -0800

    ported shape node

commit 28f9500d7bc6cd2661ee9ea591db7b3f8d583196
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Thu Mar 3 15:50:19 2022 -0800

    implemented enough dragging code to reimplement crop

    Requires far less boiler-plate code per node

commit 5aeaa59227ad2f1dc3c7f499c636de843a262a88
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Wed Mar 2 19:45:04 2022 -0800

    update just merged corner pin for new gizmos

commit 8a2d041650d1b873c6d87664564ebcdf92a3760f
Merge: c916e8e08 f5b4729a1
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Wed Mar 2 19:38:36 2022 -0800

    Merge branch 'master' into gizmo-rework

commit c916e8e08016c1d0b72d85087db76e4137587d52
Author: itsmattkc <34096995+itsmattkc@users.noreply.github.com>
Date:   Wed Mar 2 19:35:09 2022 -0800

    gizmos: rewrote drawing into standard routines

    Work towards a far more maintainable gizmo system
This commit is contained in:
itsmattkc
2022-03-28 00:01:48 -07:00
parent 1c30c4d361
commit 16580841a6
61 changed files with 3257 additions and 1015 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/node/generator/shape/shapenodebase.cpp
+148 -147
View File
@@ -23,7 +23,7 @@
#include <QtMath>
#include <QVector2D>
#include "common/lerp.h"
#include "common/util.h"
#include "core.h"
namespace olive {
@@ -34,12 +34,30 @@ QString ShapeNodeBase::kPositionInput = QStringLiteral("pos_in");
QString ShapeNodeBase::kSizeInput = QStringLiteral("size_in");
QString ShapeNodeBase::kColorInput = QStringLiteral("color_in");
ShapeNodeBase::ShapeNodeBase()
ShapeNodeBase::ShapeNodeBase(bool create_color_input)
{
AddInput(kPositionInput, NodeValue::kVec2, QVector2D(0, 0));
AddInput(kSizeInput, NodeValue::kVec2, QVector2D(100, 100));
SetInputProperty(kSizeInput, QStringLiteral("min"), QVector2D(0, 0));
AddInput(kColorInput, NodeValue::kColor, QVariant::fromValue(Color(1.0, 0.0, 0.0, 1.0)));
if (create_color_input) {
AddInput(kColorInput, NodeValue::kColor, QVariant::fromValue(Color(1.0, 0.0, 0.0, 1.0)));
}
// Initiate gizmos
QVector<NodeKeyframeTrackReference> pos_n_sz = {
NodeKeyframeTrackReference(NodeInput(this, kPositionInput), 0),
NodeKeyframeTrackReference(NodeInput(this, kPositionInput), 1),
NodeKeyframeTrackReference(NodeInput(this, kSizeInput), 0),
NodeKeyframeTrackReference(NodeInput(this, kSizeInput), 1)
};
poly_gizmo_ = AddDraggableGizmo<PolygonGizmo>({
NodeKeyframeTrackReference(NodeInput(this, kPositionInput), 0),
NodeKeyframeTrackReference(NodeInput(this, kPositionInput), 1),
});
for (int i=0; i<kGizmoScaleCount; i++) {
point_gizmo_[i] = AddDraggableGizmo<PointGizmo>(pos_n_sz, PointGizmo::kAbsolute);
}
}
void ShapeNodeBase::Retranslate()
@@ -48,20 +66,19 @@ void ShapeNodeBase::Retranslate()
SetInputName(kPositionInput, tr("Position"));
SetInputName(kSizeInput, tr("Size"));
SetInputName(kColorInput, tr("Color"));
if (HasInputWithID(kColorInput)) {
SetInputName(kColorInput, tr("Color"));
}
}
void ShapeNodeBase::DrawGizmos(const NodeValueRow &row, const NodeGlobals &globals, QPainter *p)
void ShapeNodeBase::UpdateGizmoPositions(const NodeValueRow &row, const NodeGlobals &globals)
{
// Use offsets to make the appearance of values that start in the top left, even though we
// really anchor around the center
QVector2D center_pt = globals.resolution() * 0.5;
SetInputProperty(kPositionInput, QStringLiteral("offset"), center_pt);
const double handle_radius = GetGizmoHandleRadius(p->transform());
p->setPen(QPen(Qt::white, 0));
QVector2D pos = row[kPositionInput].data().value<QVector2D>();
QVector2D sz = row[kSizeInput].data().value<QVector2D>();
QVector2D half_sz = sz * 0.5;
@@ -70,151 +87,73 @@ void ShapeNodeBase::DrawGizmos(const NodeValueRow &row, const NodeGlobals &globa
double top_pt = pos.y() + center_pt.y() - half_sz.y();
double right_pt = left_pt + sz.x();
double bottom_pt = top_pt + sz.y();
double center_x_pt = lerp(left_pt, right_pt, 0.5);
double center_y_pt = lerp(top_pt, bottom_pt, 0.5);
double center_x_pt = mid(left_pt, right_pt);
double center_y_pt = mid(top_pt, bottom_pt);
gizmo_whole_rect_ = QRectF(left_pt, top_pt, right_pt - left_pt, bottom_pt - top_pt);
p->drawRect(gizmo_whole_rect_);
point_gizmo_[kGizmoScaleTopLeft]->SetPoint(QPointF(left_pt, top_pt));
point_gizmo_[kGizmoScaleTopCenter]->SetPoint(QPointF(center_x_pt, top_pt));
point_gizmo_[kGizmoScaleTopRight]->SetPoint(QPointF(right_pt, top_pt));
point_gizmo_[kGizmoScaleBottomLeft]->SetPoint(QPointF(left_pt, bottom_pt));
point_gizmo_[kGizmoScaleBottomCenter]->SetPoint(QPointF(center_x_pt, bottom_pt));
point_gizmo_[kGizmoScaleBottomRight]->SetPoint(QPointF(right_pt, bottom_pt));
point_gizmo_[kGizmoScaleCenterLeft]->SetPoint(QPointF(left_pt, center_y_pt));
point_gizmo_[kGizmoScaleCenterRight]->SetPoint(QPointF(right_pt, center_y_pt));
gizmo_resize_handle_[kGizmoScaleTopLeft] = CreateGizmoHandleRect(QPointF(left_pt, top_pt), handle_radius);
gizmo_resize_handle_[kGizmoScaleTopCenter] = CreateGizmoHandleRect(QPointF(center_x_pt, top_pt), handle_radius);
gizmo_resize_handle_[kGizmoScaleTopRight] = CreateGizmoHandleRect(QPointF(right_pt, top_pt), handle_radius);
gizmo_resize_handle_[kGizmoScaleBottomLeft] = CreateGizmoHandleRect(QPointF(left_pt, bottom_pt), handle_radius);
gizmo_resize_handle_[kGizmoScaleBottomCenter] = CreateGizmoHandleRect(QPointF(center_x_pt, bottom_pt), handle_radius);
gizmo_resize_handle_[kGizmoScaleBottomRight] = CreateGizmoHandleRect(QPointF(right_pt, bottom_pt), handle_radius);
gizmo_resize_handle_[kGizmoScaleCenterLeft] = CreateGizmoHandleRect(QPointF(left_pt, center_y_pt), handle_radius);
gizmo_resize_handle_[kGizmoScaleCenterRight] = CreateGizmoHandleRect(QPointF(right_pt, center_y_pt), handle_radius);
DrawAndExpandGizmoHandles(p, handle_radius, gizmo_resize_handle_, kGizmoScaleCount);
poly_gizmo_->SetPolygon(QRectF(left_pt, top_pt, right_pt - left_pt, bottom_pt - top_pt));
}
bool ShapeNodeBase::GizmoPress(const NodeValueRow &row, const NodeGlobals &globals, const QPointF &p)
void ShapeNodeBase::GizmoDragMove(double x, double y, const Qt::KeyboardModifiers &modifiers)
{
gizmo_drag_ = -1;
DraggableGizmo *gizmo = static_cast<DraggableGizmo*>(sender());
// See if any of our resize handles have the pointer
for (int i=0; i<kGizmoScaleCount; i++) {
if (gizmo_resize_handle_[i].contains(p)) {
gizmo_drag_ = i;
break;
}
}
NodeInputDragger &x_drag = gizmo->GetDraggers()[0];
NodeInputDragger &y_drag = gizmo->GetDraggers()[1];
// See if the rect has the pointer
if (gizmo_drag_ == -1 && gizmo_whole_rect_.contains(p)) {
gizmo_drag_ = kGizmoWholeRect;
}
if (gizmo_drag_ >= 0) {
gizmo_pos_start_ = row[kPositionInput].data().value<QVector2D>();
gizmo_sz_start_ = row[kSizeInput].data().value<QVector2D>();
gizmo_drag_start_ = p;
gizmo_half_res_ = globals.resolution()/2;
// Get aspect ratio (avoiding potential zero)
if (qFuzzyIsNull(gizmo_sz_start_.y())) {
gizmo_aspect_ratio_ = 0;
} else {
gizmo_aspect_ratio_ = gizmo_sz_start_.x() / gizmo_sz_start_.y();
}
return true;
}
return false;
}
enum {
kGDPosX,
kGDPosY,
kGDSzX,
kGDSzY,
kGDCount
};
QVector2D ShapeNodeBase::GenerateGizmoAnchor(const QVector2D &pos, const QVector2D &size, int drag, QVector2D *pt = nullptr)
{
QVector2D anchor = pos;
QVector2D half_sz = size/2;
if (drag == kGizmoScaleTopLeft || drag == kGizmoScaleCenterLeft || drag == kGizmoScaleBottomLeft) {
anchor.setX(anchor.x() + half_sz.x());
if (pt && pt->x() > anchor.x()) {
pt->setX(anchor.x());
}
}
if (drag == kGizmoScaleTopRight || drag == kGizmoScaleCenterRight || drag == kGizmoScaleBottomRight) {
anchor.setX(anchor.x() - half_sz.x());
if (pt && pt->x() < anchor.x()) {
pt->setX(anchor.x());
}
}
if (drag == kGizmoScaleTopLeft || drag == kGizmoScaleTopCenter || drag == kGizmoScaleTopRight) {
anchor.setY(anchor.y() + half_sz.y());
if (pt && pt->y() > anchor.y()) {
pt->setY(anchor.y());
}
}
if (drag == kGizmoScaleBottomLeft || drag == kGizmoScaleBottomCenter || drag == kGizmoScaleBottomRight) {
anchor.setY(anchor.y() - half_sz.y());
if (pt && pt->y() < anchor.y()) {
pt->setY(anchor.y());
}
}
return anchor;
}
void ShapeNodeBase::GizmoMove(const QPointF &p, const rational &time, const Qt::KeyboardModifiers &modifiers)
{
if (gizmo_dragger_.isEmpty()) {
gizmo_dragger_.resize(kGDCount);
gizmo_dragger_[kGDPosX].Start(NodeKeyframeTrackReference(NodeInput(this, kPositionInput), 0), time);
gizmo_dragger_[kGDPosY].Start(NodeKeyframeTrackReference(NodeInput(this, kPositionInput), 1), time);
gizmo_dragger_[kGDSzX].Start(NodeKeyframeTrackReference(NodeInput(this, kSizeInput), 0), time);
gizmo_dragger_[kGDSzY].Start(NodeKeyframeTrackReference(NodeInput(this, kSizeInput), 1), time);
}
bool from_center = modifiers & Qt::AltModifier;
bool keep_ratio = modifiers & Qt::ShiftModifier;
QVector2D adjusted_pt(p.x(), p.y());
QVector2D diff(adjusted_pt.x() - gizmo_drag_start_.x(), adjusted_pt.y() - gizmo_drag_start_.y());
if (gizmo_drag_ == kGizmoWholeRect) {
// Simply move position by difference
gizmo_dragger_[kGDPosX].Drag(gizmo_pos_start_.x() + diff.x());
gizmo_dragger_[kGDPosY].Drag(gizmo_pos_start_.y() + diff.y());
if (gizmo == poly_gizmo_) {
x_drag.Drag(x_drag.GetStartValue().toDouble() + x);
y_drag.Drag(y_drag.GetStartValue().toDouble() + y);
} else {
bool from_center = modifiers & Qt::AltModifier;
bool keep_ratio = modifiers & Qt::ShiftModifier;
NodeInputDragger &w_drag = gizmo->GetDraggers()[2];
NodeInputDragger &h_drag = gizmo->GetDraggers()[3];
QVector2D gizmo_sz_start(w_drag.GetStartValue().toDouble(), h_drag.GetStartValue().toDouble());
QVector2D gizmo_pos_start(x_drag.GetStartValue().toDouble(), y_drag.GetStartValue().toDouble());
QVector2D gizmo_half_res = gizmo->GetGlobals().resolution()/2;
QVector2D adjusted_pt(x, y);
QVector2D new_size;
QVector2D new_pos;
QVector2D anchor;
static const int kXYCount = 2;
bool negative[kXYCount] = {false};
double original_ratio;
if (keep_ratio) {
original_ratio = w_drag.GetStartValue().toDouble() / h_drag.GetStartValue().toDouble();
}
// Calculate new size
if (from_center) {
// Calculate new size by using distance from center and doubling it
new_size = (adjusted_pt - gizmo_half_res_ - gizmo_pos_start_) * 2;
new_size = (adjusted_pt - gizmo_half_res - gizmo_pos_start) * 2;
if (gizmo_drag_ == kGizmoScaleTopCenter || gizmo_drag_ == kGizmoScaleTopLeft || gizmo_drag_ == kGizmoScaleTopRight) {
if (IsGizmoTop(gizmo)) {
new_size.setY(-new_size.y());
}
if (gizmo_drag_ == kGizmoScaleTopLeft || gizmo_drag_ == kGizmoScaleCenterLeft || gizmo_drag_ == kGizmoScaleBottomLeft) {
if (IsGizmoLeft(gizmo)) {
new_size.setX(-new_size.x());
}
} else {
// Calculate new size by using distance from "anchor" - i.e. the opposite point of the shape
// from the gizmo being dragged
adjusted_pt -= gizmo_half_res_;
adjusted_pt -= gizmo_half_res;
anchor = GenerateGizmoAnchor(gizmo_pos_start_, gizmo_sz_start_, gizmo_drag_, &adjusted_pt) + gizmo_half_res_;
anchor = GenerateGizmoAnchor(gizmo_pos_start, gizmo_sz_start, gizmo, &adjusted_pt) + gizmo_half_res;
adjusted_pt += gizmo_half_res_;
adjusted_pt += gizmo_half_res;
// Calculate size and position
new_size = adjusted_pt - anchor;
@@ -229,32 +168,31 @@ void ShapeNodeBase::GizmoMove(const QPointF &p, const rational &time, const Qt::
}
// Restrict sizes by constraints
if (gizmo_drag_ == kGizmoScaleTopCenter || gizmo_drag_ == kGizmoScaleBottomCenter) {
if (IsGizmoVerticalCenter(gizmo)) {
if (keep_ratio) {
// Calculate width from new height
new_size.setX(new_size.y() * gizmo_aspect_ratio_);
new_size.setX(new_size.y() * original_ratio);
} else {
// Constrain to original width
new_size.setX(gizmo_sz_start_.x());
new_size.setX(gizmo_sz_start.x());
}
}
if (gizmo_drag_ == kGizmoScaleCenterLeft || gizmo_drag_ == kGizmoScaleCenterRight) {
if (IsGizmoHorizontalCenter(gizmo)) {
if (keep_ratio) {
// Calculate height from new width
new_size.setY(new_size.x() / gizmo_aspect_ratio_);
new_size.setY(new_size.x() / original_ratio);
} else {
// Constrain to original height
new_size.setY(gizmo_sz_start_.y());
new_size.setY(gizmo_sz_start.y());
}
}
if (gizmo_drag_ == kGizmoScaleTopLeft || gizmo_drag_ == kGizmoScaleTopRight
|| gizmo_drag_ == kGizmoScaleBottomRight || gizmo_drag_ == kGizmoScaleBottomLeft) {
if (IsGizmoCorner(gizmo)) {
if (keep_ratio) {
float hypot = std::hypot(new_size.x(), new_size.y());
float original_angle = std::atan2(gizmo_sz_start_.x(), gizmo_sz_start_.y());
float original_angle = std::atan2(gizmo_sz_start.x(), gizmo_sz_start.y());
// Calculate new size based on original angle and hypotenuse
new_size.setX(std::sin(original_angle) * hypot);
@@ -264,7 +202,7 @@ void ShapeNodeBase::GizmoMove(const QPointF &p, const rational &time, const Qt::
// Calculate position
if (from_center) {
new_pos = gizmo_pos_start_;
new_pos = gizmo_pos_start;
} else {
QVector2D using_size = new_size;
@@ -276,31 +214,94 @@ void ShapeNodeBase::GizmoMove(const QPointF &p, const rational &time, const Qt::
}
// I'm pretty sure there's an algorithmic way of doing this, but I'm tired and this works
if (gizmo_drag_ == kGizmoScaleCenterLeft || gizmo_drag_ == kGizmoScaleCenterRight) {
if (IsGizmoHorizontalCenter(gizmo)) {
using_size.setY(0);
}
if (gizmo_drag_ == kGizmoScaleTopCenter || gizmo_drag_ == kGizmoScaleBottomCenter) {
if (IsGizmoVerticalCenter(gizmo)) {
using_size.setX(0);
}
new_pos = GenerateGizmoAnchor(gizmo_pos_start_, gizmo_sz_start_, gizmo_drag_) + using_size / 2;
new_pos = GenerateGizmoAnchor(gizmo_pos_start, gizmo_sz_start, gizmo) + using_size / 2;
}
gizmo_dragger_[kGDPosX].Drag(new_pos.x());
gizmo_dragger_[kGDPosY].Drag(new_pos.y());
gizmo_dragger_[kGDSzX].Drag(new_size.x());
gizmo_dragger_[kGDSzY].Drag(new_size.y());
x_drag.Drag(new_pos.x());
y_drag.Drag(new_pos.y());
w_drag.Drag(new_size.x());
h_drag.Drag(new_size.y());
}
}
void ShapeNodeBase::GizmoRelease(MultiUndoCommand *command)
QVector2D ShapeNodeBase::GenerateGizmoAnchor(const QVector2D &pos, const QVector2D &size, NodeGizmo *gizmo, QVector2D *pt) const
{
for (NodeInputDragger& i : gizmo_dragger_) {
i.End(command);
QVector2D anchor = pos;
QVector2D half_sz = size/2;
if (IsGizmoLeft(gizmo)) {
anchor.setX(anchor.x() + half_sz.x());
if (pt && pt->x() > anchor.x()) {
pt->setX(anchor.x());
}
}
gizmo_dragger_.clear();
if (IsGizmoRight(gizmo)) {
anchor.setX(anchor.x() - half_sz.x());
if (pt && pt->x() < anchor.x()) {
pt->setX(anchor.x());
}
}
if (IsGizmoTop(gizmo)) {
anchor.setY(anchor.y() + half_sz.y());
if (pt && pt->y() > anchor.y()) {
pt->setY(anchor.y());
}
}
if (IsGizmoBottom(gizmo)) {
anchor.setY(anchor.y() - half_sz.y());
if (pt && pt->y() < anchor.y()) {
pt->setY(anchor.y());
}
}
return anchor;
}
bool ShapeNodeBase::IsGizmoTop(NodeGizmo *g) const
{
return g == point_gizmo_[kGizmoScaleTopCenter] || g == point_gizmo_[kGizmoScaleTopLeft] || g == point_gizmo_[kGizmoScaleTopRight];
}
bool ShapeNodeBase::IsGizmoBottom(NodeGizmo *g) const
{
return g == point_gizmo_[kGizmoScaleBottomCenter] || g == point_gizmo_[kGizmoScaleBottomLeft] || g == point_gizmo_[kGizmoScaleBottomRight];
}
bool ShapeNodeBase::IsGizmoLeft(NodeGizmo *g) const
{
return g == point_gizmo_[kGizmoScaleTopLeft] || g == point_gizmo_[kGizmoScaleCenterLeft] || g == point_gizmo_[kGizmoScaleBottomLeft];
}
bool ShapeNodeBase::IsGizmoRight(NodeGizmo *g) const
{
return g == point_gizmo_[kGizmoScaleTopRight] || g == point_gizmo_[kGizmoScaleCenterRight] || g == point_gizmo_[kGizmoScaleBottomRight];
}
bool ShapeNodeBase::IsGizmoHorizontalCenter(NodeGizmo *g) const
{
return g == point_gizmo_[kGizmoScaleCenterLeft] || g == point_gizmo_[kGizmoScaleCenterRight];
}
bool ShapeNodeBase::IsGizmoVerticalCenter(NodeGizmo *g) const
{
return g == point_gizmo_[kGizmoScaleTopCenter] || g == point_gizmo_[kGizmoScaleBottomCenter];
}
bool ShapeNodeBase::IsGizmoCorner(NodeGizmo *g) const
{
return g == point_gizmo_[kGizmoScaleTopLeft] || g == point_gizmo_[kGizmoScaleTopRight]
|| g == point_gizmo_[kGizmoScaleBottomRight] || g == point_gizmo_[kGizmoScaleBottomLeft];
}
}