void ViewIndex::mergeFromMemory(const ViewIndex& memory) {
if (isEmpty())
*this = memory;
else if (!hasObject(ViewLayer::FLOOR) && !hasObject(ViewLayer::FLOOR_BACKGROUND) && !isEmpty()) {
// special case when monster or item is visible but floor is only in memory
if (memory.hasObject(ViewLayer::FLOOR))
insert(memory.getObject(ViewLayer::FLOOR));
if (memory.hasObject(ViewLayer::FLOOR_BACKGROUND))
insert(memory.getObject(ViewLayer::FLOOR_BACKGROUND));
}
}
void ArrayIter::nextHelper() {
if (hasVector()) {
m_pos++;
return;
}
if (hasMap()) {
assert(m_pos != 0);
c_Map* mp = getMap();
if (UNLIKELY(m_versionNumber != mp->getVersionNumber())) {
throw_collection_modified();
}
m_pos = mp->iter_next(m_pos);
return;
}
if (hasStableMap()) {
assert(m_pos != 0);
c_StableMap* smp = getStableMap();
if (UNLIKELY(m_versionNumber != smp->getVersionNumber())) {
throw_collection_modified();
}
m_pos = smp->iter_next(m_pos);
return;
}
assert(hasObject());
ObjectData* obj = getObject();
obj->o_invoke(s_next, Array());
}
HOT_FUNC
Variant ArrayIter::second() {
if (hasVector()) {
c_Vector* vec = getVector();
if (UNLIKELY(m_versionNumber != vec->getVersionNumber())) {
throw_collection_modified();
}
return tvAsCVarRef(vec->at(m_pos));
}
if (hasMap()) {
c_Map* mp = getMap();
if (UNLIKELY(m_versionNumber != mp->getVersionNumber())) {
throw_collection_modified();
}
return mp->iter_value(m_pos);
}
if (hasStableMap()) {
c_StableMap* smp = getStableMap();
if (UNLIKELY(m_versionNumber != smp->getVersionNumber())) {
throw_collection_modified();
}
return smp->iter_value(m_pos);
}
if (hasObject()) {
ObjectData* obj = getObject();
return obj->o_invoke(s_current, Array());
}
assert(hasArrayData());
assert(m_pos != ArrayData::invalid_index);
const ArrayData* ad = getArrayData();
assert(ad);
return ad->getValue(m_pos);
}
void ArrayIter::secondHelper(Variant & v) {
if (hasVector()) {
c_Vector* vec = getVector();
if (UNLIKELY(m_versionNumber != vec->getVersionNumber())) {
throw_collection_modified();
}
v = tvAsCVarRef(vec->at(m_pos));
return;
}
if (hasMap()) {
c_Map* mp = getMap();
if (UNLIKELY(m_versionNumber != mp->getVersionNumber())) {
throw_collection_modified();
}
v = mp->iter_value(m_pos);
return;
}
if (hasStableMap()) {
c_StableMap* smp = getStableMap();
if (UNLIKELY(m_versionNumber != smp->getVersionNumber())) {
throw_collection_modified();
}
v = smp->iter_value(m_pos);
return;
}
assert(hasObject());
ObjectData* obj = getObject();
v = obj->o_invoke(s_current, Array());
}
// ##### print() #####################################################
void Faces::print() {
first();
while (hasObject()) {
cout << "\t\t";
getObject()->print();
next();
}
}
void FeatureFS::data(const std::string &name_or_id) {
if (name_or_id.empty())
throw EmptyString("data(id)");
if (!block->hasEntity({name_or_id, ObjectType::DataArray}))
throw std::runtime_error("FeatureFS::data: DataArray not found in block!");
if (hasObject("data"))
removeObjectByNameOrAttribute("name", "data");
auto target = std::dynamic_pointer_cast<DataArrayFS>(block->getEntity({name_or_id, ObjectType::DataArray}));
bfs::path p(location()), m("data");
target->createLink(p / m);
forceUpdatedAt();
}
float CombatSubsystem::GetDataForMyWeapon(const str& property)
{
auto gpm = GameplayManager::getTheGameplayManager();
if (!gpm->hasObject(act->getArchetype()))
return 0.0;
auto objname = act->combatSubsystem->GetActiveWeaponArchetype();
objname = "Hold" + objname;
if (gpm->hasProperty(objname, property))
return gpm->getFloatValue(objname, property);
return 0.0;
}
bool EntitySet::addObject(PositionableEntity * p)
{
//if it is added, it is not posible to add it again
if(hasObject(p))return false;
//if belongs to another entityset it has to be removed from it before
if(p->owner)return false;
//addition
objects.push_back(p);
p->setOwner(this);
//if this entity set is linkable: not world, and p is not linked it is linked
linkToBase(p);
return true;
}
bool ArrayIter::endHelper() {
if (hasVector()) {
c_Vector* vec = getVector();
return m_pos >= vec->t_count();
}
if (hasMap()) {
return m_pos == 0;
}
if (hasStableMap()) {
return m_pos == 0;
}
assert(hasObject());
ObjectData* obj = getObject();
return !obj->o_invoke(s_valid, Array());
}
// ##### next() ######################################################
void Solids::next() throw (OutOfModelException*) {
if (!hasObject()) {
throw OutOfModelException();
}
current_obj.solidIt->points.next();
if (current_obj.solidIt->points.hasObject()) {
current_obj.rest= current_obj.solidIt->points.getPosition();
} else {
++current_obj.solidIt;
if (exist(current_obj)) {
current_obj.solidIt->points.first();
current_obj.rest= current_obj.solidIt->points.getPosition();
}
}
}
bool BodyBase::isAfter(const App::DocumentObject *feature, const App::DocumentObject* target) const {
assert (feature);
if (feature == target) {
return false;
}
if (!target || target == BaseFeature.getValue() ) {
return hasObject (feature);
}
const std::vector<App::DocumentObject *> & features = Group.getValues();
auto featureIt = std::find(features.begin(), features.end(), feature);
auto targetIt = std::find(features.begin(), features.end(), target);
if (featureIt == features.end()) {
return false;
} else {
return featureIt > targetIt;
}
}
//=============================================================================
//use for cells - players must enter them of course - it might be prudent to separate
//players from items though
bool Object::addObjectSecure(Object* data)
{
if(hasObject(data->getId()))
{
assert(false);
return false;
}
mData.push_back(data->getId());
if(mCapacity)
{
return true;
}
else
{
DLOG(info) << "Object*::addObjectSecure No Capacity!!!!";
return true;
}
}
Variant ArrayIter::firstHelper() {
if (hasVector()) {
return m_pos;
}
if (hasMap()) {
assert(m_pos != 0);
c_Map* mp = getMap();
if (UNLIKELY(m_versionNumber != mp->getVersionNumber())) {
throw_collection_modified();
}
return mp->iter_key(m_pos);
}
if (hasStableMap()) {
assert(m_pos != 0);
c_StableMap* smp = getStableMap();
if (UNLIKELY(m_versionNumber != smp->getVersionNumber())) {
throw_collection_modified();
}
return smp->iter_key(m_pos);
}
assert(hasObject());
ObjectData* obj = getObject();
return obj->o_invoke(s_key, Array());
}
Object& ObjectManager::createObject( const String& rName, NetworkingType type /*= LOCAL*/,
const String& rDisplayName /*= ""*/, RakNet::RakNetGUID source /*= RakNet::RakNetGUID( 0 )*/ )
{
if( !hasObject( rName ) )
{
// Default to own GUID as source.
if( source == RakNet::RakNetGUID( 0 ) ) source = mOwnGUID;
// Set to local if in offline mode.
if( mOfflineMode ) type = LOCAL;
Object& object = createObjectImpl( rName, type, rDisplayName.empty()? rName : rDisplayName,
source );
mObjects.insert( std::make_pair( rName, &object ) );
object.create();
mObjectSignal( object, true );
return object;
}
else
{
DIVERSIA_EXCEPT( Exception::ERR_DUPLICATE_ITEM, "Object already exists.",
"ObjectManager::createObject" );
}
}
void Case::affiche(sf::RenderWindow& app)
{
app.draw(getTerrain());
if (true)
{
sf::Sprite corner(*m_texture);
sf::IntRect r(Case::WIDTH, Case::HEIGHT, Case::WIDTH/2, Case::HEIGHT/2);
corner.setTextureRect(r);
Case* ctop = m_map.getCaseAt(m_intpos.x, m_intpos.y-1);
Case* cbottom = m_map.getCaseAt(m_intpos.x, m_intpos.y+1);
Case* cleft = m_map.getCaseAt(m_intpos.x-1, m_intpos.y);
Case* cright = m_map.getCaseAt(m_intpos.x+1, m_intpos.y);
Case* ctopleft = m_map.getCaseAt(m_intpos.x-1, m_intpos.y-1);
Case* ctopright = m_map.getCaseAt(m_intpos.x+1, m_intpos.y-1);
Case* cbottomleft = m_map.getCaseAt(m_intpos.x-1, m_intpos.y+1);
Case* cbottomright = m_map.getCaseAt(m_intpos.x+1, m_intpos.y+1);
std::string top = ctop? ctop->getTerrainName() : "";
std::string bottom = cbottom? cbottom->getTerrainName() : "";
std::string left = cleft? cleft->getTerrainName() : "";
std::string right = cright? cright->getTerrainName() : "";
if (top != "" && top != m_terrainName && top == left && (!ctopleft || ctopleft->getTerrainName() != m_terrainName))
{
r.left = ctop->getTerrain().getTextureRect().left;
r.top = ctop->getTerrain().getTextureRect().top + Case::HEIGHT;
corner.setPosition(m_pos.x + Case::WIDTH/4, m_pos.y);
corner.setTextureRect(r);
app.draw(corner);
}
if (top != "" && top != m_terrainName && top == right && (!ctopright || ctopright->getTerrainName() != m_terrainName))
{
r.left = ctop->getTerrain().getTextureRect().left + Case::WIDTH/2;
r.top = ctop->getTerrain().getTextureRect().top + Case::HEIGHT;
corner.setPosition(m_pos.x + Case::WIDTH/2, m_pos.y + Case::HEIGHT/4);
corner.setTextureRect(r);
app.draw(corner);
}
if (bottom != "" && bottom != m_terrainName && bottom == left && (!cbottomleft || cbottomleft->getTerrainName() != m_terrainName))
{
r.left = cbottom->getTerrain().getTextureRect().left;
r.top = cbottom->getTerrain().getTextureRect().top + Case::HEIGHT + Case::HEIGHT/2;
corner.setPosition(m_pos.x, m_pos.y + Case::HEIGHT/4);
corner.setTextureRect(r);
app.draw(corner);
}
if (bottom != "" && bottom != m_terrainName && bottom == right && (!cbottomright || cbottomright->getTerrainName() != m_terrainName))
{
r.left = cbottom->getTerrain().getTextureRect().left + Case::WIDTH/2;
r.top = cbottom->getTerrain().getTextureRect().top + Case::HEIGHT + Case::HEIGHT/2;
corner.setPosition(m_pos.x + Case::WIDTH/4, m_pos.y + Case::HEIGHT/2);
corner.setTextureRect(r);
app.draw(corner);
}
}
if(hasObject())
{
if (!m_autoTile && !m_triggerable)
{
app.draw(getObjet());
}
else if (m_triggerable)
{
sf::IntRect r = m_objet.getTextureRect();
sf::IntRect s = m_objet.getTextureRect();
r.top += (m_triggered)? 0 : Case::HEIGHT;
m_objet.setTextureRect(r);
app.draw(m_objet);
m_objet.setTextureRect(s);
}
else if (m_autoTile)
{
sf::Sprite plop(*m_texture);
sf::IntRect r = m_objet.getTextureRect();
r.left += Case::WIDTH/2;
r.top += Case::HEIGHT/2;
r.width = Case::WIDTH/2;
r.height = Case::HEIGHT/2;
sf::Vector2i& pos = m_pos;
bool test = true;
bool top = test && !m_map.getCaseAt(m_intpos.x, m_intpos.y-1)->hasObject(m_objName);
bool bottom = test && !m_map.getCaseAt(m_intpos.x, m_intpos.y+1)->hasObject(m_objName);
bool left = test && !m_map.getCaseAt(m_intpos.x-1, m_intpos.y)->hasObject(m_objName);
bool right = test && !m_map.getCaseAt(m_intpos.x+1, m_intpos.y)->hasObject(m_objName);
plop.setTextureRect(sf::IntRect(r.left - (left? Case::WIDTH/2 : 0), r.top - (top? Case::HEIGHT/2 : 0), r.width, r.height));
plop.setPosition(pos.x + 12, pos.y);
app.draw(plop);
plop.setTextureRect(sf::IntRect(r.left + (right? Case::WIDTH/2 : 0), r.top + (bottom? Case::HEIGHT/2 : 0), r.width, r.height));
plop.setPosition(pos.x + 12, pos.y + 16);
app.draw(plop);
plop.setTextureRect(sf::IntRect(r.left - (left? Case::WIDTH/2 : 0), r.top + (bottom? Case::HEIGHT/2 : 0), r.width, r.height));
plop.setPosition(pos.x, pos.y + 8);
app.draw(plop);
plop.setTextureRect(sf::IntRect(r.left + (right? Case::WIDTH/2 : 0), r.top - (top? Case::HEIGHT/2 : 0), r.width, r.height));
plop.setPosition(pos.x+24, pos.y + 8);
app.draw(plop);
}
}
}
Boolean ObjectContext::ownObject(const ID& id){
return hasObject(id) || (storage && storage->ownObject(id));
}
// ##### getObject() #################################################
Element Solids::getObject() throw (OutOfModelException*) {
if (!hasObject()) {
throw new OutOfModelException();
}
return *current_obj.rest.rest.faceIt;
}
// ##### getObjColor() ###############################################
Color Solids::getObjColor() throw (OutOfModelException*) {
if (!hasObject()) {
throw new OutOfModelException();
}
return current_obj.solidIt->color;
}
/* 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);
}
const ViewObject* ViewIndex::getTopObject(const vector<ViewLayer>& layers) const {
for (int i = layers.size() - 1; i >= 0; --i)
if (hasObject(layers[i]))
return &getObject(layers[i]);
return nullptr;
}
bool Object::checkForObject(Object* object) {
return hasObject(object->getId());
}
bool DataManager::hasObject(std::string const & path) const {
return hasObject(hash_string(path.c_str()));
}
void View::addObject(DrawingObject* obj)
{
if (!hasObject(obj))
objects.push_back(obj);
//debug_print("Object '%s' added to viewport\n", obj->name().c_str());
}
const av::tools::MFTargetHolder::ContainerType&
av::tools::PickSelector::pick()
{
mSelectedTargets.clear();
if (RootNode.getValue().isValid())
{
// initialize line segment
const ::osg::Vec3 start_pos = PickRayTransform.getValue().getTrans();
const ::osg::Vec3 end_pos =
(PickRayDirection.getValue() * PickRayLength.getValue()) * PickRayTransform.getValue();
const ::osg::Vec3 pick_dir = end_pos - start_pos;
mIntersector->setStart(start_pos);
mIntersector->setEnd(end_pos);
// compute intersections. check type of root node because apply is type dependent.
::osg::Node *root = RootNode.getValue()->getOsgNode();
::osg::Transform *root_transform = dynamic_cast< ::osg::Transform*>(root);
if (root_transform != 0)
mVisitor->apply(*root_transform);
else
mVisitor->apply(*root);
if(mIntersector->containsIntersections())
{
MFContainer::ContainerType targets;
const bool create_node_paths = CreateNodePaths.getValue();
const bool create_intersections = CreateIntersections.getValue();
const ::osgUtil::LineSegmentIntersector::Intersections &intersections =
mIntersector->getIntersections();
const unsigned int node_mask = NodePickMask.getValue();
const unsigned int subtree_mask = SubtreePickMask.getValue();
const bool pick_no_mask = PickNodesWithoutPickMask.getValue();
for (::osgUtil::LineSegmentIntersector::Intersections::const_iterator intersection =
intersections.begin(); intersection != intersections.end(); ++intersection)
{
av::Link<av::FieldContainer> target;
std::list<av::Link<av::osg::Node> > node_path_list;
// iterate over the node path from the intersected node to the root node,
// check the pick masks and find the first Avango node.
for (::osg::NodePath::const_reverse_iterator node = intersection->nodePath.rbegin();
node != intersection->nodePath.rend(); ++node)
{
av::Link<av::osg::Node> av_node = av::osg::get_from_osg_object<av::osg::Node>(*node);
if (av_node.isValid())
{
SFBool *ignore = dynamic_cast<SFBool*>(av_node->getField("PickIgnore"));
if (ignore == 0 || !ignore->getValue())
{
SFUInt *mask = dynamic_cast<SFUInt*>(av_node->getField("PickMask"));
if (!target.isValid())
{
if ((mask == 0 && pick_no_mask) ||
(mask != 0 && (node_mask & mask->getValue()) != 0u))
{
target = av_node;
node_path_list.push_back(av_node);
}
else
break;
}
else
{
if ((mask == 0 && pick_no_mask) ||
(mask != 0 && (subtree_mask & mask->getValue()) != 0u))
{
node_path_list.push_front(av_node);
}
else
{
target.clear();
break;
}
}
}
else
break;
}
}
// check if we want to pick front or back face
if (target.isValid())
{
if (intersection->getWorldIntersectNormal() * pick_dir < 0.0)
{
SFBool *pick_front = dynamic_cast<SFBool*>(target->getField("PickFrontFace"));
if (pick_front != 0 && !pick_front->getValue())
target.clear();
}
else
{
SFBool *pick_back = dynamic_cast<SFBool*>(target->getField("PickBackFace"));
if (pick_back != 0 && !pick_back->getValue())
target.clear();
}
}
// add node to output list, if we don't have it already
if (target.isValid() && !hasObject(targets, target))
{
targets.push_back(target);
Link<TargetHolder> holder;
if (create_node_paths || create_intersections)
{
std::vector<av::Link<av::osg::Node> > node_path;
node_path.reserve(node_path_list.size());
node_path.insert(node_path.begin(), node_path_list.begin(), node_path_list.end());
Link<NodePathTargetHolder> path_holder;
if (create_intersections)
{
// create IntersectionTargetHolder
Link<av::osg::Intersection> av_intersection = new av::osg::Intersection;
av_intersection->NodePath.setValue(node_path);
av_intersection->Point.setValue(intersection->getWorldIntersectPoint());
av_intersection->Normal.setValue(intersection->getWorldIntersectNormal());
av_intersection->IndexList.setValue(intersection->indexList);
av_intersection->RatioList.setValue(intersection->ratioList);
Link<IntersectionTargetHolder> intersection_holder = new IntersectionTargetHolder;
intersection_holder->Intersection.setValue(av_intersection);
path_holder = intersection_holder;
}
else
path_holder = new NodePathTargetHolder;
path_holder->NodePath.setValue(node_path);
holder = path_holder;
}
else
holder = new TargetHolder;
holder->Target.setValue(target);
if (SetCreator.getValue())
holder->Creator.setValue(this);
mSelectedTargets.push_back(holder);
}
// stop if we only consider the first hit
if (!mSelectedTargets.empty() && FirstHitOnly.getValue())
break;
}
}
mIntersector->reset();
}
return mSelectedTargets;
}
// ##### next() ######################################################
void Faces::next() throw (OutOfModelException*) {
if (!hasObject()) {
throw new OutOfModelException();
}
++current_object.faceIt;
}
