Tree Gen 1.43.0: UCX in _Pieces_All.fbx - und zwei Fehler, die dabei auffielen

Die Gesamtdatei kam ohne Kollision an, waehrend die Einzeldateien welche
hatten. Jetzt bekommt jedes Teil auch dort seine Huelle, gleiche Konvention wie
beim Stand-Baum: UCX_<Teilname> als Geschwister, kein Elternteil. Sie entstehen
VOR dem Umsetzen der Pivots, weil in der Gesamtdatei alle Teile noch an ihrer
Originalposition stehen.

Beim Nachmessen kamen zwei Fehler heraus, die auch die BESTEHENDEN
Einzeldateien betrafen:

1) Die Huellen umschlossen das Laub mit
   _tree_ucx las alle Vertices eines Teils, also auch die Blatt-Cards. Gemessen
   am baum-Preset war die Huelle dadurch 1.4- bis 2.1-mal so gross wie das Holz.
   Jetzt nur noch Material-Slot 0. Die Spielseite hatte das fuer ihre
   Interim-Boxen laengst so gemacht - zu Recht.

2) Das Aufweiten war fuer schlanke Teile kaputt
   Nach dem Vereinfachen wurde die Huelle durch Skalieren um die Huellenmitte
   aufgeblasen. Bei langgestreckten Teilen entgleist das: liegt eine Flaeche
   fast durch die Mitte, wird der Hebel winzig und der Faktor explodiert -
   gemessen 4.2 an einem Stammsegment mit Laenge zu Dicke 13:1. An der dicken
   Eiche blieb es bei 1.0-1.4, deshalb ist es nie aufgefallen; erst der Wechsel
   auf Rinde-only machte die Teile schlank genug.

   Jetzt wird je Flaeche der ECHTE Fehlbetrag gemessen und die Vertices um genau
   diesen Betrag nach aussen geschoben - eine Verschiebung in Metern, kein
   Verhaeltnis. Iterativ, weil ein Vertex mehreren Flaechen angehoert und
   entlang seiner eigenen Normale wandert (ein Durchgang liess einen Rest
   stehen, der Test schlug an). Bleibt danach etwas uebrig, faellt die Funktion
   auf die unvereinfachte Huelle zurueck.

Ergebnis am 12-teiligen Baum: alle Huellen 14-31 Verts (Budget 32), keine
groesser als das 1.35-fache ihres Holzes.

test_faell_teile prueft die Gesamtdatei jetzt auf: je Teil genau eine Huelle,
richtiger Name, kein Elternteil, und Huellengroesse gegen die RINDE.
Gegenproben: ohne Rinde-Filter 10 Fehler (1.41x bis 2.06x), ohne Huellen in der
Gesamtdatei 1 Fehler.

27 Tests bestehen.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

stylized_tree_generator.py

