# Blender

## Vom Cursor eine Linie in negativer y-Richtung mit Länge 11.2 mm

```python
import bpy
from mathutils import Vector  # Importiert die Vektor-Klasse für 3D-Berechnungen

# 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

# 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

```python
import bpy
import bmesh


# Holen einer Referenz auf das aktuelle Objekt
mesh_obj = bpy.context.active_object

# Erzeugen eines neuen bmesh-Objektes
bm = bmesh.new()

# Initialisieren des bmesh-Objektes mit den Daten des vorhandenen Objektes
bm.from_mesh(mesh_obj.data)

bmesh.ops.bevel(bm, geom=bm.verts, offset=0.5)


# Schreiben der bmesh-Daten in die mesh-Daten
bm.to_mesh(mesh_obj.data)

# Optional: updaten der mesh-Daten
mesh_obj.data.update()

# freigeben des Speichers der von bmesh genutzt wurde
bm.free()
```

![](/Volumes/Daten02/Projekte/Snippets/Blender1.png)

```python
import bpy
import bmesh


# Holen einer Referenz auf das aktuelle Objekt
mesh_obj = bpy.context.active_object

# Erzeugen eines neuen bmesh-Objektes
bm = bmesh.new()

# Initialisieren des bmesh-Objektes mit den Daten des vorhandenen Objektes
bm.from_mesh(mesh_obj.data)

bmesh.ops.bevel(
                bm, 
                geom=bm.edges,
                offset=0.2,
                segments=4,
                affect="EDGES",
                profile=0.5,
)


# Schreiben der bmesh-Daten in die mesh-Daten
bm.to_mesh(mesh_obj.data)

# Optional: updaten der mesh-Daten
mesh_obj.data.update()

# freigeben des Speichers der von bmesh genutzt wurde
bm.free()
```

![Blender2](/Volumes/Daten02/Projekte/Snippets/Blender2.png)

## Erzeugen eines Objektes von stretch

```
import bpy

obj_name = "my_shape"


# Erzeugen der mesh Daten
mesh_data = bpy.data.meshes.new(f"{obj_name}_data")

# Erzeugen des Mesh-Objektes unter Nutzng der Mesh-Daten 
mesh_obj = bpy.data.objects.new(obj_name, mesh_data)

# Hinzufügen des Mesh-Obektes zur Szene
bpy.context.scene.collection.objects.link(mesh_obj)
```

![](/Volumes/Daten02/Projekte/Snippets/2024-03-25_18-39.png)

https://www.youtube.com/watch?v=N3U2noAHgBo&t=88s

## Farben für Mesh und Vertex

Preferences --> Themes --> 3D View

## Mesh zu Curve

1. in Objektmodus
2. Object --> Convert --> Curve

## Curve neu berechnen z. B. auf 64 Vertices

1. Curve auswählen
2. Add --> Modifier --> Geometry Nodes
3. Anwählen Geometry Nodes
4. Shift A --> Search: Resample
5. Auf 64 Vertices stellen

Spiegeln von Objekten

Markieren und Add Mirror

# Tests

## Trennen eines Meshs

P auf zwei Ringe

Löschen der Edges zwischen den Ringen

## Zusammensetzen

Beide Meshes im Object-Mode auswählen

cmd j 

Beide Meshes markieren, Edge --> Bridge Edge Loops
