Tree Gen 1.27.0: Blatt-Cards aus einer Collection (Punkt 3)

"Leaf Card" kann jetzt eine COLLECTION sein: je Blattpunkt wird zufaellig eine
Card gezogen (Pick Instance, seed-stabil). Damit legt der Nutzer 4-6
Diamond-Cards mit unterschiedlichen Atlas-UVs an und die Krone mischt sie.
Rueckwaertskompatibel - ein einzelnes Objekt geht weiter, die Sammlung hat
Vorrang.

Umsetzung: Collection Info mit Separate Children (sonst kaeme die Sammlung als
ein Klumpen an und Pick Instance haette nichts zum Auswaehlen), Geometry-Switch
zwischen Einzel- und Sammlungspfad, Instanz-Index aus einem Random Value, dessen
Obergrenze aus der TATSAECHLICHEN Anzahl kommt - eine feste Obergrenze wuerde
bei weniger Cards Luecken erzeugen. Geometry Nodes kann einen leeren
Collection-Zeiger nicht selbst pruefen, deshalb setzt make_leaves einen
"Use Collection"-Schalter.

Beweisfuehrung im Test: die Zufalls-Groesse wird ABGESCHALTET, dann kommt jede
Groessenabweichung nur von der Card-Variante und die Anzahl verschiedener
Face-Flaechen ist ein exakter Zaehler. Gemessen: Einzel-Card 2 Flaechen (ein
Card-Paar), Sammlung mit 4 Cards 10 Flaechen - alle Varianten kommen vor.
Gleicher Seed identisch, anderer Seed anders.

Nebenbei: die Vorpruefung des Blattwerk-Operators war eine zusammengesetzte
Bedingung, die bei gesetzter Sammlung ohne Einzel-Card auf None zugriff.

Neu: tests/test_blatt_varianten.py. 20 Tests bestehen.

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

README.md

@@ -352,6 +352,39 @@ Gras-, Blumen- und Farn-Bueschel. Der Kern ist die **Wind-UV**:
 
 ## Stylized Tree Generator
 
+### Spielfertiger Stand-Baum (Faellsystem)
+
+Knopf **Spielfertig exportieren** im Export-Panel: Stamm und `_Leaf`-Ebene
+werden zu **einem** Mesh mit **zwei Material-Slots** verschmolzen
+(Slot 0 = `M_Bark`, Slot 1 = `M_Foliage`). Die getrennten Objekte im Blend
+bleiben die Arbeitsebene — verschmolzen wird nur die Export-Kopie. Ursprung
+Bbox-Unterseite Mitte, FBX-Einstellungen wie in der Fels-Pipeline.
+
+**Kugel-Normalen** (Haken `Kugel-Normalen auf Blaetter`, Standard an): alle
+Blatt-Normalen zeigen radial vom Kronen-Schwerpunkt nach aussen. Ohne das wirkt
+jede Card wie ein eigenes flaches Blech und die Krone flimmert im Licht. Der
+Schwerpunkt kommt **nur aus den Blatt-Faces** — der Stamm wuerde die Mitte nach
+unten ziehen und die Kugel verkippen.
+
+> Bewusst direkt ueber `normals_split_custom_set` statt ueber den
+> Normal-Edit-Modifier: der muesste vor dem Export angewendet werden, und
+> angewendete Modifier plus Custom Normals ist genau die Kombination, bei der
+> der FBX-Export gerne flachbuegelt. Am **reimportierten** FBX gemessen:
+> mittlere Radialitaet **1.000**, 100 % der 510 Blatt-Loops ueber 0.8.
+> Gegenprobe Rinde 0.043.
+
+**Card-Varianten:** `Card-Sammlung` nimmt eine Collection mit 4–6 Diamond-Cards
+unterschiedlicher Atlas-UVs; je Blattpunkt wird eine zufaellig gezogen
+(seed-stabil). Eine einzelne Card geht weiter — die Sammlung hat Vorrang.
+
+Zwei Fallen beim Bauen:
+
+- Ueber `bmesh.from_mesh` zusammenzufuegen haengt die Geometrie zwar an, wirft
+  aber die **Material-Indizes** weg: danach lagen alle 748 Faces auf Index 0.
+  Blenders `join` fuehrt die Slot-Listen zusammen und rechnet die Indizes um.
+- `join` loescht das zweite Objekt; jede gehaltene Referenz darauf ist danach
+  tot. Die Aufraeumliste fuehrt deshalb **Namen** statt Objekte.
+
 ### Proportionen: gemessen, nicht geschaetzt
 
 Drei Presets sahen falsch aus. Die Ursachen wurden gemessen bzw. belegt, nicht