@@ -1,7 +1,7 @@
 bl_info = {
     "name": "Stylized Tree Generator",
     "author": "D4rkst3r",
-    "version": (1, 42, 0),
+    "version": (1, 43, 0),
     "blender": (4, 2, 0),
     "location": "View3D > Sidebar > Tree Gen",
     "description": "Parametrischer Baum-/Palmen-/Busch-Generator (Geometry Nodes) mit Wachstums-Stufen",
@@ -2211,6 +2211,13 @@ def _tree_ucx(quell_objs, name, max_verts=32, punkte=None):
         return None
 
     quelle = [v.co.copy() for v in bm.verts]
+
+    # Rohzustand sichern. Das Vereinfachen unten kann bei LANGGESTRECKTEN
+    # Teilen entgleisen - siehe die Notbremse nach dem Aufblasen.
+    bm.verts.index_update()
+    roh_verts = [v.co.copy() for v in bm.verts]
+    roh_faces = [[v.index for v in f.verts] for f in bm.faces]
+
     winkel = math.radians(1.0)
     while len(bm.verts) > max_verts and winkel < math.radians(60.0):
         bmesh.ops.dissolve_limit(bm, angle_limit=winkel,
@@ -2224,29 +2231,75 @@ def _tree_ucx(quell_objs, name, max_verts=32, punkte=None):
     bm.normal_update()
 
     # Das Vereinfachen schneidet Ecken ab - die Huelle waere danach KLEINER als
-    # das Teil und der Spieler wuerde einsinken. Exakt so weit aufblasen, dass
-    # wieder alles hineinpasst.
+    # das Teil und der Spieler wuerde einsinken. Also wieder aufweiten.
+    #
+    # NICHT durch Skalieren um die Huellenmitte. Das war der erste Ansatz und
+    # entgleist bei langgestreckten Teilen: liegt eine Flaeche fast durch die
+    # Mitte, wird der Hebel winzig und der noetige Faktor explodiert. Gemessen
+    # an einem Stammsegment des schlanken "baum"-Presets (Laenge zu Dicke rund
+    # 13:1) kam Faktor 4.2 heraus - die Huelle war viermal so gross wie das Holz.
+    # Bei der dicken Eiche blieb es bei 1.0-1.4, deshalb ist es lange nicht
+    # aufgefallen.
+    #
+    # Stattdessen je Flaeche den ECHTEN Fehlbetrag messen (wie weit liegt der
+    # schlimmste Quellpunkt vor ihrer Ebene?) und die Vertices um genau diesen
+    # Betrag nach aussen schieben. Das ist eine Verschiebung in Metern, kein
+    # Verhaeltnis - sie kann nicht explodieren.
     if bm.faces and quelle:
-        mitte = Vector((0.0, 0.0, 0.0))
-        for v in bm.verts:
-            mitte += v.co
-        mitte /= max(len(bm.verts), 1)
-        faktor = 1.0
-        for f in bm.faces:
-            n = f.normal
-            if n.length_squared < 1e-12:
-                continue
-            d = n.dot(f.verts[0].co)
-            basis = d - n.dot(mitte)
-            if basis <= 1e-9:
-                continue
-            for co in quelle:
-                noetig = (n.dot(co) - n.dot(mitte)) / basis
-                if noetig > faktor:
-                    faktor = noetig
-        if faktor > 1.0:
-            for v in bm.verts:
-                v.co = mitte + (v.co - mitte) * faktor
+        def _rest():
+            """Groesster Abstand, mit dem ein Quellpunkt noch draussen liegt."""
+            r = 0.0
+            for f in bm.faces:
+                n = f.normal
+                if n.length_squared < 1e-12:
+                    continue
+                d0 = n.dot(f.verts[0].co)
+                r = max(r, max((n.dot(co) - d0) for co in quelle))
+            return r
+
+        # ITERATIV. Ein Vertex gehoert mehreren Flaechen an und wandert entlang
+        # SEINER Normale - die Ebene verschiebt sich dadurch nur um den auf sie
+        # projizierten Anteil, also weniger als noetig. Ein einzelner Durchgang
+        # laesst deshalb einen Rest stehen (gemessen, der Test schlug an). Jeder
+        # weitere Durchgang verkleinert ihn; nach wenigen ist er weg.
+        for _ in range(8):
+            rest = _rest()
+            if rest <= 1e-4:
+                break
+            schuld = {}
+            for f in bm.faces:
+                n = f.normal
+                if n.length_squared < 1e-12:
+                    continue
+                d0 = n.dot(f.verts[0].co)
+                ueber = max((n.dot(co) - d0) for co in quelle)
+                if ueber > 1e-9:
+                    for v in f.verts:
+                        if ueber > schuld.get(v, 0.0):
+                            schuld[v] = ueber
+            if not schuld:
+                break
+            for v, d in schuld.items():
+                n = v.normal
+                if n.length_squared < 1e-12:
+                    continue
+                v.co = v.co + n.normalized() * d
+            bm.normal_update()
+
+        # Notbremse: geht es nicht auf, ist die vereinfachte Huelle als
+        # Kollision unbrauchbar - dann lieber die unvereinfachte mit ein paar
+        # Vertices mehr.
+        if _rest() > 1e-4 and roh_faces:
+            bm.free()
+            bm = bmesh.new()
+            neu_v = [bm.verts.new(c) for c in roh_verts]
+            bm.verts.ensure_lookup_table()
+            for f in roh_faces:
+                try:
+                    bm.faces.new([neu_v[i] for i in f])
+                except ValueError:
+                    pass          # Doppelflaeche - die gibt es schon
+            bm.normal_update()
 
     bmesh.ops.triangulate(bm, faces=bm.faces[:])
     me = bpy.data.meshes.new("UCX_" + name)
@@ -2257,6 +2310,27 @@ def _tree_ucx(quell_objs, name, max_verts=32, punkte=None):
     return ob
 
 
+def _rinden_punkte(ob):
+    """Weltkoordinaten der RINDEN-Vertices (Material-Slot 0) eines Faell-Teils.
+
+    Blatt-Cards gehoeren nicht in eine Kollisionshuelle: sie stehen weit vom
+    Holz ab, und der Spieler soll gegen den Ast stossen, nicht gegen das Laub.
+    Gemessen an der Eiche blaeht das Laub die Huellen-Diagonale beim Ast um
+    8-19 % auf - und beim OBERSTEN Stammsegment, das die Krone traegt, um 67 %
+    (1.75 m statt 1.05 m).
+
+    Fallback auf alle Vertices, falls ein Teil keinen zweiten Slot hat: ein
+    reines Stammsegment ist ohnehin komplett Rinde.
+    """
+    me = ob.data
+    if len(me.materials) > 1:
+        idx = {vi for p in me.polygons if p.material_index == 0
+               for vi in p.vertices}
+        if idx:
+            return [ob.matrix_world @ me.vertices[i].co for i in idx]
+    return [ob.matrix_world @ v.co for v in me.vertices]
+
+
 def _stamm_punkte(tree_obj, matrix):
     """Stamm-Koordinaten vom Fuss bis zum KRONENANSATZ, in Weltkoordinaten.
 
@@ -3044,9 +3118,26 @@ class TREEGEN_OT_export_pieces(Operator):
         # Damit Unreal den zusammengesetzten Baum deckungsgleich rekonstruieren
         # kann: hier stehen alle Teile noch an ihrer Originalposition.
         if s.piece_export_combined and teile:
+            # Auch die Gesamtdatei bekommt je Teil seine Huelle - dieselbe
+            # Geschwister-Konvention wie beim Stand-Baum: `UCX_<Teilname>`
+            # neben dem Teil, kein Elternteil. Vorher kam die Datei ohne
+            # Kollision an, waehrend die Einzeldateien welche hatten.
+            #
+            # Sie entstehen HIER und nicht in der Schleife weiter unten: dort
+            # sitzt jedes Teil schon auf seinem eigenen Massenmittelpunkt, in
+            # der Gesamtdatei stehen alle noch an ihrer Originalposition.
+            hullen = []
+            if s.piece_ucx:
+                for t in teile:
+                    h = _tree_ucx(None, t.name, max_verts=s.piece_ucx_verts,
+                                  punkte=_rinden_punkte(t))
+                    if h is not None:
+                        hullen.append(h)
             _deselect(context)
             for t in teile:
                 t.select_set(True)
+            for h in hullen:
+                h.select_set(True)
             context.view_layer.objects.active = teile[0]
             bpy.ops.export_scene.fbx(
                 filepath=os.path.join(verzeichnis, basis + "_Pieces_All.fbx"),
@@ -3055,6 +3146,11 @@ class TREEGEN_OT_export_pieces(Operator):
                 use_triangles=True, use_custom_props=True, colors_type='SRGB',
                 add_leaf_bones=False, bake_anim=False, path_mode='AUTO',
                 apply_scale_options='FBX_SCALE_ALL')
+            for h in hullen:
+                hm = h.data
+                bpy.data.objects.remove(h, do_unlink=True)
+                if hm.users == 0:
+                    bpy.data.meshes.remove(hm)
 
         # --- Je Teil eine Datei, Pivot = Massenmittelpunkt --------------
         geschrieben = 0
@@ -3063,7 +3159,10 @@ class TREEGEN_OT_export_pieces(Operator):
             t.data.transform(Matrix.Translation(-schwer))
             t.matrix_basis = Matrix.Identity(4)
 
-            hull = _tree_ucx([t], t.name, max_verts=s.piece_ucx_verts) \
+            # Huelle aus der RINDE, nicht aus allen Vertices: das Laub blaehte
+            # sie beim obersten Stammsegment gemessen um 67 % auf.
+            hull = _tree_ucx(None, t.name, max_verts=s.piece_ucx_verts,
+                             punkte=_rinden_punkte(t)) \
                 if s.piece_ucx else None
 
             _deselect(context)