自学教程：C++ GlobalSelectionSystem函数代码示例

void resizeBrushesToBounds(const AABB& aabb, const std::string& shader){	if (GlobalSelectionSystem().getSelectionInfo().brushCount == 0)	{		gtkutil::MessageBox::ShowError(_("No brushes selected."), GlobalMainFrame().getTopLevelWindow());		return;	}	GlobalSelectionSystem().foreachBrush([&] (Brush& brush)	{ 		brush.constructCuboid(aabb, shader, TextureProjection());	});	SceneChangeNotify();}

void cloneSelected(const cmd::ArgumentList& args){	// Check for the correct editing mode (don't clone components)	if (GlobalSelectionSystem().Mode() == SelectionSystem::eComponent) {		return;	}	UndoableCommand undo("cloneSelected");	// Create the list that will take the cloned instances	SelectionCloner::Map cloned;	SelectionCloner cloner;	GlobalSceneGraph().root()->traverse(cloner);	// Create a new namespace and move all cloned nodes into it	INamespacePtr clonedNamespace = GlobalNamespaceFactory().createNamespace();	assert(clonedNamespace != NULL);	// Move items into the temporary namespace, this will setup the links	clonedNamespace->connect(cloner.getCloneRoot());	// Get the namespace of the current map	scene::IMapRootNodePtr mapRoot = GlobalMapModule().getRoot();	if (mapRoot == NULL) return; // not map root (this can happen)	INamespacePtr nspace = mapRoot->getNamespace();	if (nspace)    {		// Prepare the nodes for import		nspace->ensureNoConflicts(cloner.getCloneRoot());		// Now move all nodes into the target namespace		nspace->connect(cloner.getCloneRoot());	}	// Unselect the current selection	GlobalSelectionSystem().setSelectedAll(false);	// Finally, move the cloned nodes to their destination and select them	cloner.moveClonedNodes(true);	if (registry::getValue<int>(RKEY_OFFSET_CLONED_OBJECTS) == 1)	{		// Move the current selection by one grid unit to the "right" and "downwards"		nudgeSelected(eNudgeDown);		nudgeSelected(eNudgeRight);	}}

void mergeSelectedBrushes(const cmd::ArgumentList& args){	// Get the current selection	BrushPtrVector brushes = selection::algorithm::getSelectedBrushes();	if (brushes.empty()) {		rMessage() << _("CSG Merge: No brushes selected.") << std::endl;		wxutil::Messagebox::ShowError(_("CSG Merge: No brushes selected."));		return;	}	if (brushes.size() < 2) {		rMessage() << "CSG Merge: At least two brushes have to be selected./n";		wxutil::Messagebox::ShowError("CSG Merge: At least two brushes have to be selected.");		return;	}	rMessage() << "CSG Merge: Merging " << brushes.size() << " brushes." << std::endl;	UndoableCommand undo("mergeSelectedBrushes");	// Take the last selected node as reference for layers and parent	scene::INodePtr merged = GlobalSelectionSystem().ultimateSelected();	scene::INodePtr parent = merged->getParent();	assert(parent != NULL);	// Create a new BrushNode	scene::INodePtr node = GlobalBrushCreator().createBrush();	// Insert the newly created brush into the (same) parent entity	parent->addChildNode(node);	// Move the new brush to the same layers as the merged one	node->assignToLayers(merged->getLayers());	// Get the contained brush	Brush* brush = Node_getBrush(node);	// Attempt to merge the selected brushes into the new one	if (!Brush_merge(*brush, brushes, true))	{		rWarning() << "CSG Merge: Failed - result would not be convex." << std::endl;		return;	}	ASSERT_MESSAGE(!brush->empty(), "brush left with no faces after merge");	// Remove the original brushes	for (BrushPtrVector::iterator i = brushes.begin(); i != brushes.end(); ++i)	{		scene::removeNodeFromParent(*i);	}	// Select the new brush	Node_setSelected(node, true);	rMessage() << "CSG Merge: Succeeded." << std::endl;	SceneChangeNotify();}

void SelectionSetToolmenu::onEntryActivated(){	// Create new selection set if possible	std::string name = _entry->get_entry()->get_text();	if (name.empty()) return;	// don't create empty sets	if (GlobalSelectionSystem().countSelected() == 0)	{		ui::IDialogPtr dialog = GlobalDialogManager().createMessageBox(			_("Cannot create selection set"),			_("Cannot create a selection set, there is nothing selected in the current scene."),			ui::IDialog::MESSAGE_CONFIRM);		dialog->run();		return;	}	ISelectionSetPtr set = GlobalSelectionSetManager().createSelectionSet(name);	assert(set != NULL);	set->assignFromCurrentScene();	// Clear the entry again	_entry->get_entry()->set_text("");}

void PatchInspector::emitTesselation(){	UndoableCommand setFixedTessCmd("patchSetFixedTesselation");	wxSpinCtrl* fixedSubdivX = findNamedObject<wxSpinCtrl>(this, "PatchInspectorSubdivisionsX");	wxSpinCtrl* fixedSubdivY = findNamedObject<wxSpinCtrl>(this, "PatchInspectorSubdivisionsY");	Subdivisions tess(		fixedSubdivX->GetValue(),		fixedSubdivY->GetValue()	);	bool fixed = findNamedObject<wxCheckBox>(this, "PatchInspectorFixedSubdivisions")->GetValue();	// Save the setting into the selected patch(es)	GlobalSelectionSystem().foreachPatch([&] (Patch& patch)	{		patch.setFixedSubdivisions(fixed, tess);	});	fixedSubdivX->Enable(fixed);	fixedSubdivY->Enable(fixed);	findNamedObject<wxStaticText>(this, "PatchInspectorSubdivisionsXLabel")->Enable(fixed);	findNamedObject<wxStaticText>(this, "PatchInspectorSubdivisionsYLabel")->Enable(fixed);	GlobalMainFrame().updateAllWindows();}

void ModelCache::refreshSelectedModels(const cmd::ArgumentList& args){	// Disable screen updates for the scope of this function	ui::ScreenUpdateBlocker blocker(_("Processing..."), _("Reloading Models"));	// Find all models in the current selection	ModelFinder walker;	GlobalSelectionSystem().foreachSelected(walker);	// Remove the selected models from the cache	ModelFinder::ModelPaths models = walker.getModelPaths();	for (ModelFinder::ModelPaths::const_iterator i = models.begin();		 i != models.end(); ++i)	{		ModelMap::iterator found = _modelMap.find(*i);		if (found != _modelMap.end())		{			_modelMap.erase(found);		}	}	// Traverse the entities and submit a refresh call	ModelFinder::Entities entities = walker.getEntities();	for (ModelFinder::Entities::const_iterator i = entities.begin();		 i != entities.end(); ++i)	{		(*i)->refreshModel();	}}

void PasteToCamera (void){	CamWnd& camwnd = *g_pParentWnd->GetCamWnd();	GlobalSelectionSystem().setSelectedAll(false);	UndoableCommand undo("pasteToCamera");	Selection_Paste();	// Work out the delta	Vector3 mid = selection::algorithm::getCurrentSelectionCenter();	Vector3 delta = vector3_snapped(camwnd.getCameraOrigin(), GlobalGrid().getGridSize()) - mid;	// Move to camera	GlobalSelectionSystem().translateSelected(delta);}

void Scene_BrushResize_Selected(scene::Graph& graph, const AABB& bounds, const char* shader){  if(GlobalSelectionSystem().countSelected() != 0)  {    const scene::Path& path = GlobalSelectionSystem().ultimateSelected().path();    Brush* brush = Node_getBrush(path.top());    if(brush != 0)    {      TextureProjection projection;      TexDef_Construct_Default(projection);      Brush_ConstructCuboid(*brush, bounds, shader, projection);      SceneChangeNotify();    }  }}

/// moves selected primitives to entity, which is or its primitive is ultimateSelected() or firstSelected()void Entity_moveSelectedPrimitives( bool toLast ){	if ( GlobalSelectionSystem().countSelected() < 2 ) {		globalErrorStream() << "Source and target entity primitives should be selected!/n";		return;	}	const scene::Path& path = toLast? GlobalSelectionSystem().ultimateSelected().path() : GlobalSelectionSystem().firstSelected().path();	scene::Node& node = ( !Node_isEntity( path.top() ) && path.size() > 1 )? path.parent() : path.top();	if ( Node_isEntity( node ) && node_is_group( node ) ) {		StringOutputStream command;		command << "movePrimitivesToEntity " << makeQuoted( Node_getEntity( node )->getEntityClass().name() );		UndoableCommand undo( command.c_str() );		Scene_parentSelectedBrushesToEntity( GlobalSceneGraph(), node );	}}

/** * Callback common to all of the commands that trigger a processing by mesh * visitor when selected. This callback does its own internal dispatch to * distinctly handle the various commands. * * @param commandString The command token. */voidMainMenu::CommandMeshVisitor(const std::string& commandString){   // Look up the registered mesh visitor for this command.   VisitorMap::const_iterator visitorMapIter = _visitorMap.find(commandString);   MeshVisitor *meshVisitor;   if (visitorMapIter == _visitorMap.end() ||       (meshVisitor = visitorMapIter->second) == NULL)   {      // That's odd, there isn't one. Bail out.      std::string message(commandString + ": " + DIALOG_INTERNAL_ERROR);      GenericPluginUI::ErrorReportDialog(DIALOG_ERROR_TITLE, message.c_str());      return;   }   // Let Radiant know the name of the operation responsible for the changes   // that are about to happen.   UndoableCommand undo(commandString.c_str());   // Apply the visitor to every selected mesh.   meshVisitor->ResetVisitedCount();   GlobalSelectionSystem().foreachSelected(*meshVisitor);   if (meshVisitor->GetVisitedCount() == 0)   {      // Warn if there weren't any meshes selected (so nothing happened).       GenericPluginUI::WarningReportDialog(DIALOG_WARNING_TITLE,                                           DIALOG_NOMESHES_MSG);   }}

void LightNode::renderInactiveComponents(RenderableCollector& collector, const VolumeTest& volume, const bool selected) const{	// greebo: We are not in component selection mode (and the light is still selected),	// check if we should draw the center of the light anyway	if (selected		&& GlobalSelectionSystem().ComponentMode() != SelectionSystem::eVertex		&& EntitySettings::InstancePtr()->alwaysShowLightVertices())	{		if (_light.isProjected())		{			EntitySettings& settings = *EntitySettings::InstancePtr();			const Vector3& colourStartEndInactive = settings.getLightVertexColour(EntitySettings::VERTEX_START_END_DESELECTED);			const Vector3& colourVertexInactive = settings.getLightVertexColour(EntitySettings::VERTEX_DESELECTED);			const_cast<Light&>(_light).colourLightStart() = colourStartEndInactive;			const_cast<Light&>(_light).colourLightEnd() = colourStartEndInactive;			const_cast<Light&>(_light).colourLightTarget() = colourVertexInactive;			const_cast<Light&>(_light).colourLightRight() = colourVertexInactive;			const_cast<Light&>(_light).colourLightUp() = colourVertexInactive;			// Render the projection points			_light.renderProjectionPoints(collector, volume, localToWorld());		}		else		{			const Vector3& colourVertexInactive = EntitySettings::InstancePtr()->getLightVertexColour(				EntitySettings::VERTEX_INACTIVE);			const_cast<Light&>(_light).getDoom3Radius().setCenterColour(colourVertexInactive);			_light.renderLightCentre(collector, volume, localToWorld());		}	}}

void NudgeSelection (ENudgeDirection direction, float fAmount, EViewType viewtype){	AxisBase axes(AxisBase_forViewType(viewtype));	Vector3 view_direction(-axes.z);	Vector3 nudge(AxisBase_axisForDirection(axes, direction) * fAmount);	GlobalSelectionSystem().NudgeManipulator(nudge, view_direction);}

void LightNode::evaluateTransform() {	if (getType() == TRANSFORM_PRIMITIVE) {		_light.translate(getTranslation());		_light.rotate(getRotation());	}	else {		// Check if the light center is selected, if yes, transform it, if not, it's a drag plane operation		if (GlobalSelectionSystem().ComponentMode() == SelectionSystem::eVertex) {			if (_lightCenterInstance.isSelected()) {				// Retrieve the translation and apply it to the temporary light center variable				// This adds the translation vector to the previous light origin				_light.getDoom3Radius().m_centerTransformed =										_light.getDoom3Radius().m_center + getTranslation();			}			if (_lightTargetInstance.isSelected()) {				// Delegate the work to the Light class				_light.translateLightTarget(getTranslation());			}			if (_lightRightInstance.isSelected()) {				// Save the new light_right vector				_light.rightTransformed() = _light.right() + getTranslation();			}			if (_lightUpInstance.isSelected()) {				// Save the new light_up vector				_light.upTransformed() = _light.up() + getTranslation();			}			if (_lightStartInstance.isSelected()) {				// Delegate the work to the Light class (including boundary checks)				_light.translateLightStart(getTranslation());			}			if (_lightEndInstance.isSelected()) {				// Save the new light_up vector				_light.endTransformed() = _light.end() + getTranslation();			}			// If this is a projected light, then it is likely for the according vertices to have changed, so update the projection			if (_light.isProjected()) {				// Call projection changed, so that the recalculation can be triggered (call for projection() would be ignored otherwise)				_light.projectionChanged();				// Recalculate the frustum				_light.projection();			}		}		else {			// Ordinary Drag manipulator			//m_dragPlanes.m_bounds = _light.aabb();			// greebo: Be sure to use the actual lightAABB for evaluating the drag operation, NOT			// the aabb() or localABB() method, that returns the bounding box including the light center,			// which may be positioned way out of the volume			m_dragPlanes.m_bounds = _light.lightAABB();			_light.setLightRadius(m_dragPlanes.evaluateResize(getTranslation(), rotation()));		}	}}

// free all map elements, reinitialize the structures that depend on themvoid Map::freeMap() {    map::PointFile::Instance().clear();    GlobalSelectionSystem().setSelectedAll(false);    GlobalSelectionSystem().setSelectedAllComponents(false);    GlobalShaderClipboard().clear();    GlobalRegion().clear();    m_resource->removeObserver(*this);    // Reset the resource pointer    m_resource = IMapResourcePtr();    GlobalLayerSystem().reset();}

void Select_SetShader (const std::string& shader){	if (GlobalSelectionSystem().Mode() != SelectionSystem::eComponent) {		Scene_BrushSetShader_Selected(GlobalSceneGraph(), shader);	}	Scene_BrushSetShader_Component_Selected(GlobalSceneGraph(), shader);}

void BrushInstance::renderComponents (Renderer& renderer, const VolumeTest& volume) const{	m_brush.evaluateBRep();	const Matrix4& localToWorld = Instance::localToWorld();	renderer.SetState(m_brush.m_state_point, Renderer::eWireframeOnly);	renderer.SetState(m_brush.m_state_point, Renderer::eFullMaterials);	if (volume.fill() && GlobalSelectionSystem().ComponentMode() == SelectionSystem::eFace) {		evaluateViewDependent(volume, localToWorld);		renderer.addRenderable(m_render_faces_wireframe, localToWorld);	} else {		m_brush.renderComponents(GlobalSelectionSystem().ComponentMode(), renderer, volume, localToWorld);	}}

AABB getDefaultBoundsFromSelection(){	AABB aabb = GlobalSelectionSystem().getWorkZone().bounds;	float gridSize = GlobalGrid().getGridSize();	if (aabb.extents[0] == 0)	{		aabb.extents[0] = gridSize;	}	if (aabb.extents[1] == 0)	{		aabb.extents[1] = gridSize;	}	if (aabb.extents[2] == 0)	{		aabb.extents[2] = gridSize;	}	if (aabb.isValid())	{		return aabb;	}	return AABB(Vector3(0, 0, 0), Vector3(64, 64, 64));}

GroupCycle::GroupCycle() :	_index(0),	_updateActive(false){	GlobalSelectionSystem().addObserver(this);	rescanSelection();}

static gboolean entitylist_tree_select(GtkTreeSelection *selection, GtkTreeModel *model, GtkTreePath *path, gboolean path_currently_selected, gpointer data){  GtkTreeIter iter;  gtk_tree_model_get_iter(model, &iter, path);  scene::Node* node;  gtk_tree_model_get_pointer(model, &iter, 0, &node);  scene::Instance* instance;  gtk_tree_model_get_pointer(model, &iter, 1, &instance);  Selectable* selectable = Instance_getSelectable(*instance);  if(node == 0)  {    if(path_currently_selected != FALSE)    {      getEntityList().m_selection_disabled = true;      GlobalSelectionSystem().setSelectedAll(false);      getEntityList().m_selection_disabled = false;    }  }  else if(selectable != 0)  {    getEntityList().m_selection_disabled = true;    selectable->setSelected(path_currently_selected == FALSE);    getEntityList().m_selection_disabled = false;    return TRUE;  }  return FALSE;}

void mirrorSelection(int axis){	Vector3 flip(1, 1, 1);	flip[axis] = -1;	GlobalSelectionSystem().scaleSelected(flip);}

void nudgeByAxis(int nDim, float fNudge){	Vector3 translate(0, 0, 0);	translate[nDim] = fNudge;	GlobalSelectionSystem().translateSelected(translate);}

/**  * greebo: Creates a new entity with an attached curve * * @key: The curve type: pass either "curve_CatmullRomSpline" or "curve_Nurbs". */void createCurve(const std::string& key){    UndoableCommand undo(std::string("createCurve: ") + key);    // De-select everything before we proceed    GlobalSelectionSystem().setSelectedAll(false);    GlobalSelectionSystem().setSelectedAllComponents(false);    std::string curveEClass = game::current::getValue<std::string>(GKEY_DEFAULT_CURVE_ENTITY);    // Fallback to func_static, if nothing defined in the registry    if (curveEClass.empty()) {        curveEClass = "func_static";    }    // Find the default curve entity    IEntityClassPtr entityClass = GlobalEntityClassManager().findOrInsert(        curveEClass,        true    );    // Create a new entity node deriving from this entityclass    IEntityNodePtr curve(GlobalEntityCreator().createEntity(entityClass));    // Insert this new node into the scenegraph root    GlobalSceneGraph().root()->addChildNode(curve);    // Select this new curve node    Node_setSelected(curve, true);    // Set the model key to be the same as the name    curve->getEntity().setKeyValue("model",                                   curve->getEntity().getKeyValue("name"));    // Initialise the curve using three pre-defined points    curve->getEntity().setKeyValue(        key,        "3 ( 0 0 0  50 50 0  50 100 0 )"    );    ITransformablePtr transformable = Node_getTransformable(curve);    if (transformable != NULL) {        // Translate the entity to the center of the current workzone        transformable->setTranslation(GlobalXYWnd().getActiveXY()->getOrigin());        transformable->freezeTransform();    }}

void DragManipulator::testSelect(const View& view, const Matrix4& pivot2world) {    SelectionPool selector;    SelectionVolume test(view);    if (GlobalSelectionSystem().Mode() == SelectionSystem::ePrimitive) {        BooleanSelector booleanSelector;        Scene_TestSelect_Primitive(booleanSelector, test, view);        if (booleanSelector.isSelected()) {            selector.addSelectable(SelectionIntersection(0, 0), &_dragSelectable);            _selected = false;        } else {            _selected = Scene_forEachPlaneSelectable_selectPlanes(GlobalSceneGraph(), selector, test);        }    }    // Check for entities that can be selected    else if (GlobalSelectionSystem().Mode() == SelectionSystem::eEntity) {        // Create a boolean selection pool (can have exactly one selectable or none)        BooleanSelector booleanSelector;        // Find the visible entities        Scene_forEachVisible(GlobalSceneGraph(), view, testselect_entity_visible(booleanSelector, test));        // Check, if an entity could be found        if (booleanSelector.isSelected()) {            selector.addSelectable(SelectionIntersection(0, 0), &_dragSelectable);            _selected = false;        }    } else {        BestSelector bestSelector;        Scene_TestSelect_Component_Selected(bestSelector, test, view, GlobalSelectionSystem().ComponentMode());        for (std::list<Selectable*>::iterator i = bestSelector.best().begin(); i != bestSelector.best().end(); ++i) {            if (!(*i)->isSelected()) {                GlobalSelectionSystem().setSelectedAllComponents(false);            }            _selected = false;            selector.addSelectable(SelectionIntersection(0, 0), (*i));            _dragSelectable.setSelected(true);        }    }    for (SelectionPool::iterator i = selector.begin(); i != selector.end(); ++i) {        (*i).second->setSelected(true);    }}

void GroupCycle::rescanSelection() {	if (_updateActive) {		return;	}	const SelectionInfo& info = GlobalSelectionSystem().getSelectionInfo();	_list.clear();	_index = 0;	if (info.totalCount == 1 && info.entityCount == 1) {		const scene::INodePtr& node = GlobalSelectionSystem().ultimateSelected();		algorithm::ChildNodeFinder finder(_list);		node->traverse(finder);	}}

// greebo: see header for documentationvoid rotateSelected(const Vector3& eulerXYZ){	std::string command("rotateSelectedEulerXYZ: ");	command += string::to_string(eulerXYZ);	UndoableCommand undo(command.c_str());	GlobalSelectionSystem().rotateSelected(Quaternion::createForEulerXYZDegrees(eulerXYZ));}