C++ Path::top方法代码示例

void post( const scene::Path& path, scene::Instance& instance ) const {
	Selectable *selectable = Instance_getSelectable( instance );
	if ( selectable && selectable->isSelected() ) {
		Entity* entity = Node_getEntity( path.top() );
		if ( entity == 0 && Node_isPrimitive( path.top() ) ) {
			NodeSmartReference child( path.top().get() );
			NodeSmartReference parent( path.parent().get() );

			if ( path.size() >= 3 && parent != worldspawn ) {
				NodeSmartReference parentparent( path[path.size() - 3].get() );

				Node_getTraversable( parent )->erase( child );
				Node_getTraversable( group )->insert( child );

				if ( Node_getTraversable( parent )->empty() ) {
					//deleteme.push(DeletionPair(parentparent, parent));
					Node_getTraversable( parentparent )->erase( parent );
				}
			}
			else
			{
				Node_getTraversable( parent )->erase( child );
				Node_getTraversable( group )->insert( child );
			}
		}
	}
}

		bool pre (const scene::Path& path, scene::Instance& instance) const
		{
			if (path.top().get().visible()) {
				Snappable* snappable = Node_getSnappable(path.top());
				if (snappable != 0 && Instance_getSelectable(instance)->isSelected()) {
					snappable->snapto(m_snap);
				}
			}
			return true;
		}

 bool pre(const scene::Path& path, scene::Instance& instance) const
 {
   if(path.top().get().visible())
   {
     Brush* brush = Node_getBrush(path.top());
     if(brush != 0 && Brush_hasShader(*brush, m_name))
     {
       Instance_getSelectable(instance)->setSelected(true);
     }
   }
   return true;
 }

void Scene_FindEntityBrush(std::size_t entity, std::size_t brush, scene::Path& path)
{
  path.push(GlobalSceneGraph().root());
  {
	  EntityFindByIndexWalker visitor(entity, path);
	  path.top()->traverse(visitor);
  }

  if(path.size() == 2)
  {
	  BrushFindByIndexWalker visitor(brush, path);
	  path.top()->traverse(visitor);
  }
}

		void Path_parent (const scene::Path& parent, const scene::Path& child) const
		{
			ENodeType contains = node_get_contains(parent.top());
			ENodeType type = node_get_nodetype(child.top());

			if (contains != eNodeUnknown && contains == type) {
				NodeSmartReference node(child.top().get());
				Path_deleteTop(child);
				Node_getTraversable(parent.top())->insert(node);
				SceneChangeNotify();
			} else {
				globalErrorStream() << "failed - " << nodetype_get_name(type) << " cannot be parented to "
						<< nodetype_get_name(contains) << " container.\n";
			}
		}

bool pre( const scene::Path& path, scene::Instance& instance ) const {
	if ( m_entity == 0 ) {
		Entity* entity = Node_getEntity( path.top() );
		if ( entity != 0 && string_equal( m_name, entity->getKeyValue( "classname" ) ) ) {
			m_entity = entity;
		}
	}
	return true;
}

	bool pre(const scene::Path& path, scene::Instance& instance) const {
		if (path.top().get().visible() && Node_isBrush(path.top())) // this node is a floor
		{

			const AABB& aabb = instance.worldAABB();

			float floorHeight = aabb.origin.z() + aabb.extents.z();

			if (floorHeight > m_current && floorHeight < m_bestUp) {
				m_bestUp = floorHeight;
			}

			if (floorHeight < m_current && floorHeight > m_bestDown) {
				m_bestDown = floorHeight;
			}
		}

		return true;
	}

		bool pre (const scene::Path& path, scene::Instance& instance) const
		{
			++m_depth;
			if (m_depth == 2) { /* entity depth */
				/* traverse and select children if any one is selected */
				if (instance.childSelected())
					Instance_setSelected(instance, true);
				return Node_getEntity(path.top())->isContainer() && instance.childSelected();
			} else if (m_depth == 3) { /* primitive depth */
				Instance_setSelected(instance, true);
				return false;
			}
			return true;
		}

bool PlaneSelectableSelectPlanes::pre(const scene::Path& path, scene::Instance& instance) const {
    if(path.top().get().visible())
    {
      Selectable* selectable = Instance_getSelectable(instance);
      if(selectable != 0 && selectable->isSelected())
      {
        PlaneSelectable* planeSelectable = Instance_getPlaneSelectable(instance);
        if(planeSelectable != 0)
        {
          planeSelectable->selectPlanes(_selector, _test, _selectedPlaneCallback);
        }
      }
    }
    return true;
}

