/* virtual */ void
av::tools::ChangeSelector::evaluate()
{
av::tools::Selector::evaluate();
const MFTargetHolder::ContainerType &targets = Targets.getValue();
MFTargetHolder::ContainerType added_targets, kept_targets, removed_targets;
for (MFTargetHolder::ContainerType::const_iterator last_holder = mLastTargets.begin();
last_holder != mLastTargets.end(); ++last_holder)
{
if (!hasTarget(targets, (*last_holder)->Target.getValue()))
removed_targets.push_back(*last_holder);
}
for (MFTargetHolder::ContainerType::const_iterator holder = targets.begin();
holder != targets.end(); ++holder)
{
const SFContainer::ValueType &target = (*holder)->Target.getValue();
(hasTarget(mLastTargets, target) ? kept_targets : added_targets).push_back(*holder);
}
if (!removed_targets.empty() || !RemovedTargets.isEmpty())
RemovedTargets.setValue(removed_targets);
if (!kept_targets.empty() || !KeptTargets.isEmpty())
KeptTargets.setValue(kept_targets);
if (!added_targets.empty() || !SelectedTargets.isEmpty())
SelectedTargets.setValue(added_targets);
mLastTargets = targets;
alwaysEvaluate(!added_targets.empty() || !removed_targets.empty());
}
void ToolManager::deselect()
{
if(hasTarget()){
hasSelected = false;
getTarget()->deselectObj();
currentTool->axis.deselectObj();
Interface::setCurrentSelectList(Interface::displayList);
}
}
/* virtual */ void av::tools::Tool::evaluate()
{
av::FieldContainer::evaluate();
const MFTargetHolder::ContainerType& targets = Targets.getValue();
for(MFTargetHolder::ContainerType::const_iterator last_holder = mLastTargets.begin(); last_holder != mLastTargets.end(); ++last_holder)
{
if(!hasTarget(targets, (*last_holder)->Target.getValue()))
evaluateRemovedTarget(**last_holder);
}
for(MFTargetHolder::ContainerType::const_iterator holder = targets.begin(); holder != targets.end(); ++holder)
{
evaluateTarget(**holder);
if(hasTarget(mLastTargets, (*holder)->Target.getValue()))
evaluateKeptTarget(**holder);
else
evaluateAddedTarget(**holder);
}
mLastTargets = targets;
}
bool CursorManager::onTarget(boost::shared_ptr<world::IngameObject> obj) {
if (!hasTarget()) {
return false;
}
if (target_->acceptsTarget(obj)) {
target_->onTarget(obj);
target_.reset();
updateCursor();
return true;
} else {
return false;
}
}
void GraphNodeLink::draw(NVGcontext* ctx)
{
auto sourceSize = mSource->size().cast<float>();
Eigen::Vector2i inputPosition(
mSource->absolutePosition().x() - mParent->absolutePosition().x() + (sourceSize.x() * 0.5f),
mSource->absolutePosition().y() - mParent->absolutePosition().y() + (sourceSize.y() * 0.5f)
);
Eigen::Vector2i outputPosition(Eigen::Vector2i::Zero());
if (hasTarget()) {
// Get relative position of parent (node) of the target (sink)
Eigen::Vector2i delta = mSink->parent()->absolutePosition() - mSink->parent()->position();
delta.x() -= (sourceSize.x() * 0.5f);
delta.y() -= (sourceSize.y() * 0.5f);
outputPosition = mSink->absolutePosition() - delta;
}
else {
Eigen::Vector2i offset = mSource->absolutePosition() - mParent->absolutePosition();
Eigen::Vector2i delta = mTargetPosition - mSource->position();
outputPosition = offset + delta;
}
Eigen::Vector2i positionDiff = outputPosition - inputPosition;
NVGcontext* vg = ctx;
nvgStrokeColor(vg, nvgRGBA(131, 148, 150, 255));
nvgStrokeWidth(vg, 2.0f);
nvgBeginPath(vg);
nvgMoveTo(
vg,
inputPosition.x(),
inputPosition.y()
);
nvgQuadTo(vg,
1.2 * positionDiff.x(), positionDiff.y(),
outputPosition.x(), outputPosition.y()
);
nvgStroke(vg);
Widget::draw(ctx);
}
/* virtual */ void
av::tools::UnionSelector::evaluate()
{
av::tools::Selector::evaluate();
if (TargetSet1.isEmpty())
{
if (!TargetSet2.isEmpty())
SelectedTargets.setValue(TargetSet2.getValue());
else if (!SelectedTargets.isEmpty())
SelectedTargets.clear();
}
else if (TargetSet2.isEmpty())
SelectedTargets.setValue(TargetSet1.getValue());
else
{
const MFTargetHolder::ContainerType &set1 = TargetSet1.getValue();
const MFTargetHolder::ContainerType &set2 = TargetSet2.getValue();
MFTargetHolder::ContainerType selected_targets;
for (MFTargetHolder::ContainerType::const_iterator holder1 = set1.begin();
holder1 != set1.end(); ++holder1)
{
const SFContainer::ValueType &target = (*holder1)->Target.getValue();
MFTargetHolder::ContainerType::const_iterator holder2 = find(set2, target);
if (holder2 == set2.end())
selected_targets.push_back(*holder1);
else
selected_targets.push_back(combine(*holder1, *holder2));
}
for (MFTargetHolder::ContainerType::const_iterator holder2 = set2.begin();
holder2 != set2.end(); ++holder2)
{
if (!hasTarget(set1, (*holder2)->Target.getValue()))
selected_targets.push_back(*holder2);
}
SelectedTargets.setValue(selected_targets);
}
}
std::unique_ptr<CompilerInstance>
prepareCompilerInstance(std::unique_ptr<clang::CompilerInvocation> CI,
const PrecompiledPreamble *Preamble,
std::unique_ptr<llvm::MemoryBuffer> Buffer,
std::shared_ptr<PCHContainerOperations> PCHs,
IntrusiveRefCntPtr<vfs::FileSystem> VFS,
DiagnosticConsumer &DiagsClient) {
assert(VFS && "VFS is null");
assert(!CI->getPreprocessorOpts().RetainRemappedFileBuffers &&
"Setting RetainRemappedFileBuffers to true will cause a memory leak "
"of ContentsBuffer");
// NOTE: we use Buffer.get() when adding remapped files, so we have to make
// sure it will be released if no error is emitted.
if (Preamble) {
Preamble->OverridePreamble(*CI, VFS, Buffer.get());
} else {
CI->getPreprocessorOpts().addRemappedFile(
CI->getFrontendOpts().Inputs[0].getFile(), Buffer.get());
}
auto Clang = llvm::make_unique<CompilerInstance>(PCHs);
Clang->setInvocation(std::move(CI));
Clang->createDiagnostics(&DiagsClient, false);
if (auto VFSWithRemapping = createVFSFromCompilerInvocation(
Clang->getInvocation(), Clang->getDiagnostics(), VFS))
VFS = VFSWithRemapping;
Clang->setVirtualFileSystem(VFS);
Clang->setTarget(TargetInfo::CreateTargetInfo(
Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));
if (!Clang->hasTarget())
return nullptr;
// RemappedFileBuffers will handle the lifetime of the Buffer pointer,
// release it.
Buffer.release();
return Clang;
}
void CursorManager::updateCursor() {
unsigned int cursorId = CursorType::GAME_WEST;
if ((enableFlags_ & CursorEnableFlags::OVERRIDE) && cursorOverride_ != 0xFFFFFFFFu) {
cursorId = cursorOverride_;
} else if (hasTarget()) {
cursorId = CursorType::TARGET;
} else if (enableFlags_ & CursorEnableFlags::DIRECTION) {
cursorId = cursorDirection_;
}
if (warMode_) {
cursorId += CursorType::COUNT;
}
//LOG_DEBUG << "NEW CURSOR ID: " << cursorId
//<< " enable: " << std::hex << enableFlags_ << std::dec
//<< " dir: " << cursorDirection_
//<< " override: " << cursorOverride_
//<< " target?: " << hasTarget()
//<< " warmode?: " << warMode_
//<< std::endl;
cursorImages_[cursorId].activate();
}
void WebGLQuery::updateCachedResult(gpu::gles2::GLES2Interface* gl) {
if (m_queryResultAvailable)
return;
if (!m_canUpdateAvailability)
return;
if (!hasTarget())
return;
// We can only update the cached result when control returns to the browser.
m_canUpdateAvailability = false;
GLuint available = 0;
gl->GetQueryObjectuivEXT(object(), GL_QUERY_RESULT_AVAILABLE_EXT, &available);
m_queryResultAvailable = !!available;
if (m_queryResultAvailable) {
GLuint result = 0;
gl->GetQueryObjectuivEXT(object(), GL_QUERY_RESULT_EXT, &result);
m_queryResult = result;
m_taskHandle.cancel();
} else {
scheduleAllowAvailabilityUpdate();
}
}
bool AIComponent::setTargetId(std::size_t target)
{
mTarget = target;
return hasTarget();
}
/* virtual */ void av::tools::ProximitySelector::evaluate()
{
av::tools::Selector::evaluate();
// get needed field values
const MFContainer::ContainerType& target_objects = TargetObjects.getValue();
const MFTargetHolder::ContainerType& targets = Targets.getValue();
const ::gua::math::vec3 pos = PositionTransform.getValue() * Position.getValue();
const double prox_radius = ProximityRadius.getValue();
const double dist_radius = DistanceRadius.getValue();
const double time = Time.getValue();
const double lag = ProximityLag.getValue();
const unsigned int max_targets = MaxNumberOfTargets.getValue();
// remove proximity candidates, which are no longer in the target lists
{
TargetTimeList_t::iterator cand = mProxCands.begin();
while(cand != mProxCands.end())
{
if(hasObject(target_objects, cand->first) || av::tools::hasTarget(targets, cand->first))
++cand;
else
cand = mProxCands.erase(cand);
}
}
// remove distance candidates, which are no longer in the target lists
{
TargetTimeList_t::iterator cand = mDistCands.begin();
while(cand != mDistCands.end())
{
if(hasObject(target_objects, cand->first) || av::tools::hasTarget(targets, cand->first))
++cand;
else
{
MFTargetHolder::ContainerType::iterator holder = av::tools::find(mSelTargets, cand->first);
if(holder != mSelTargets.end())
mSelTargets.erase(holder);
else
logger.warn() << "distance candidate was not in selected targets";
cand = mDistCands.erase(cand);
}
}
}
// remove selected targets, which are no longer in the target lists
{
MFTargetHolder::ContainerType::iterator holder = mSelTargets.begin();
while(holder != mSelTargets.end())
{
const SFContainer::ValueType& target = (*holder)->Target.getValue();
if(hasObject(target_objects, target) || av::tools::hasTarget(targets, target))
++holder;
else
holder = mSelTargets.erase(holder);
}
}
TargetTimeList_t new_prox_cands, new_dist_cands;
MFTargetHolder::ContainerType new_sel_targets;
// check for new proximity candidates in TargetObjects
for(MFContainer::ContainerType::const_iterator target = target_objects.begin(); target != target_objects.end(); ++target)
{
if(!hasTarget(mProxCands, *target) && !av::tools::hasTarget(mSelTargets, *target))
{
// we only accept gua nodes to get the absolute transform
Link<av::gua::Node> node = dynamic_cast<av::gua::Node*>(target->getBasePtr());
if(node.isValid())
{
const ::gua::math::mat4 nodeTransform(node->getGuaNode()->get_world_transform());
const ::gua::math::vec3 nodeTranslation(nodeTransform[12], nodeTransform[13], nodeTransform[14]);
if(distance(pos, nodeTranslation) < prox_radius)
{
if(lag > 0.000001)
new_prox_cands.push_back(TargetTimePair_t(node, time));
else
{
new_sel_targets.push_back(new TargetHolder);
new_sel_targets.back()->Target.setValue(*target);
new_sel_targets.back()->Creator.setValue(this);
}
}
}
}
}
// check for new proximity candidates in Targets
for(MFTargetHolder::ContainerType::const_iterator holder = targets.begin(); holder != targets.end(); ++holder)
{
const SFContainer::ValueType& target = (*holder)->Target.getValue();
if(!hasTarget(mProxCands, target) && !av::tools::hasTarget(mSelTargets, target))
{
// we only accept gua nodes to get the absolute transform
Link<av::gua::Node> node = dynamic_cast<av::gua::Node*>(target.getBasePtr());
if(node.isValid())
{
const ::gua::math::mat4 nodeTransform(node->getGuaNode()->get_world_transform());
const ::gua::math::vec3 nodeTranslation(nodeTransform[12], nodeTransform[13], nodeTransform[14]);
if(distance(pos, nodeTranslation) < prox_radius)
{
if(lag > 0.000001)
new_prox_cands.push_back(TargetTimePair_t(node, time));
else
new_sel_targets.push_back(*holder);
}
}
}
}
// check if proximity candidates are out of range or have timed out
{
TargetTimeList_t::iterator cand = mProxCands.begin();
while(cand != mProxCands.end())
{
const ::gua::math::mat4 candTransform(cand->first->getGuaNode()->get_world_transform());
const ::gua::math::vec3 candTranslation(candTransform[12], candTransform[13], candTransform[14]);
if(distance(pos, candTranslation) > prox_radius)
cand = mProxCands.erase(cand);
else if(time - cand->second > lag)
{
MFTargetHolder::ContainerType::const_iterator holder = av::tools::find(targets, cand->first);
if(holder != targets.end())
new_sel_targets.push_back(*holder);
else
{
new_sel_targets.push_back(new TargetHolder);
new_sel_targets.back()->Target.setValue(cand->first);
new_sel_targets.back()->Creator.setValue(this);
}
cand = mProxCands.erase(cand);
}
else
++cand;
}
}
// check for updated target holders and if selected targets are out of range
{
MFTargetHolder::ContainerType::iterator holder = mSelTargets.begin();
while(holder != mSelTargets.end())
{
const SFContainer::ValueType target = (*holder)->Target.getValue();
MFTargetHolder::ContainerType::const_iterator input_holder = av::tools::find(targets, target);
if(input_holder != targets.end() && *holder != *input_holder)
*holder = *input_holder;
if(hasTarget(mDistCands, target))
++holder;
else
{
// we only accept gua nodes to get the absolute transform
Link<av::gua::Node> node = dynamic_cast<av::gua::Node*>(target.getBasePtr());
if(node.isValid())
{
const ::gua::math::mat4 nodeTransform(node->getGuaNode()->get_world_transform());
const ::gua::math::vec3 nodeTranslation(nodeTransform[12], nodeTransform[13], nodeTransform[14]);
if(distance(pos, nodeTranslation) < prox_radius)
{
if(lag > 0.000001)
{
new_dist_cands.push_back(TargetTimePair_t(node, time));
++holder;
}
else
holder = mSelTargets.erase(holder);
}
else
++holder;
}
else
{
holder = mSelTargets.erase(holder);
logger.warn() << "non-node target was in selected targets";
}
}
}
}
// check if distance candidates are back in range or have have timed out
{
TargetTimeList_t::iterator cand = mDistCands.begin();
while(cand != mDistCands.end())
{
const ::gua::math::mat4 candTransform(cand->first->getGuaNode()->get_world_transform());
const ::gua::math::vec3 candTranslation(candTransform[12], candTransform[13], candTransform[14]);
if(distance(pos, candTranslation) < dist_radius)
cand = mDistCands.erase(cand);
else if(time - cand->second > lag)
{
MFTargetHolder::ContainerType::iterator holder = av::tools::find(mSelTargets, cand->first);
if(holder != mSelTargets.end())
mSelTargets.erase(holder);
else
logger.warn() << "distance candidate was not in selected targets";
cand = mDistCands.erase(cand);
}
else
++cand;
}
}
// update lists
mProxCands.splice(mProxCands.end(), new_prox_cands);
mDistCands.splice(mDistCands.end(), new_dist_cands);
mSelTargets.insert(mSelTargets.end(), new_sel_targets.begin(), new_sel_targets.end());
// check if we have too many targets
if(max_targets != 0u)
{
while(mSelTargets.size() > max_targets && !mDistCands.empty())
{
MFTargetHolder::ContainerType::iterator holder = av::tools::find(mSelTargets, mDistCands.front().first);
if(holder != mSelTargets.end())
mSelTargets.erase(holder);
else
logger.warn() << "distance candidate was not in selected targets";
mDistCands.pop_front();
}
if(mSelTargets.size() > max_targets)
{
mSelTargets.erase(mSelTargets.begin(), mSelTargets.begin() + (mSelTargets.size() - max_targets));
}
}
// update output field
if(SelectedTargets.getValue() != mSelTargets)
SelectedTargets.setValue(mSelTargets);
}
bool GraphNodeLink::isConnected()
{
return (hasSource() && hasTarget());
}
float Unit::distToTarget(){
if(!hasTarget()) return -1;
return (getTarget()->getPosition() - getPosition()).GetLength();
}
