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; }