bool ClosestTexturableFinder::pre (const scene::Path& path, scene::Instance& instance) const
{
	// Check if the node is filtered
	if (path.top().get().visible()) {
		// Test the instance for a brush
		BrushInstance* brush = Instance_getBrush(instance);

		if (brush != NULL) {
			// Construct the selectiontest
			_selectionTest.BeginMesh(brush->localToWorld());

			// Cycle through all the faces
			for (Brush::const_iterator i = brush->getBrush().begin(); i != brush->getBrush().end(); i++) {
				// Test the face for selection
				SelectionIntersection intersection;
				(*i)->testSelect(_selectionTest, intersection);

				// Any intersection found / is it better than the previous one?
				if (intersection.valid() && SelectionIntersection_closer(intersection, _bestIntersection)) {
					// Yes, store this as new best intersection
					_bestIntersection = intersection;

					// Save the face and the parent brush
					_texturable.face = (*i);
					_texturable.brush = &brush->getBrush();
				}
			}
		} else {
			// No brush, test for a patch
			SelectionTestable* selectionTestable = Instance_getSelectionTestable(instance);

			if (selectionTestable != NULL) {
				bool occluded;
				OccludeSelector selector(_bestIntersection, occluded);
				selectionTestable->testSelect(selector, _selectionTest);

				if (occluded) {
					_texturable = Texturable();
				}
			}
		}
	}

	return true;
}

			// Visit function
			virtual bool pre (const scene::Path& path, scene::Instance& instance) const
			{
				Entity* entity = Node_getEntity(path.top());
				if (entity != NULL) {
					// Get the entity name
					std::string entName = entity->getKeyValue("targetname");

					// if not targetname is set, ignore it
					if (!entName.empty()) {
						// Append the name to the list store
						GtkTreeIter iter;
						gtk_list_store_append(GTK_LIST_STORE(_store), &iter);
						gtk_list_store_set(GTK_LIST_STORE(_store), &iter, 0, entName.c_str(), -1);
					}

					return false; // don't traverse children if entity found
				}

				return true; // traverse children otherwise
			}

void post( const scene::Path& path, scene::Instance& instance ) const {
	Entity* entity = Node_getEntity( path.top() );
	if ( entity != 0 && ( instance.childSelected() || Instance_getSelectable( instance )->isSelected() ) ) {
		if( path.top().get_pointer() == m_world ){ /* do not want to convert whole worldspawn entity */
			if( instance.childSelected() && !m_2world ){ /* create an entity from world brushes instead */
				EntityClass* entityClass = GlobalEntityClassManager().findOrInsert( m_classname, true );
				if( entityClass->fixedsize )
					return;

				//is important to have retexturing here; if doing in the end, undo doesn't succeed; //don't do this extra now, as it requires retexturing, working for subgraph
//				if ( string_compare_nocase_n( m_classname, "trigger_", 8 ) == 0 ){
//					Scene_PatchSetShader_Selected( GlobalSceneGraph(), GetCommonShader( "trigger" ).c_str() );
//					Scene_BrushSetShader_Selected( GlobalSceneGraph(), GetCommonShader( "trigger" ).c_str() );
//				}

				NodeSmartReference node( GlobalEntityCreator().createEntity( entityClass ) );
				Node_getTraversable( GlobalSceneGraph().root() )->insert( node );

				scene::Path entitypath( makeReference( GlobalSceneGraph().root() ) );
				entitypath.push( makeReference( node.get() ) );
				scene::Instance& entityInstance = findInstance( entitypath );

				if ( g_pGameDescription->mGameType == "doom3" ) {
					Node_getEntity( node )->setKeyValue( "model", Node_getEntity( node )->getKeyValue( "name" ) );
				}

				//Scene_parentSelectedBrushesToEntity( GlobalSceneGraph(), node );
				Scene_parentSubgraphSelectedBrushesToEntity( GlobalSceneGraph(), node, path );
				Scene_forEachChildSelectable( SelectableSetSelected( true ), entityInstance.path() );
			}
			return;
		}
		else if( m_2world ){ /* ungroupSelectedEntities */ //condition is skipped with world = 0, so code next to this may create multiple worldspawns; todo handle this very special case?
			if( node_is_group( path.top() ) ){
				parentBrushes( path.top(), *m_world );
				Path_deleteTop( path );
			}
			return;
		}

		EntityClass* eclass = GlobalEntityClassManager().findOrInsert( m_classname, node_is_group( path.top() ) );
		NodeSmartReference node( GlobalEntityCreator().createEntity( eclass ) );

		if( entity->isContainer() && eclass->fixedsize ){ /* group entity to point one */
			char value[64];
			sprintf( value, "%g %g %g", instance.worldAABB().origin[0], instance.worldAABB().origin[1], instance.worldAABB().origin[2] );
			entity->setKeyValue( "origin", value );
		}

		EntityCopyingVisitor visitor( *Node_getEntity( node ) );
//		entity->forEachKeyValue( visitor );

		NodeSmartReference child( path.top().get() );
		NodeSmartReference parent( path.parent().get() );
//		Node_getTraversable( parent )->erase( child );
		if ( Node_getTraversable( child ) != 0 && node_is_group( node ) ) { /* group entity to group one */
			parentBrushes( child, node );
		}
		Node_getTraversable( parent )->insert( node );

		entity->forEachKeyValue( visitor ); /* must do this after inserting node, otherwise problem: targeted + having model + not loaded b4 new entities aren't selectable normally + rendered only while 0 0 0 is rendered */

		if( !entity->isContainer() && !eclass->fixedsize ){ /* point entity to group one */
			AABB bounds( g_vector3_identity, Vector3( 16, 16, 16 ) );
			if ( !string_parse_vector3( entity->getKeyValue( "origin" ), bounds.origin ) ) {
				bounds.origin = g_vector3_identity;
			}
			Brush_ConstructPlacehoderCuboid( node.get(), bounds );
			Node_getEntity( node )->setKeyValue( "origin", "" );
		}

		Node_getTraversable( parent )->erase( child );
	}
}

EntityGroupSelected( const scene::Path &p ) : group( p.top().get() ), worldspawn( Map_FindOrInsertWorldspawn( g_map ) ){
}