@@ -572,6 +605,8 @@ gefiltert `.\run_tests.ps1 -Filter panels`.
 
 | Datei | prueft |
 |---|---|
+| `tests/test_baum_export.py` | Stand-Baum: ein Mesh, zwei Slots, Ursprung, **Kugel-Normalen im exportierten FBX** |
+| `tests/test_blatt_varianten.py` | Card-Sammlung: alle Varianten werden gezogen, seed-stabil, Einzelobjekt weiter moeglich |
 | `tests/test_proportionen.py` | Baum-Proportionen: Palmenkrone, Strauch-Breite, Setzling-Schlankheit, Branch Count 0 |
 | `tests/test_bruchstuecke.py` | Bruchstuecke: Volumen 100 % des Muttersteins, dichte Topologie, genau ein Erz-Stueck, Material-Slots, Ursprung, UCX je Teil |
 | `tests/test_schnellstart.py` | Schnellstart: jede Sorte liefert ohne Nacharbeit Geometrie + Slot, Erz-Sorte ueber der Dichte-Schwelle, Dissolve-Bereich streut je Stein |

blender_manifest_tree.toml

@@ -1,7 +1,7 @@
 schema_version = "1.0.0"
 
 id = "stylized_tree_generator"
-version = "1.26.0"
+version = "1.27.0"
 name = "Stylized Tree Generator"
 tagline = "Parametrische Baeume, Palmen, Bueschen mit Wachstums-Stufen"
 maintainer = "D4rkst3r"

dist/index.html

@@ -50,17 +50,17 @@
     <td>34.1KB</td>
   </tr>
   <tr>
-    <td><tt><a href="./stylized_tree_generator-1.26.0.zip?repository=.%2Findex.json&blender_version_min=4.2.0">stylized_tree_generator-1.26.0</a></tt></td>
+    <td><tt><a href="./stylized_tree_generator-1.27.0.zip?repository=.%2Findex.json&blender_version_min=4.2.0">stylized_tree_generator-1.27.0</a></tt></td>
     <td>Stylized Tree Generator</td>
     <td>Parametrische Baeume, Palmen, Bueschen mit Wachstums-Stufen</td>
     <td><a href="https://git.d4rkst3r.de/D4rkst3r/stylized-rock-generator">link</a></td>
     <td>4.2.0 - ~</td>
     <td>all</td>
     <td>all</td>
-    <td>27.6KB</td>
+    <td>28.6KB</td>
   </tr>
 </table>
 
-<center><p>Built 2026-08-06, 04:42</p></center>
+<center><p>Built 2026-08-06, 04:48</p></center>
 </body>
 </html>

dist/index.json

@@ -82,7 +82,7 @@
       "id": "stylized_tree_generator",
       "name": "Stylized Tree Generator",
       "tagline": "Parametrische Baeume, Palmen, Bueschen mit Wachstums-Stufen",
-      "version": "1.26.0",
+      "version": "1.27.0",
       "type": "add-on",
       "maintainer": "D4rkst3r",
       "license": [
@@ -98,9 +98,9 @@
         "Mesh",
         "Modeling"
       ],
-      "archive_url": "./stylized_tree_generator-1.26.0.zip",
+      "archive_url": "./stylized_tree_generator-1.27.0.zip",
-      "archive_size": 28299,
+      "archive_size": 29267,
-      "archive_hash": "sha256:8e6cf3131a36efe840d0f59802003a3cb198b611a405c53e6428f2a99029b0c9"
+      "archive_hash": "sha256:daeb815cde034e527cdffb0e76a980e964f228b7a0f39070ba78477be9fc3e57"
     }
   ]
 }

stylized_tree_generator.py

