SQL User und Blender Linie erweitert

Blender.md

@@ -4,27 +4,95 @@
 
 ```python
 import bpy
-from mathutils import Vector
+from mathutils import Vector  # Importiert die Vektor-Klasse für 3D-Berechnungen
 
-# Definiere die Länge der Linie
-line_length = -1.12  # 11.2 mm
- 
-# Hole die 3D-Cursor-Position
+# 1. Definition der Länge
+# Da Blender standardmäßig in Metern rechnet, entsprechen -1.12 Einheiten 
+# im Normalfall -1.12 Metern (oder eben 11.2 mm, wenn die Szenen-Skalierung angepasst wurde).
+line_length = -1.12  
+
+# 2. Startpunkt festlegen
+# Greift auf die aktuelle Position des 3D-Cursors im Viewport zu.
+# Das ist ein praktischer Weg, um Objekte dort entstehen zu lassen, wo man gerade hingeklickt hat.
 cursor_position = bpy.context.scene.cursor.location
 
-# Berechne die Endposition der Linie
+# 3. Endpunkt berechnen
+# Hier wird die Vektor-Mathematik genutzt:
+# Wir addieren zur Cursor-Position einen neuen Vektor.
+# Da nur der X-Wert mit 'line_length' belegt ist, wird die Linie 
+# exakt entlang der (lokalen) X-Achse gezeichnet.
+# Das Ergebnis ist ein neuer Punkt, der 1.12 Einheiten links vom Cursor liegt.
 end_position = cursor_position + Vector((line_length, 0, 0))
 
+
 # Erstelle eine neue Linie
+# 1. Definition der Geometrie-Daten
+# 'vertices' ist eine Liste mit zwei 3D-Vektoren (X, Y, Z). 
+# Sie markieren den Start- und Endpunkt der Linie.
 vertices = [cursor_position, end_position]
+
+# 'edges' definiert die Verbindung. (0, 1) bedeutet: 
+# Verbinde den ersten Punkt (Index 0) mit dem zweiten Punkt (Index 1).
 edges = [(0, 1)]
+
+# 2. Erstellen der Mesh-Datenstruktur
+# Hier wird ein neuer, leerer Datensatz für ein Mesh im Speicher angelegt.
 mesh = bpy.data.meshes.new(name="LineMesh")
+
+# 3. Erstellen des Objekts
+# Ein Mesh allein ist noch nicht im 3D-Raum sichtbar. 
+# Wir brauchen ein 'Object', das als Container für das Mesh dient.
 line_obj = bpy.data.objects.new(name="LineObject", object_data=mesh)
+
+# 4. Objekt in die Szene einfügen
+# Das Objekt wird der aktuellen Collection (Sammlung) hinzugefügt, 
+# damit es im Outliner und im Viewport erscheint.
 bpy.context.collection.objects.link(line_obj)
+
+# 5. Daten in das Mesh füllen
+# Die vorab definierten Punkte und Kanten werden nun in das Mesh-Datenobjekt geschrieben.
+# Die leere Liste [] am Ende steht für 'faces' (Flächen), die wir hier nicht brauchen.
+mesh.from_pydata(vertices, edges, [])
+
+# 6. Mesh aktualisieren
+# Berechnet interne Strukturen neu (z. B. Normalen), um sicherzustellen, 
+# dass das Mesh korrekt dargestellt wird.
+mesh.update()
+```
+
+Die Linie erweitern, also im rechten Winkel an die voirhandene Linie ansetzen
+
+```python
+# 1. Berechne den dritten Punkt
+# Wir starten bei der 'end_position' und gehen um die gleiche Länge 
+# in die Y-Richtung (statt X-Richtung).
+next_position = end_position + Vector((0, line_length, 0))
+
+# 2. Aktualisiere die Punkt-Liste
+# Wir haben jetzt drei Punkte: Start, Knick, Ende.
+vertices = [cursor_position, end_position, next_position]
+
+# 3. Definiere die Kanten (Edges)
+# Kante 1: Von Punkt 0 zu Punkt 1
+# Kante 2: Von Punkt 1 zu Punkt 2
+edges = [(0, 1), (1, 2)]
+
+# 4. Mesh-Erstellung (wie gehabt)
+mesh = bpy.data.meshes.new(name="AngleMesh")
+line_obj = bpy.data.objects.new(name="AngleObject", object_data=mesh)
+bpy.context.collection.objects.link(line_obj)
+
+# Daten füllen
 mesh.from_pydata(vertices, edges, [])
 mesh.update()
 ```
 
+**Abknicken auf der Ebene (Y-Achse):** `Vector((0, line_length, 0))`
+
+**Abknicken nach oben/unten (Z-Achse):** `Vector((0, 0, line_length))`
+
+
+
 ## Ein bestehendes Objekt mittel bmesh verändern
 
 https://www.youtube.com/watch?v=TFQMNcTj5Jw