ldforge: comparison src/editmodes/magicWandMode.cpp

-:7986584e7498
+:9ecc878c7dea
 	// Get vertex<->object data
 	for (LDObject* obj : currentDocument()->objects())
 	{
 		// Note: this deliberately only takes vertex-objects into account.
 		// The magic wand does not process subparts.
-		for (int i = 0; i < obj->numVertices(); ++i)
+		if (obj->hasVertices())
-			m_vertices[obj->vertex (i)] << obj;
+		{
+			LDVertexObject* vo = static_cast<LDVertexObject*> (obj);
+			for (int i = 0; i < vo->numVertices(); ++i)
+				m_vertices[vo->vertex (i)] << vo;
+		}
 	}
 }
 EditModeType MagicWandMode::type() const
 {
 	return EditModeType::MagicWand;
 }
-void MagicWandMode::fillBoundaries (LDObject* obj, QVector<BoundaryType>& boundaries, QVector<LDObject*>& candidates)
+void MagicWandMode::fillBoundaries (LDVertexObject* obj, Boundaries& boundaries, Candidates& candidates)
 {
 	// All boundaries obviously share vertices with the object, therefore they're all in the list
 	// of candidates.
-	for (LDObject* candidate : candidates)
+	for (LDVertexObject* candidate : candidates)
 	{
 		if (not isOneOf (candidate->type(), OBJ_Line, OBJ_CondLine) or candidate->vertex (0) == candidate->vertex (1))
 			continue;
 		int matches = 0;
 				// conditional line, select it.
 				if (candidate->type() == OBJ_CondLine)
 					m_selection << candidate;
 				else
 					boundaries.append (std::make_tuple (candidate->vertex (0), candidate->vertex (1)));
 				break;
 			}
 		}
 	}
 }
-void MagicWandMode::doMagic (LDObject* obj, MagicWandMode::MagicType type)
+void MagicWandMode::doMagic (LDObject* input, MagicType type)
 {
-	if (obj == nullptr)
+	if (input == nullptr or not input->hasVertices())
 	{
 		if (type == Set)
 		{
 			currentDocument()->clearSelection();
 			m_window->buildObjectList();
 		}
 		return;
 	}
-	int matchesneeded = 0;
+	LDVertexObject* obj = static_cast<LDVertexObject*> (input);
-	QVector<BoundaryType> boundaries;
+	int matchesneeded = (obj->numVertices() == 2) ? 1 : 2;
+	Boundaries boundaries;
 	LDObjectType objtype = obj->type();
 	if (type != InternalRecursion)
 	{
 		m_selection.clear();
 		m_selection.append (obj);
 	}
-	switch (obj->type())
+	Candidates candidates;
-	{
-		case OBJ_Line:
-		case OBJ_CondLine:
-			matchesneeded = 1;
-			break;
-		case OBJ_Triangle:
-		case OBJ_Quad:
-			matchesneeded = 2;
-			break;
-		default:
-			return;
-	}
-	QVector<LDObject*> candidates;
 	// Get the list of objects that touch this object, i.e. share a vertex
 	// with this.
 	for (int i = 0; i < obj->numVertices(); ++i)
 		candidates += m_vertices[obj->vertex (i)];
 	// If we're dealing with surfaces, get a list of boundaries.
 	if (matchesneeded > 1)
 		fillBoundaries (obj, boundaries, candidates);
-	for (LDObject* candidate : candidates)
+	for (LDVertexObject* candidate : candidates)
 	{
-		try
+		// If we're doing this on lines, we need exact type match. Surface types (quads and
-		{
+		// triangles) can be mixed. Also don't consider self a candidate, and don't consider
-			// If we're doing this on lines, we need exact type match. Surface types (quads and
+		// objects we have already processed.
-			// triangles) can be mixed. Also don't consider self a candidate, and don't consider
+		if ((candidate == obj) or
-			// objects we have already processed.
+			(candidate->color() != obj->color()) or
-			if ((candidate == obj) or
+			(m_selection.contains (candidate)) or
-				(candidate->color() != obj->color()) or
+			(matchesneeded == 1 and (candidate->type() != objtype)) or
-				(m_selection.contains (candidate)) or
+			((candidate->numVertices() > 2) ^ (matchesneeded == 2)))
-				(matchesneeded == 1 and (candidate->type() != objtype)) or
-				((candidate->numVertices() > 2) ^ (matchesneeded == 2)))
-			{
-				throw 0;
-			}
-			// Now ensure the two objects share enough vertices.
-			QVector<Vertex> matches;
-			for (int i = 0; i < obj->numVertices(); ++i)
-			{
-				for (int j = 0; j < candidate->numVertices(); ++j)
-				{
-					if (obj->vertex(i) == candidate->vertex(j))
-					{
-						matches << obj->vertex(i);
-						break;
-					}
-				}
-			}
-			if (matches.size() < matchesneeded)
-				throw 0; // Not enough matches.
-			// Check if a boundary gets in between the objects.
-			for (auto boundary : boundaries)
-			{
-				if (isOneOf (matches[0], std::get<0> (boundary), std::get<1> (boundary)) and
-					isOneOf (matches[1], std::get<0> (boundary), std::get<1> (boundary)))
-				{
-					throw 0;
-				}
-			}
-			m_selection.append (candidate);
-			doMagic (candidate, InternalRecursion);
-		}
-		catch (int&)
 		{
 			continue;
 		}
+		// Now ensure the two objects share enough vertices.
+		QSet<Vertex> matches = obj->vertexSet();
+		matches.intersect (candidate->vertexSet());
+		if (matches.size() < matchesneeded)
+			goto skipthis; // Not enough matches.
+		// Check if a boundary gets in between the objects.
+		for (const Boundary& boundary : boundaries)
+		{
+			if (matches.contains (std::get<0>(boundary)) and matches.contains (std::get<1>(boundary)))
+				goto skipthis;
+		}
+		m_selection.append (candidate);
+		doMagic (candidate, InternalRecursion);
+skipthis:
+		continue;
 	}
 	switch (type)
 	{
 	case Set:
 		if (data.keymods & Qt::ShiftModifier)
 			wandtype = MagicWandMode::Additive;
 		else if (data.keymods & Qt::ControlModifier)
 			wandtype = MagicWandMode::Subtractive;
-		doMagic (renderer()->pickOneObject (data.ev->x(), data.ev->y()), wandtype);
+		LDObject* obj = renderer()->pickOneObject (data.ev->x(), data.ev->y());
+		doMagic (obj, wandtype);
 		return true;
 	}
 	return false;
 }

Mercurial > ldforge / file comparison

comparison: src/editmodes/magicWandMode.cpp

src/editmodes/magicWandMode.cpp