@@ -1,7 +1,7 @@
 bl_info = {
     "name": "Stylized Tree Generator",
     "author": "D4rkst3r",
-    "version": (1, 26, 0),
+    "version": (1, 27, 0),
     "blender": (4, 2, 0),
     "location": "View3D > Sidebar > Tree Gen",
     "description": "Parametrischer Baum-/Palmen-/Busch-Generator (Geometry Nodes) mit Wachstums-Stufen",
@@ -1176,6 +1176,7 @@ LEAF_DEFAULTS = {
     "Size Var": 0.35,
     "Tilt": 0.5,           # wie stark die Cards aus der Senkrechten kippen (rad)
     "Seed": 0,
+    "Use Collection": False,
 }
 
 
@@ -1211,6 +1212,11 @@ def build_leaf_group(rebuild=False):
 
     add_in("Tree", 'NodeSocketObject')
     add_in("Leaf Card", 'NodeSocketObject')
+    # Mehrere Atlas-Varianten: die Collection liefert je Punkt eine zufaellig
+    # gewaehlte Card. "Use Collection" wird von make_leaves gesetzt - Geometry
+    # Nodes kann einen leeren Collection-Zeiger nicht selbst pruefen.
+    add_in("Leaf Cards", 'NodeSocketCollection')
+    add_in("Use Collection", 'NodeSocketBool', False)
     add_in("Density", 'NodeSocketFloat', LEAF_DEFAULTS["Density"], 0.0, 20000.0)
     add_in("Max Radius", 'NodeSocketFloat', LEAF_DEFAULTS["Max Radius"], 0.001, 0.5)
     add_in("Size", 'NodeSocketFloat', LEAF_DEFAULTS["Size"], 0.01, 5.0)
@@ -1228,6 +1234,23 @@ def build_leaf_group(rebuild=False):
     card = N("GeometryNodeObjectInfo"); card.location = (-700, -200)
     L(V["Leaf Card"], _sock(card, "Object"))
 
+    # Separate Children = jedes Objekt der Collection wird eine EIGENE Instanz.
+    # Ohne das kaeme die Collection als ein einziger Klumpen an und "Pick
+    # Instance" haette nichts zum Auswaehlen.
+    coll = N("GeometryNodeCollectionInfo"); coll.location = (-700, -420)
+    L(V["Leaf Cards"], _sock(coll, "Collection"))
+    try:
+        _sock(coll, "Separate Children").default_value = True
+        _sock(coll, "Reset Children").default_value = True
+    except (AttributeError, KeyError):
+        pass
+
+    quelle = N("GeometryNodeSwitch"); quelle.location = (-500, -300)
+    quelle.input_type = 'GEOMETRY'
+    L(V["Use Collection"], _sock(quelle, "Switch"))
+    L(_out(card, "Geometry"), _sock(quelle, "False"))
+    L(_out(coll, "Instances", "Geometry"), _sock(quelle, "True"))
+
     # Auswahl: nur duenne Aeste (uv_r < Max Radius)
     na = N("GeometryNodeInputNamedAttribute"); na.location = (-700, 20)
     na.data_type = 'FLOAT'
@@ -1272,7 +1295,35 @@ def build_leaf_group(rebuild=False):
 
     inst = N("GeometryNodeInstanceOnPoints"); inst.location = (100, 200)
     L(_out(dist, "Points"), _sock(inst, "Points"))
-    L(_out(card, "Geometry"), _sock(inst, "Instance"))
+    L(_out(quelle, "Output"), _sock(inst, "Instance"))
+    try:
+        L(V["Use Collection"], _sock(inst, "Pick Instance"))
+    except (KeyError, RuntimeError):
+        pass
+
+    # Zufaelliger Index je Punkt, aus der tatsaechlichen Anzahl abgeleitet -
+    # eine feste Obergrenze wuerde bei weniger Cards Luecken erzeugen.
+    dsize = N("GeometryNodeAttributeDomainSize"); dsize.location = (-320, -560)
+    try:
+        dsize.component = 'INSTANCES'
+    except (AttributeError, TypeError):
+        pass
+    L(_out(coll, "Instances", "Geometry"), _sock(dsize, "Geometry"))
+    dmax = N("ShaderNodeMath"); dmax.location = (-150, -560)
+    dmax.operation = 'SUBTRACT'; dmax.inputs[1].default_value = 1.0
+    try:
+        L(_out(dsize, "Instance Count", "Point Count"), dmax.inputs[0])
+    except (KeyError, RuntimeError):
+        dmax.inputs[0].default_value = 1.0
+    ridx = N("FunctionNodeRandomValue"); ridx.location = (100, -560)
+    ridx.data_type = 'INT'
+    L(V["Seed"], _sock(ridx, "Seed"))
+    ridx.inputs[4].default_value = 0
+    L(dmax.outputs[0], ridx.inputs[5])
+    try:
+        L(ridx.outputs["Value"], _sock(inst, "Instance Index"))
+    except (KeyError, RuntimeError):
+        pass
     L(rrot.outputs["Value"], _sock(inst, "Rotation"))
     L(rsc.outputs[1], _sock(inst, "Scale"))
 
@@ -1287,7 +1338,7 @@ def leaf_socket_ids(ng):
             if getattr(so, "in_out", "") == 'INPUT'}
 
 
