185 lines
5.1 KiB
Markdown
185 lines
5.1 KiB
Markdown
# 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()
|
|
```
|
|
|
|
|
|
|
|
```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()
|
|
```
|
|
|
|
|
|
|
|
## 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)
|
|
```
|
|
|
|
|
|
|
|
https://www.youtube.com/watch?v=N3U2noAHgBo&t=88s |