speed up connected faces selection

from several minutes to 0.5s when accidentally selecting 32k faces at once. Minimum time to select increased a bit since an octree of the entire level is created for each selection.

Author: wootguy

src/bsp/Bsp.cpp

@@ -21,6 +21,8 @@
 #include "Fgd.h"
 #include "Texture.h"
 #include "LeafNavMeshGenerator.h"
+#include "NavMeshGenerator.h"
+#include "PolyOctree.h"
 
 typedef map< string, vec3 > mapStringToVector;
 
@@ -4291,53 +4293,102 @@ bool Bsp::rename_texture(const char* oldName, const char* newName) {
 	return false;
 }
 
-unordered_set<int> Bsp::selectConnected(int modelId, int faceId, unordered_set<int>& ignoreFaces, bool planarTextureOnly) {
+unordered_set<int> Bsp::selectConnected(vector<int>& srcFaces, unordered_set<int>& ignoreFaces, bool planarTextureOnly) {
 	unordered_set<int> selected;
-	const float epsilon = 1.0f;
+	vector<Polygon3D*> selectedFaces;
+	queue<Polygon3D*> testPolys;
+	unordered_set<int> validMiptex;
+	vector<vec3> validNormals;
+	vector<Polygon3D*> polys;
+	vector<int> polyModels; // maps a polygon index to a model index
+
+	for (int idx : srcFaces) {
+		BSPFACE& face = faces[idx];
+		BSPTEXTUREINFO& info = texinfos[face.iTextureInfo];
+		BSPPLANE& plane = planes[face.iPlane];
 
-	BSPMODEL& model = models[modelId];
+		vector<vec3> selectedVerts;
+		for (int e = 0; e < face.nEdges; e++) {
+			int32_t edgeIdx = surfedges[face.iFirstEdge + e];
+			BSPEDGE& edge = edges[abs(edgeIdx)];
+			int vertIdx = edgeIdx >= 0 ? edge.iVertex[1] : edge.iVertex[0];
+			selectedVerts.push_back(verts[vertIdx]);
+		}
 
-	BSPFACE& face = faces[faceId];
-	BSPTEXTUREINFO& info = texinfos[face.iTextureInfo];
-	BSPPLANE& plane = planes[face.iPlane];
+		Polygon3D* poly = new Polygon3D(selectedVerts, idx, true);
+		selectedFaces.push_back(poly);
+		testPolys.push(poly);
+		validMiptex.insert(info.iMiptex);
+		push_unique_vec3(validNormals, plane.vNormal, 0.0001f);
+	}
 
-	vector<vec3> selectedVerts;
-	for (int e = 0; e < face.nEdges; e++) {
-		int32_t edgeIdx = surfedges[face.iFirstEdge + e];
-		BSPEDGE& edge = edges[abs(edgeIdx)];
-		int vertIdx = edgeIdx >= 0 ? edge.iVertex[1] : edge.iVertex[0];
-		selectedVerts.push_back(verts[vertIdx]);
+	for (int fa = 0; fa < faceCount; fa++) {
+		polyModels.push_back(get_model_from_face(fa));
+
+		BSPFACE& face = faces[fa];
+
+		vector<vec3> faceVerts;
+
+		for (int e = 0; e < face.nEdges; e++) {
+			int32_t edgeIdx = surfedges[face.iFirstEdge + e];
+			BSPEDGE& edge = edges[abs(edgeIdx)];
+			int vertIdx = edgeIdx >= 0 ? edge.iVertex[1] : edge.iVertex[0];
+			faceVerts.push_back(verts[vertIdx]);
+		}
+
+		Polygon3D* poly = new Polygon3D(faceVerts, polys.size(), true);
+
+		polys.push_back(poly);
 	}
 
-	bool anyNewFaces = true;
-	while (anyNewFaces) {
-		anyNewFaces = false;
+	PolygonOctree* octree = NavMeshGenerator::createPolyOctree(this, polys, 6);
 
-		for (int fa = 0; fa < model.nFaces; fa++) {
-			int testFaceIdx = model.iFirstFace + fa;
-			BSPFACE& faceA = faces[testFaceIdx];
-			BSPTEXTUREINFO& infoA = texinfos[faceA.iTextureInfo];
-			BSPPLANE& planeA = planes[faceA.iPlane];
+	while (testPolys.size()) {
+		Polygon3D* poly = testPolys.front();
+		testPolys.pop();
 
-			if (selected.count(testFaceIdx) || ignoreFaces.count(fa)) {
+		int srcModel = polyModels[poly->idx];
+		unordered_set<int> regionPolys = octree->getPolysInRegion(poly);
+
+		for (int ridx : regionPolys) {
+			int idx = polys[ridx]->idx;
+			BSPFACE& faceA = faces[idx];
+
+			if (polyModels[idx] != srcModel)
 				continue;
-			}
 
-			if (planarTextureOnly && (planeA.vNormal != plane.vNormal || info.iMiptex != infoA.iMiptex)) {
+			if (selected.count(idx) || ignoreFaces.count(idx))
 				continue;
+
+			if (planarTextureOnly) {
+				BSPTEXTUREINFO& info = texinfos[faceA.iTextureInfo];
+				BSPPLANE& plane = planes[faceA.iPlane];
+
+				if (!validMiptex.count(info.iMiptex))
+					continue;
+
+				bool isPlanar = false;
+				for (const vec3& norm : validNormals) {
+					if (plane.vNormal == norm) {
+						isPlanar = true;
+						break;
+					}
+				}
+
+				if (!isPlanar)
+					continue;
 			}
 
-			vector<vec3> uniqueVerts;
 			bool isConnected = false;
 
 			for (int e = 0; e < faceA.nEdges && !isConnected; e++) {
 				int32_t edgeIdx = surfedges[faceA.iFirstEdge + e];
 				BSPEDGE& edge = edges[abs(edgeIdx)];
 				int vertIdx = edgeIdx >= 0 ? edge.iVertex[1] : edge.iVertex[0];
+				const float epsilon = 1.0f;
 
-				bool isUnique = true;
-				vec3 v2 = verts[vertIdx];
-				for (vec3 v1 : selectedVerts) {
+				vec3& v2 = verts[vertIdx];
+				for (const vec3& v1 : poly->verts) {
 					if ((v1 - v2).length() < epsilon) {
 						isConnected = true;
 						break;
@@ -4351,15 +4402,22 @@ unordered_set<int> Bsp::selectConnected(int modelId, int faceId, unordered_set<i
 					int32_t edgeIdx = surfedges[faceA.iFirstEdge + e];
 					BSPEDGE& edge = edges[abs(edgeIdx)];
 					int vertIdx = edgeIdx >= 0 ? edge.iVertex[1] : edge.iVertex[0];
-					selectedVerts.push_back(verts[vertIdx]);
 				}
 
-				selected.insert(testFaceIdx);
-				anyNewFaces = true;
+				selected.insert(idx);
+				testPolys.push(polys[ridx]);
 			}
 		}
 	}
 
+	for (Polygon3D* poly : polys) {
+		delete poly;
+	}
+	for (Polygon3D* poly : selectedFaces) {
+		delete poly;
+	}
+	delete octree;
+
 	return selected;
 }
 

src/bsp/Bsp.h

@@ -372,7 +372,7 @@ class Bsp
 	// select faces connected to the given one
 	// ignoreFaces will not be connected thru
 	// planarTextureOnly = only select on the same plane with the same texture
-	unordered_set<int> selectConnected(int modelId, int faceId, unordered_set<int>& ignoreFaces, bool planarTextureOnly);
+	unordered_set<int> selectConnected(vector<int>& srcFaces, unordered_set<int>& ignoreFaces, bool planarTextureOnly);
 
 	// returns true if the map has eny entities that make use of hull 2
 	bool has_hull2_ents();

src/editor/Gui.cpp

@@ -458,13 +458,8 @@ void Gui::draw3dContextMenus() {
 				if (ImGui::MenuItem("Select connected faces", "", false)) {
 					Bsp* map = app->pickInfo.getMap();
 
-					unordered_set<int> newSelect;
-					for (int i = 0; i < app->pickInfo.faces.size(); i++) {
-						int faceIdx = app->pickInfo.faces[i];
-						int modelIdx = map->get_model_from_face(faceIdx);
-						unordered_set<int> selectPart = map->selectConnected(modelIdx, faceIdx, app->hiddenFaces, false);
-						newSelect.insert(selectPart.begin(), selectPart.end());
-					}
+					int oldSelectSz = app->pickInfo.faces.size();
+					unordered_set<int> newSelect = map->selectConnected(app->pickInfo.faces, app->hiddenFaces, false);
 
 					g_app->mapRenderer->highlightPickedFaces(false);
 
@@ -475,21 +470,16 @@ void Gui::draw3dContextMenus() {
 					g_app->mapRenderer->highlightPickedFaces(true);
 					g_app->updateTextureAxes();
 
-					logf("Selected %d faces\n", app->pickInfo.faces.size());
+					logf("Selected %d faces\n", app->pickInfo.faces.size() - oldSelectSz);
 					g_app->pickCount++;
 				}
-				tooltip(g, "Recursively select faces connected by edges.");
+				tooltip(g, "Recursively select faces connected by vertices.");
 
 				if (ImGui::MenuItem("Select connected planar faces of this texture", "", false)) {
 					Bsp* map = app->pickInfo.getMap();
 
-					unordered_set<int> newSelect;
-					for (int i = 0; i < app->pickInfo.faces.size(); i++) {
-						int faceIdx = app->pickInfo.faces[i];
-						int modelIdx = map->get_model_from_face(faceIdx);
-						unordered_set<int> selectPart = map->selectConnected(modelIdx, faceIdx, app->hiddenFaces, true);
-						newSelect.insert(selectPart.begin(), selectPart.end());
-					}
+					int oldSelectSz = app->pickInfo.faces.size();
+					unordered_set<int> newSelect = map->selectConnected(app->pickInfo.faces, app->hiddenFaces, true);
 
 					g_app->mapRenderer->highlightPickedFaces(false);
 
@@ -500,7 +490,7 @@ void Gui::draw3dContextMenus() {
 					g_app->mapRenderer->highlightPickedFaces(true);
 					g_app->updateTextureAxes();
 
-					logf("Selected %d faces\n", app->pickInfo.faces.size());
+					logf("Selected %d faces\n", app->pickInfo.faces.size() - oldSelectSz);
 					g_app->pickCount++;
 				}
 				tooltip(g, "Selects faces connected to this one which lie on the same plane and use the same texture");

src/nav/NavMeshGenerator.cpp

@@ -116,7 +116,7 @@ PolygonOctree* NavMeshGenerator::createPolyOctree(Bsp* map, const vector<Polygon
 	vec3 treeMin, treeMax;
 	getOctreeBox(map, treeMin, treeMax);
 
-	logf("Create octree depth %d, size %f -> %f\n", treeDepth, treeMax.x, treeMax.x / pow(2, treeDepth));
+	debugf("Create octree depth %d, size %f -> %f\n", treeDepth, treeMax.x, treeMax.x / pow(2, treeDepth));
 	PolygonOctree* octree = new PolygonOctree(treeMin, treeMax, treeDepth);
 
 	for (int i = 0; i < faces.size(); i++) {

src/nav/NavMeshGenerator.h

@@ -14,17 +14,17 @@ class NavMeshGenerator {
 	// returns polygons used to construct the mesh
 	NavMesh* generate(Bsp* map, int hull);
 
+	// group polys that are close together for fewer collision checks later
+	static PolygonOctree* createPolyOctree(Bsp* map, const vector<Polygon3D*>& faces, int treeDepth);
+
 private:
 	int octreeDepth = 6;
 
 	// get faces of the hull that form the borders of the map
 	vector<Polygon3D*> getHullFaces(Bsp* map, int hull);
 
 	// get smallest octree box that can contain the entire map
-	void getOctreeBox(Bsp* map, vec3& min, vec3& max);
-
-	// group polys that are close together for fewer collision checks later
-	PolygonOctree* createPolyOctree(Bsp* map, const vector<Polygon3D*>& faces, int treeDepth);
+	static void getOctreeBox(Bsp* map, vec3& min, vec3& max);
 
 	// splits faces along their intersections with each other to clip polys that extend out
 	// into the void, then tests each poly to see if it faces into the map or into the void.

src/nav/PolyOctree.cpp

@@ -85,6 +85,12 @@ void PolygonOctree::getPolysInRegion(Polygon3D* poly, vector<bool>& regionPolys)
     getPolysInRegion(root, poly, 0, regionPolys);
 }
 
+unordered_set<int> PolygonOctree::getPolysInRegion(Polygon3D* poly) {
+    unordered_set<int> regionPolys;
+    getPolysInRegion(root, poly, 0, regionPolys);
+    return regionPolys;
+}
+
 void PolygonOctree::getPolysInRegion(PolyOctant* node, Polygon3D* poly, int currentDepth, vector<bool>& regionPolys) {
     if (currentDepth >= maxDepth) {
         for (auto p : node->polygons) {
@@ -99,3 +105,18 @@ void PolygonOctree::getPolysInRegion(PolyOctant* node, Polygon3D* poly, int curr
         }
     }
 }
+
+void PolygonOctree::getPolysInRegion(PolyOctant* node, Polygon3D* poly, int currentDepth, unordered_set<int>& regionPolys) {
+    if (currentDepth >= maxDepth) {
+        for (auto p : node->polygons) {
+            if (p->idx != -1)
+                regionPolys.insert(p->idx);
+        }
+        return;
+    }
+    for (int i = 0; i < 8; ++i) {
+        if (isPolygonInOctant(poly, node->children[i])) {
+            getPolysInRegion(node->children[i], poly, currentDepth + 1, regionPolys);
+        }
+    }
+}

src/nav/PolyOctree.h

@@ -1,6 +1,7 @@
 #pragma once
 #include "Polygon3D.h"
 #include <vector>
+#include <unordered_set>
 
 struct PolyOctant {
     vec3 min;
@@ -32,10 +33,14 @@ class PolygonOctree {
 
     void getPolysInRegion(Polygon3D* poly, vector<bool>& regionPolys);
 
+    unordered_set<int> getPolysInRegion(Polygon3D* poly);
+
 private:
     void buildOctree(PolyOctant* node, int currentDepth);
 
     void getPolysInRegion(PolyOctant* node, Polygon3D* poly, int currentDepth, vector<bool>& regionPolys);
 
+    void getPolysInRegion(PolyOctant* node, Polygon3D* poly, int currentDepth, unordered_set<int>& regionPolys);
+
     void insertPolygon(PolyOctant* node, Polygon3D* polygon, int currentDepth);
 };