-def make_leaves(context, tree_obj, card_obj, name=None, **overrides):
+def make_leaves(context, tree_obj, card_obj, name=None, card_coll=None, **overrides):
     """Erzeugt/aktualisiert ein <Baum>_Leaf-Objekt mit dem Blattwerk-Modifier."""
     name = name or (tree_obj.name + "_Leaf")
     ob = bpy.data.objects.get(name)
@@ -1306,6 +1357,10 @@ def make_leaves(context, tree_obj, card_obj, name=None, **overrides):
     ids = leaf_socket_ids(ng)
     md[ids["Tree"]] = tree_obj
     md[ids["Leaf Card"]] = card_obj
+    # Rueckwaertskompatibel: ohne Collection bleibt alles wie bisher.
+    if "Leaf Cards" in ids:
+        md[ids["Leaf Cards"]] = card_coll
+    overrides.setdefault("Use Collection", card_coll is not None)
     vals = dict(LEAF_DEFAULTS); vals.update(overrides)
     for k, v in vals.items():
         if k in ids:
@@ -1484,8 +1539,15 @@ class TreeGenSettings(PropertyGroup):
     )
     leaf_card: PointerProperty(
         name="Blatt-Card", type=bpy.types.Object,
-        description=("Objekt, das als Blatt/Billboard gestreut wird (z.B. dein "
+        description=("Einzelne Card, die gestreut wird (z.B. dein 'Diamon "
-                     "'Diamon Plane'). Leer = _Leaf bleibt leer zum Selbermodellieren"),
+                     "Plane'). Leer = _Leaf bleibt leer zum Selbermodellieren. "
+                     "Wird ignoriert, sobald eine Card-Sammlung gesetzt ist"),
+    )
+    leaf_cards: PointerProperty(
+        name="Card-Sammlung", type=bpy.types.Collection,
+        description=("Sammlung mehrerer Cards mit unterschiedlichen Atlas-UVs. "
+                     "Je Blattpunkt wird zufaellig eine gewaehlt (Seed-stabil) - "
+                     "damit mischt die Krone 4-6 Varianten statt einer"),
     )
     leaf_density: FloatProperty(
         name="Dichte", default=150.0, min=0.0, max=20000.0,
@@ -1755,8 +1817,13 @@ class TREEGEN_OT_leaves(Operator):
 
     def execute(self, context):
         s = context.scene.tree_gen_settings
-        if s.leaf_card is None or s.leaf_card.type != 'MESH':
+        # Card-Sammlung hat Vorrang; ohne sie muss die Einzel-Card ein Mesh sein.
-            self.report({'ERROR'}, "Bitte zuerst eine Blatt-Card waehlen (Mesh-Objekt).")
+        if s.leaf_cards is not None:
+            if not [o for o in s.leaf_cards.objects if o.type == 'MESH']:
+                self.report({'ERROR'}, "Die Card-Sammlung enthaelt keine Meshes.")
+                return {'CANCELLED'}
+        elif s.leaf_card is None or s.leaf_card.type != 'MESH':
+            self.report({'ERROR'}, "Bitte eine Blatt-Card oder eine Card-Sammlung waehlen.")
             return {'CANCELLED'}
         trees = [o for o in context.selected_objects
                  if o.type == 'MESH' and not o.name.endswith(("_Leaf", "_Frucht"))]
@@ -1768,6 +1835,7 @@ class TREEGEN_OT_leaves(Operator):
         for t in trees:
             try:
                 lf = make_leaves(context, t, s.leaf_card,
+                                 card_coll=s.leaf_cards,
                                  Density=s.leaf_density, Size=s.leaf_size,
                                  **{"Size Var": s.leaf_size_var,
                                     "Max Radius": s.leaf_max_radius,
@@ -1969,9 +2037,12 @@ class VIEW3D_PT_tree_leaves(_TreeSub):
     def draw(self, context):
         layout = self.layout
         s = context.scene.tree_gen_settings
-        layout.prop(s, "leaf_card")
+        layout.prop(s, "leaf_cards")
+        row = layout.row()
+        row.active = s.leaf_cards is None
+        row.prop(s, "leaf_card")
         col = layout.column(align=True)
-        col.active = s.leaf_card is not None
+        col.active = s.leaf_card is not None or s.leaf_cards is not None
         col.prop(s, "leaf_density")
         col.prop(s, "leaf_size")
         col.prop(s, "leaf_size_var")
@@ -1980,7 +2051,11 @@ class VIEW3D_PT_tree_leaves(_TreeSub):
         col.prop(s, "leaf_budget")
         layout.separator()
         layout.operator("object.treegen_leaves", icon='OUTLINER_OB_POINTCLOUD')
-        if s.leaf_card is None:
+        if s.leaf_cards is not None:
+            n = len([o for o in s.leaf_cards.objects if o.type == 'MESH'])
+            layout.label(text="%d Card-Variante(n), zufaellig je Blatt" % n,
+                         icon='INFO')
+        elif s.leaf_card is None:
             layout.label(text="Ohne Card bleibt _Leaf leer", icon='INFO')
 
 

tests/test_blatt_varianten.py

@@ -0,0 +1,135 @@
+"""Punkt 3: Blatt-Cards aus einer COLLECTION statt aus einem Einzelobjekt.
+
+Damit kann der Nutzer 4-6 Diamond-Cards mit unterschiedlichen Atlas-UVs anlegen
+und die Krone mischt sie. Rueckwaertskompatibel: ein einzelnes Objekt geht
+weiter.
+
+Beweisfuehrung: die Zufalls-Groesse wird ABGESCHALTET (Size Var 0). Dann kommt
+jede Groessenabweichung ausschliesslich von der Card-Variante, und die Anzahl
+verschiedener Face-Flaechen ist ein exakter Zaehler fuer die benutzten Varianten.
+Mit eingeschalteter Groessenstreuung waere das Mass unbrauchbar - alles streut.
+
+Aufruf: blender --background --factory-startup --python tests/test_blatt_varianten.py
+"""
+import os
+import sys
+import importlib.util
+
+import bpy
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+spec = importlib.util.spec_from_file_location(
+    "tg", os.path.join(ROOT, "stylized_tree_generator.py"))
+tg = importlib.util.module_from_spec(spec)
+sys.modules["tg"] = tg
+spec.loader.exec_module(tg)
+tg.register()
+
+fails = []
+for o in list(bpy.data.objects):
+    bpy.data.objects.remove(o, do_unlink=True)
+
+
+def card(name, groesse):
+    """Diamond-Card in definierter Groesse - die Groesse ist hier der Marker."""
+    me = bpy.data.meshes.new(name)
+    g = groesse
+    me.from_pydata([(-g, 0, 0), (0, 0, g * 1.4), (g, 0, 0), (0, 0, -g * 0.2)],
+                   [], [(0, 1, 2), (0, 2, 3)])
+    me.update()
+    ob = bpy.data.objects.new(name, me)
+    bpy.context.scene.collection.objects.link(ob)
+    return ob
+
+
+coll = bpy.data.collections.new("Leaf_Cards")
+bpy.context.scene.collection.children.link(coll)
+einzel = card("Card_Single", 0.5)
+GROESSEN = (0.30, 0.45, 0.60, 0.75)
+for i, g in enumerate(GROESSEN):
+    c = card("Card_%02d" % (i + 1), g)
+    bpy.context.scene.collection.objects.unlink(c)
+    coll.objects.link(c)
+
+s = bpy.context.scene.tree_gen_settings
+s.preset = 'baum'
+s.use_growth = False
+s.apply_modifier = True
+s.art_name = "Eiche"
+s.variant = 1
+s.leaf_size_var = 0.0        # entscheidend: Groesse kommt NUR von der Variante
+
+bpy.ops.object.treegen_create()
+baum = [o for o in bpy.context.scene.objects
+        if o.type == 'MESH' and o.name.startswith("Eiche_01")
+        and not o.name.endswith(("_Leaf", "_Frucht"))][0]
+
+
+def streuen(collection, einzelcard, seed):
+    s.leaf_cards = collection
+    s.leaf_card = einzelcard
+    s.seed = seed
+    for o in bpy.context.scene.objects:
+        o.select_set(o is baum)
+    bpy.context.view_layer.objects.active = baum
+    bpy.ops.object.treegen_leaves()
+    bl = bpy.data.objects.get(baum.name + "_Leaf")
+    dg = bpy.context.evaluated_depsgraph_get()
+    ev = bl.evaluated_get(dg)
+    me = ev.to_mesh()
+    flaechen = sorted({round(p.area, 5) for p in me.polygons})
+    n = len(me.polygons)
+    ev.to_mesh_clear()
+    return n, flaechen
+
+
+print("%-26s %7s %s" % ("Variante", "Faces", "verschiedene Flaechen"))
+
+# --- 1) Rueckwaertskompatibel: Einzelobjekt ------------------------------
+n1, f1 = streuen(None, einzel, 0)
+print("%-26s %7d %d" % ("Einzel-Card", n1, len(f1)))
+if n1 == 0:
+    fails.append("Einzel-Card erzeugt keine Blaetter - Rueckwaertskompatibilitaet weg")
+# Eine Card = zwei unterschiedlich grosse Tris = genau zwei Flaechen.
+if len(f1) > 3:
+    fails.append("Einzel-Card liefert %d verschiedene Flaechen, erwartet <= 3 - "
+                 "die Groessenstreuung ist nicht wirklich aus" % len(f1))
+
+# --- 2) Collection: alle Varianten kommen vor ----------------------------
+n2, f2 = streuen(coll, None, 0)
+print("%-26s %7d %d" % ("Collection (%d Cards)" % len(GROESSEN), n2, len(f2)))
+if n2 == 0:
+    fails.append("Collection erzeugt keine Blaetter")
+# Vier Cards mit je zwei Tris = acht verschiedene Flaechen, wenn wirklich alle
+# vier gezogen werden. Weniger heisst: es kommen nicht alle Varianten vor.
+erwartet = 2 * len(GROESSEN)
+if len(f2) < erwartet:
+    fails.append("Nur %d verschiedene Flaechen, erwartet %d - es werden nicht "
+                 "alle %d Card-Varianten gezogen"
+                 % (len(f2), erwartet, len(GROESSEN)))
+
+# --- 3) Seed-stabil ------------------------------------------------------
+n3, f3 = streuen(coll, None, 0)
+print("%-26s %7d %d" % ("gleicher Seed", n3, len(f3)))
+if (n3, f3) != (n2, f2):
+    fails.append("Gleicher Seed liefert ein anderes Ergebnis - nicht stabil")
+
+n4, f4 = streuen(coll, None, 7)
+print("%-26s %7d %d" % ("anderer Seed", n4, len(f4)))
+if (n4, f4) == (n2, f2):
+    fails.append("Anderer Seed liefert dasselbe Ergebnis - der Seed wirkt nicht")
+
+# --- 4) Collection hat Vorrang vor der Einzel-Card -----------------------
+n5, f5 = streuen(coll, einzel, 0)
+print("%-26s %7d %d" % ("beides gesetzt", n5, len(f5)))
+if len(f5) < erwartet:
+    fails.append("Mit gesetzter Einzel-Card faellt die Collection zurueck - "
+                 "die Sammlung muss Vorrang haben")
+
+print("")
+if fails:
+    print("ERGEBNIS: %d FEHLER" % len(fails))
+    for x in fails:
+        print("  - " + x)
+    sys.exit(1)
+print("ERGEBNIS: ALLE CHECKS OK")