VMF: Optimize merged faces cleanup

Author: H2xDev

addons/godotvmf/entities/func_detail.gd

@@ -2,14 +2,16 @@
 class_name func_detail extends VMFEntityNode
 
 func _entity_setup(entity: VMFEntity):
-	var mesh = get_mesh();
-	mesh.lightmap_unwrap(global_transform, config.import.lightmap_texel_size);
-
-	$MeshInstance3D.cast_shadow = entity.data.get("disableshadows", 0) == 0;
+	var mesh = get_mesh(true, false);
 
 	if !mesh or mesh.get_surface_count() == 0:
 		queue_free();
 		return;
 
+	var unwrap_err = mesh.lightmap_unwrap(global_transform, config.import.lightmap_texel_size);
+	if unwrap_err != OK:
+		VMFLogger.warn("func_detail %s: lightmap_unwrap failed (%d), skipping UV2" % [entity.id, unwrap_err]);
+
+	$MeshInstance3D.cast_shadow = entity.data.get("disableshadows", 0) == 0;
 	$MeshInstance3D.set_mesh(mesh);
 	$MeshInstance3D/StaticBody3D/CollisionShape3D.shape = $MeshInstance3D.mesh.create_trimesh_shape();

addons/godotvmf/entities/prop_static.gd

@@ -30,6 +30,13 @@ func _entity_setup(e: VMFEntity):
 		model_instance.visibility_range_end_margin = fade_margin;
 
 	var geometry_node := get_vmfnode().geometry as Node3D;
+	if not geometry_node:
+		var node := Node3D.new();
+		node.name = "Geometry";
+		get_vmfnode().add_child(node);
+		node.set_owner(get_vmfnode().owner);
+		return;
+
 	var models_node := geometry_node.get_node_or_null("StaticProps") as Node3D;
 
 	if not models_node:

addons/godotvmf/shaders/WorldVertexTransitionMaterial.gd.uid

@@ -68,9 +68,9 @@ func get_color(x: float, y: float) -> Color:
 	var index = y + x * verts_count;
 
 	if alphas.size() == 0:
-		return Color8(255, 0, 0);
+		return Color8(0, 0, 0);
 
-	return Color8(int(alphas[index]), 0, 0);
+	return Color8(255 - int(alphas[index]), 0, 0);
 
 func get_vertices() -> Array[Vector3]:
 	if side.vertices.size() < 3:

addons/godotvmf/shaders/WorldVertexTransitionMaterial.gdshader.uid

@@ -26,6 +26,8 @@ func _init(raw: Dictionary, _solid: VMFSolid) -> void:
 	smoothing_groups = raw.get("smoothing_groups", 0);
 	solid = _solid;
 	plane = raw.plane.value;
+	if id == 18590:
+		print("Debug plane points: ", raw.plane);
 
 	vaxis = VMFTexCoord.new(raw.vaxis);
 	uaxis = VMFTexCoord.new(raw.uaxis);
@@ -59,47 +61,9 @@ func filter_existing_vertices(solid: VMFSolid) -> void:
 
 	vertices = PackedVector3Array(new_vertices);
 
-## Internal method. Calculates the vertices of this side if they are not already calculated.
-## Called automatically from VMFSolid
+## Internal method. Called from VMFSolid after vertices have been populated either
+## via vertices_plus (in _init) or via VMFSolid._compute_vertices_from_planes().
 func calculate_vertices() -> void:
-	# Already calculated
-	if vertices.size() > 0: 
-		if is_displacement:
-			dispinfo.calculate_vertices();
-		return; 
-
-	var raw_vertices: Array[Vector3] = [];
-	var cache = {};
-
-	var is_vertice_exists = func(vector: Vector3):
-		var hash_value: int = hash(Vector3i(vector));
-		if hash_value in cache: return true;
-
-		cache[hash_value] = 1;
-		return false;
-
-	for side2 in solid.sides:
-		if side2 == self: continue;
-
-		for side3 in solid.sides:
-			if side2 == side3 or side3 == self: continue;
-			var vertex = solid.get_planes_intersection_point(self, side2, side3);
-
-			if vertex == null or is_vertice_exists.call(vertex): continue;
-			raw_vertices.append(vertex as Vector3);
-
-	raw_vertices = raw_vertices.filter(func(vertex):
-		return not solid.sides.any(func(s: VMFSide): return s.plane.distance_to(vertex) > 0.01);
-	);
-
-	var side_normal: Vector3 = plane.normal;
-	var center := (plane_points[0] + plane_points[1] + plane_points[2]) / 3.0;
-	var vector_sorter: VMFVectorSorter = VMFVectorSorter.new(side_normal, center);
-
-	raw_vertices.sort_custom(vector_sorter.sort);
-
-	vertices = PackedVector3Array(raw_vertices);
-
 	if is_displacement:
 		dispinfo.calculate_vertices();
 

addons/godotvmf/src/structs/vmf_displacement_info.gd

@@ -3,7 +3,6 @@ class_name VMFSolid extends RefCounted
 var id: int = -1;
 var sides: Array[VMFSide] = [];
 var has_displacement: bool = false;
-var intersections: Dictionary = {};
 var min: Vector3 = Vector3(INF, INF, INF);
 var max: Vector3 = Vector3(-INF, -INF, -INF);
 var vertices: Array[Vector3] = [];
@@ -31,23 +30,66 @@ func define_sides(raw: Dictionary) -> void:
 
 		if side_instance.is_displacement:
 			has_displacement = true;
