void Layout::synchronizeItem(Item*& layoutItem, Item*& externalItem, Model::Node* node)
{
// When refactoring this method have in mind that layoutItem might point to the same item as externalItem.
if (externalItem != layoutItem)
{
SAFE_DELETE_ITEM(layoutItem);
setUpdateNeeded();
}
if (externalItem && externalItem->node() != node )
{
SAFE_DELETE_ITEM(externalItem);
layoutItem = nullptr; // One of the safe deletes above deleted this item
setUpdateNeeded();
}
if (!externalItem && node)
{
externalItem = renderer()->render(nullptr, node);
externalItem->setParentItem(this);
layoutItem = externalItem;
setUpdateNeeded();
}
}
void PoseLerpNodeInstance::update(){
try {
real64 blend_factor= factorIn->get();
if (limitFactorIn->get())
blend_factor= util::limited(blend_factor, 0.0, 1.0);
auto pose1= input1->get().getLocalInBindPose();
auto pose2= input2->get().getLocalInBindPose();
animation::ArmaturePose::Pose result_pose;
if (!pose1.empty() && !pose2.empty()){
result_pose= lerp(pose1, pose2, blend_factor);
}
else { // Poses not delivered properly to inputs
if (!pose1.empty())
result_pose= pose1;
else if (!pose2.empty())
result_pose= pose2;
}
if (!result_pose.empty()){
resultOut->send(
animation::ArmaturePose(input1->get().getArmature(), std::move(result_pose))
);
}
}
catch (global::Exception& e){
print(debug::Ch::Nodes, debug::Vb::Moderate, "ArmaturePose lerp failed: %s", e.what());
}
setUpdateNeeded(false);
}
void RollBotAiNode::create()
{
aIn= addInputSlot<SignalType::RtTransform2>("acceleration");
omegaIn= addInputSlot<SignalType::Real>("angularVelocity");
torqueMulIn= addInputSlot<SignalType::Real>("torqueMul");
wakeUpIn= addInputSlot<SignalType::Trigger>("wakeUp");
timeAwakeIn= addInputSlot<SignalType::Real>("timeAwake");
escapeIn= addInputSlot<SignalType::Vec2>("escape");
positionIn= addInputSlot<SignalType::Vec2>("position");
torqueOut= addOutputSlot<SignalType::Real>("torque");
awakeOut= addOutputSlot<SignalType::Boolean>("awake");
wantedDirection= 0;
frustration= 0.0;
lastOmega= 0.0;
hardPushTimeout= 0.0;
thinkingTimeout= 0.0;
thinkingProbability= 0.0;
startSleepingAfterThinking= false;
sleeping= true;
wakeUpTimer= 0.0;
wakeUpIn->setOnReceiveCallback(MAKE_MOD_FPTR(callback_wakeUp));
setUpdateNeeded(true);
}
void AlignmentView::setLcbHover(int lcb, float offset)
{
highlight = true;
highlightLcb = lcb;
highlightOffset = offset;
setUpdateNeeded();
}
void PanelBorderLayout::setContent(Item* content, bool deleteOldContent)
{
if (content_ == content) return;
if ( deleteOldContent ) SAFE_DELETE_ITEM(content_);
else if (content_) content_->setParentItem(nullptr);
if ( content ) content->setParentItem(this);
content_ = content;
setUpdateNeeded();
}
void HMethod::keyPressEvent(Visualization::Item *target, QKeyEvent *event)
{
bool createDown = event->modifiers() == Qt::NoModifier &&
(event->key() == Qt::Key_Enter || event->key() == Qt::Key_Return);
bool createRight = event->modifiers() == Qt::ShiftModifier &&
(event->key() == Qt::Key_Enter || event->key() == Qt::Key_Return);
//bool switchVertical = event->modifiers() == Qt::NoModifier && event->key() == Qt::Key_Tab;
bool switchHorizontal = event->modifiers() == Qt::ShiftModifier && event->key() == Qt::Key_Tab;
bool processed = false;
auto m = dynamic_cast<OOVisualization::VMethod*> ( target );
if (m)
{
if ( (m->name()->itemOrChildHasFocus() || m->arguments()->itemOrChildHasFocus()) && createDown)
{
processed = true;
if (m->node()->items()->size() > 0)
{
target->scene()->addPostEventAction( new Interaction::SetCursorEvent(target, m->node()->items()->at(0)));
}
else
{
auto empty = new OOModel::EmptyExpression();
auto es = new OOModel::ExpressionStatement();
es->setExpression(empty);
m->node()->model()->beginModification(m->node(), "add empty statement");
m->node()->items()->append(es);
m->node()->model()->endModification();
m->setUpdateNeeded(Visualization::Item::StandardUpdate);
target->scene()->addPostEventAction( new Interaction::SetCursorEvent(target, empty));
}
}
else if (m->name()->itemOrChildHasFocus() && switchHorizontal)
{
processed = true;
if (m->node()->arguments()->size() > 0)
{
target->scene()->addPostEventAction( new Interaction::SetCursorEvent(target,
m->node()->arguments()->at(0)));
}
}
else if ( (m->name()->itemOrChildHasFocus()) && createRight)
{
processed = true;
createNewArgument(m, 0);
}
}
if (!processed) GenericHandler::keyPressEvent(target, event);
}
void SrtTransform2RandomizeNodeInstance::update()
{
util::SrtTransform2d t= transformIn->get();
t.rotation += util::Rand::continuous(-rotBiasIn->get(), rotBiasIn->get());
t.scale *= 1.0 + util::Rand::continuous(-scaleBiasIn->get(), scaleBiasIn->get());
if (flipXIn->get() && util::Rand::discrete(0, 1) == 0)
t.scale.x *= -1.0;
transformOut->send(t);
setUpdateNeeded(false);
}
void RealAddNodeInstance::create()
{
input1= addInputSlot<SignalType::Real>("input1");
input2= addInputSlot<SignalType::Real>("input2");
realOut= addOutputSlot<SignalType::Real>("result");
auto recv= +[] (RealAddNodeInstance* self)
{ self->realOut->send(self->input1->get() + self->input2->get()); };
input1->setOnReceiveCallback(recv);
input2->setOnReceiveCallback(recv);
setUpdateNeeded(false);
}
void PoseLerpNodeInstance::create(){
input1= addInputSlot<SignalType::ArmaturePose>("input1");
input2= addInputSlot<SignalType::ArmaturePose>("input2");
factorIn= addInputSlot<SignalType::Real>("factor");
limitFactorIn= addInputSlot<SignalType::Boolean>("limitFactor");
resultOut= addOutputSlot<SignalType::ArmaturePose>("result");
auto cb= +[] (PoseLerpNodeInstance* self){ self->setUpdateNeeded(); };
input1->setOnReceiveCallback(cb);
input2->setOnReceiveCallback(cb);
factorIn->setOnReceiveCallback(cb);
setUpdateNeeded(false);
}
void AlignmentView::mouseMoveEvent(QMouseEvent * event)
{
TrackListView::mouseMoveEvent(event);
//float diff = qPow(qPow(event->pos().x() - getCursorX(), 2) + qPow(event->pos().y() - getCursorY(), 2), .5);
cursorX = event->pos().x();
cursorY = event->pos().y();
cursorSize = 8;// + diff * 1000 / width();
if ( cursorSize > 20 )
{
cursorSize = 20;
}
if
(
cursorX >= frameWidth() && cursorX < width() - frameWidth() * 2 &&
cursorY >= frameWidth() && cursorY < height() - frameWidth() * 2
)
{
highlightTrack = getTrackHover();
//if ( highlightTrack == trackFocus )
{
highlight = true;
// float position = (float)x / (width() - frameWidth() * 2);
int position = cursorX - frameWidth();
int w = width() - frameWidth() * 2;
highlightLcb = trackViews[highlightTrack].getLcb(position, w, highlightOffset);
highlightRc = trackViews[highlightTrack].getRc() != trackViews[highlightTrack].getLcbRc(highlightLcb);
setUpdateNeeded();
signalLcbHoverChange(highlightLcb, highlightOffset);
}
//printf("%d (%d, %d): %d\n", highlightTrack, event->pos().x(), event->pos().y(), highlightLcb);
}
if ( cursorSize < 10 )
{
// cursorSize += 1;
}
//DrawingArea::update();
}
void SrtTransform2RandomizeNodeInstance::create()
{
transformIn= addInputSlot<SignalType::SrtTransform2>("transform");
rotBiasIn= addInputSlot<SignalType::Real>("rotBias");
scaleBiasIn= addInputSlot<SignalType::Real>("scaleBias");
flipXIn= addInputSlot<SignalType::Boolean>("flipX");
transformOut= addOutputSlot<SignalType::SrtTransform2>("randomized");
auto recv= +[] (SrtTransform2RandomizeNodeInstance* self)
{ self->setUpdateNeeded(true); };
transformIn->setOnReceiveCallback(recv);
rotBiasIn->setOnReceiveCallback(recv);
scaleBiasIn->setOnReceiveCallback(recv);
flipXIn->setOnReceiveCallback(recv);
setUpdateNeeded(false);
}
void IPLProcess::requestUpdate()
{
setUpdateNeeded(true);
//notifyPropertyChangedEventHandler();
}
void RootItem::setItem(Item* item)
{
item_ = item;
if (item_) item_->setParentItem(this);
setUpdateNeeded(StandardUpdate);
}
void ControlFlowItem::clearConnectors()
{
connectors_.clear();
arrowEndings_.clear();
setUpdateNeeded();
}
void ControlFlowItem::addConnector(QList< QPoint >& points, bool arrowEnding)
{
connectors_.append(points);
arrowEndings_.append(arrowEnding);
setUpdateNeeded();
}
void PanelBorderLayout::setPanel(bool enable, PanelLayout*& panel, const PanelLayoutStyle& style)
{
if ( enable && !panel ) panel = new PanelLayout(this, &style);
if ( !enable && panel ) SAFE_DELETE_ITEM(panel);
setUpdateNeeded();
}