-	
+
+	var needs_computation := false;
+	for s in sides:
+		if s.vertices.size() == 0:
+			needs_computation = true;
+			break;
+
+	if needs_computation:
+		_compute_vertices_from_planes();
+
 	for side in sides:
 		side.calculate_vertices();
 
-	intersections = {};
 	vertices = [];
 
-func get_planes_intersection_point(side: VMFSide, side2: VMFSide, side3: VMFSide) -> Variant:
-	var d: Array[int] = [side.id, side2.id, side3.id];
-	d.sort();
+	for side in sides:
+		for v in side.vertices:
+			if v.x < min.x: min.x = v.x;
+			if v.y < min.y: min.y = v.y;
+			if v.z < min.z: min.z = v.z;
+			if v.x > max.x: max.x = v.x;
+			if v.y > max.y: max.y = v.y;
+			if v.z > max.z: max.z = v.z;
+
+## Computes vertices for all sides that don't have pre-computed vertices (i.e. no vertices_plus).
+## Iterates all unique plane triples once (C(n,3)), tests each intersection against all planes,
+## then distributes valid vertices to the three involved sides and sorts them.
+func _compute_vertices_from_planes() -> void:
+	var n := sides.size();
+	var side_verts: Array[Dictionary] = [];
+	side_verts.resize(n);
+	for i in range(n):
+		side_verts[i] = {};
+
+	for i in range(n):
+		for j in range(i + 1, n):
+			for k in range(j + 1, n):
+				var v: Variant = sides[i].plane.intersect_3(sides[j].plane, sides[k].plane);
+				if v == null: continue;
+				var vertex := v as Vector3;
+
+				var valid := true;
+				for s in sides:
+					if s.plane.distance_to(vertex) > 0.01:
+						valid = false;
+						break;
+				if not valid: continue;
+
+				var vhash := hash(Vector3i(vertex));
+				side_verts[i][vhash] = vertex;
+				side_verts[j][vhash] = vertex;
+				side_verts[k][vhash] = vertex;
 
-	var ihash := hash(d);
-	var is_intersection_defined: bool = ihash in intersections;
+	for i in range(n):
+		if sides[i].vertices.size() > 0: continue;
 
-	if is_intersection_defined:
-		return intersections[ihash];
-	else:
-		var vertex: Variant = side.plane.intersect_3(side2.plane, side3.plane);
-		intersections[ihash] = vertex;
-		return vertex;
+		var raw: Array = side_verts[i].values();
+		var side_normal := sides[i].plane.normal;
+		var pp := sides[i].plane_points;
+		var center := (pp[0] + pp[1] + pp[2]) / 3.0;
+		var sorter := VMFVectorSorter.new(side_normal, center);
+		raw.sort_custom(sorter.sort);
+		sides[i].vertices = PackedVector3Array(raw);

addons/godotvmf/src/structs/vmf_side.gd

@@ -173,6 +173,10 @@ static func remove_merged_faces(brush_a: VMFSolid, brushes: Array[VMFSolid]) ->
 	for brush_b in brushes:
 		if brush_a == brush_b: continue;
 
+		if brush_a.max.x < brush_b.min.x or brush_b.max.x < brush_a.min.x: continue;
+		if brush_a.max.y < brush_b.min.y or brush_b.max.y < brush_a.min.y: continue;
+		if brush_a.max.z < brush_b.min.z or brush_b.max.z < brush_a.min.z: continue;
+
 		for side_a in brush_a.sides:
 			var a_removed = false;
 

addons/godotvmf/src/structs/vmf_solid.gd

@@ -8,7 +8,7 @@ static var _vector2Regex := RegEx.create_from_string('^([-\\d\\.e]+)\\s([-\\d\\.
 static var _colorRegex := RegEx.create_from_string('^([-\\d\\.e]+)\\s([-\\d\\.e]+)\\s([-\\d\\.e]+)\\s([-\\d\\.e]+)$');
 static var _uvRegex := RegEx.create_from_string('\\[([-\\d\\.e]+)\\s([-\\d\\.e]+)\\s([-\\d\\.e]+)\\s([-\\d\\.e]+)\\]\\s([-\\d\\.e]+)');
 static var _planeRegex := RegEx.create_from_string('\\(([\\d\\-\\.e]+\\s[\\d\\-\\.e]+\\s[\\d\\-\\.e]+)\\)\\s?\\(([\\d\\-\\.e]+\\s[\\d\\-\\.e]+\\s[\\d\\-\\.e]+)\\)\\s?\\(([\\d\\-\\.e]+\\s[\\d\\-\\.e]+\\s[\\d\\-\\.e]+)\\)');
-static var _commentRegex := RegEx.create_from_string('\\s+?\\/\\/.+');
+static var _commentRegex := RegEx.create_from_string('\\s*\\/\\/.+');
 
 ## Returns Dictionary representation of the Valve Data Format file located at [file_path].
 ## Returns null and prints an error if the file could not be read or parsed.
@@ -60,7 +60,7 @@ static func parse_value(line: String) -> Variant:
 
 		var v = Plane(plane[0], plane[1], plane[2]);
 
-		if not v:
+		if v.normal == Vector3.ZERO:
 			push_error('ValveFormatParser: Failed to create plane from: ' + line);
 			return null;
 
@@ -71,7 +71,7 @@ static func parse_value(line: String) -> Variant:
 		return float(line);
 	return line;
 static func define_structure(hierarchy: Array, line: String, keys_to_lower = false):
-	var _name := line.strip_edges().replace('{', '').replace('"', '');
+	var _name := line.strip_edges().replace('{', '').replace('"', '').strip_edges();
 	if keys_to_lower:
 		_name = _name.to_lower();
 	var newStruct = {};