Python Scripting in Blender – Automatisierung und Add-on-Entwicklung

Python Scripting in Blender nutzt Blenders vollständig zugängliche Python-API (bpy), die es ermöglicht, sämtliche Blender-Funktionen zu automatisieren, eigene Operatoren und Panels zu erstellen, prozedurale 3D-Inhalte programmatisch zu generieren und komplexe Workflows als Add-ons zu paketieren.

Rubrik: Software & Tools Deep-Dive · Unterrubrik: Blender · Niveau: Fortgeschritten Blender-Version: ab 2.5x Python-API stabilisiert, API-Updates mit jeder Blender-Version (breaking changes selten, aber möglich)

Was ist Python Scripting in Blender?

Blender integriert einen vollständigen CPython-Interpreter direkt in die Anwendung. Die gesamte Blender-Funktionalität – von der Objekterstellung über Materialbearbeitung bis zum Rendering – ist über die Python-Bibliothek `bpy` (Blender Python) zugänglich und skriptbar.

Das bedeutet:

• Jede manuelle Aktion in Blender kann per Python automatisiert werden
• Eigene Werkzeuge und Panels können direkt in Blenders Interface integriert werden
• Prozedurale Objekte, Materialien und Animationen können programmatisch erzeugt werden
• Komplexe Batch-Prozesse (100 Dateien rendern, Assets exportieren) werden automatisierbar

Blenders Python-Integration umfasst:

• Interaktive Python Console direkt in Blender
• Text Editor für Script-Entwicklung
• Info Log der alle GUI-Operationen als Python-Code anzeigt

Erklärung & Parameter

Python Console und Text Editor

Python Console aufrufen: Editortyp → Python Console. Hier können Python-Befehle interaktiv eingegeben und sofort ausgeführt werden. Tab-Vervollständigung ist vollständig unterstützt.

Text Editor aufrufen: Editortyp → Text Editor. Hier werden Scripts als Textdateien gespeichert und ausgeführt. Alt + P → Script ausführen.

Info Editor: Zeigt alle Blender-Operationen als Python-Code. Wenn eine Aktion in der GUI durchgeführt wird (z. B. Würfel hinzufügen), erscheint der entsprechende Python-Befehl im Info Log → ideale Quelle um die richtige API-Funktion zu finden.

Die bpy-Bibliothek

Das zentrale Modul für alle Blender-Operationen:

``python import bpy ``

#### bpy.data – Datenzugriff

Direkter Zugriff auf alle Blender-Datenblöcke:

``python bpy.data.objects # Alle Objekte in der Szene bpy.data.meshes # Alle Meshes bpy.data.materials # Alle Materialien bpy.data.images # Alle Bilder/Texturen bpy.data.collections # Alle Collections bpy.data.actions # Alle Animationsactions bpy.data.armatures # Alle Armatures bpy.data.cameras # Alle Kameras bpy.data.lights # Alle Lichter bpy.data.node_groups # Alle Node Groups (Shader, Geometry Nodes) bpy.data.scenes # Alle Scenes bpy.data.texts # Alle Text-Datenblöcke ``

Beispiel: Alle Objekte auflisten: ``python for obj in bpy.data.objects: print(obj.name, obj.type) ``

#### bpy.context – Aktueller Kontext

Zugriff auf aktiv selektierte Objekte und den aktuellen Zustand:

``python bpy.context.active_object # Aktiv ausgewähltes Objekt bpy.context.selected_objects # Alle ausgewählten Objekte bpy.context.scene # Aktuelle Szene bpy.context.view_layer # Aktueller View Layer bpy.context.mode # Aktueller Modus (OBJECT, EDIT, etc.) bpy.context.area # Aktueller Editor-Bereich bpy.context.space_data # Daten des aktuellen Editors ``

#### bpy.ops – Operatoren

Ausführen von Blender-Operationen (wie Menüpunkte oder Shortcuts per Code):

``python bpy.ops.object.select_all(action='DESELECT') # Alles deselektieren bpy.ops.mesh.primitive_cube_add(size=2, location=(0, 0, 0)) # Würfel hinzufügen bpy.ops.object.delete() # Ausgewählte Objekte löschen bpy.ops.render.render(write_still=True) # Einzelframe rendern bpy.ops.export_scene.gltf(filepath="/tmp/out.glb") # GLTF exportieren bpy.ops.object.mode_set(mode='EDIT') # Edit Mode wechseln ``

Wichtig: Viele Operatoren benötigen den richtigen Kontext. Der override-Parameter erlaubt Kontext-Manipulation: ``python bpy.ops.object.editmode_toggle({'active_object': obj}) ``

#### bpy.types – Typen-Definitionen

Basis für eigene Klassen (Panels, Operatoren, Add-ons).

Mathematik-Bibliotheken

Blender stellt mathutils bereit: ```python from mathutils import Vector, Matrix, Euler, Quaternion

v = Vector((1, 0, 0)) m = Matrix.Rotation(1.5708, 4, 'Z') # 90° Rotation um Z-Achse ```

Eigene Operatoren erstellen

```python import bpy

class MYOThelloworld(bpy.types.Operator): blidname = "object.helloworld" bllabel = "Hello World" bldescription = "Gibt Hello World in der Console aus" bloptions = {'REGISTER', 'UNDO'}

def execute(self, context): print("Hello World!") return {'FINISHED'}

def register(): bpy.utils.registerclass(MYOThelloworld)

def unregister(): bpy.utils.unregisterclass(MYOThelloworld)

if name == "main": register() bpy.ops.object.hello_world() ```

Naming Convention: CATEGORY_OT_operatorname (OT = Operator Type, PT = Panel Type, MT = Menu Type etc.)

Eigene Panels erstellen

```python class MYPTcustompanel(bpy.types.Panel): bllabel = "My Custom Panel" blidname = "MYPTcustompanel" blspacetype = 'VIEW3D' blregiontype = 'UI' blcategory = 'Custom'

def draw(self, context): layout = self.layout layout.label(text="Hallo aus meinem Panel!") layout.operator("object.helloworld") layout.prop(context.activeobject, "name") ```

Add-on Struktur

Ein Blender Add-on ist ein Python-Modul (einzelne .py-Datei oder Ordner):

```python bl_info = { "name": "My Add-on", "author": "Autor Name", "version": (1, 0, 0), "blender": (4, 0, 0), "location": "View3D > Sidebar > My Tab", "description": "Beschreibung des Add-ons", "category": "Object", }

import bpy

classes = [MYOThelloworld, MYPTcustompanel]

def register(): for cls in classes: bpy.utils.register_class(cls)

def unregister(): for cls in classes: bpy.utils.unregister_class(cls) ```

Installieren: Edit → Preferences → Add-ons → Install → .py-Datei auswählen.

Beispiele (5 konkrete Anwendungsfälle)

1. Batch-Export: Script exportiert alle Objekte der Szene als separate FBX-Dateien mit korrekten Namen:

``python import bpy, os export_dir = "/tmp/exports/" for obj in bpy.data.objects: if obj.type == 'MESH': bpy.ops.object.select_all(action='DESELECT') obj.select_set(True) bpy.context.view_layer.objects.active = obj filepath = os.path.join(export_dir, obj.name + ".fbx") bpy.ops.export_scene.fbx(filepath=filepath, use_selection=True) ``

1. Prozedurale Stadtgenerierung: Loops über ein Grid, zufällige Quader-Höhen, automatische Material-Zuweisung → ganze Stadtblöcke in Sekunden.
2. Render Farm Automation: Script iteriert über mehrere .blend-Dateien, öffnet jede, rendert, speichert Ergebnis – alles über die Command Line mit blender --background --python myscript.py.
3. Custom Shader-Tool: Panel im Shader Editor das vordefinierte PBR-Material-Setups (Metall, Glas, Haut) auf Knopfdruck erstellt und anwendet.
4. Animation Baking: Script baked alle animierten Transformationen zu expliziten Keyframes (für Game Engine Export) mit bpy.ops.nla.bake().

Schritt-für-Schritt: Erstes Script ausführen

1. Editortyp auf Text Editor setzen
2. New → Neues leeres Script erstellen
3. Script eingeben:

```python import bpy

bpy.ops.mesh.primitivecubeadd(location=(0, 0, 2))

obj = bpy.context.activeobject obj.name = "MeinWürfel"

mat = bpy.data.materials.new(name="RotesMaterial") mat.usenodes = True mat.nodetree.nodes["Principled BSDF"].inputs["Base Color"].defaultvalue = (1, 0, 0, 1) obj.data.materials.append(mat)

print(f"Objekt '{obj.name}' erstellt!") ```

1. Alt + P → Script ausführen
2. Im 3D Viewport erscheint ein roter Würfel bei Z=2

In der Praxis

Info Log als Lernhilfe nutzen:

• Editortyp → Info
• Eine GUI-Aktion durchführen (z. B. Würfel hinzufügen)
• Im Info Log erscheint der entsprechende Python-Code
• Code kopieren und im Text Editor als Ausgangspunkt verwenden

Auto-Completion in der Python Console: bpy.data.objects['Cube']. + Tab → vollständige Liste aller verfügbaren Properties und Methoden.

Blender im Hintergrundmodus (CLI): ``bash blender --background myscene.blend --python myscript.py `` Für Render-Automatisierung ohne GUI – ideal für Render-Farms und CI/CD-Pipelines.

Nützliche Shortcuts im Text Editor:

• Alt + P → Script ausführen
• Strg + Space → Auto-Complete (wenn aktiviert)
• Strg + F → Suchen/Ersetzen
• Strg + Z → Undo

Häufige API-Fallstricke:

• Operatoren brauchen korrekten Kontext → oft Fehler wenn active_object None ist
• bpy.data und bpy.ops haben unterschiedliche Interfaces: bpy.data ist direkter Datenzugriff, bpy.ops führt Operatoren aus (mit Undo-History)
• Nach Blender-Updates: bl_info["blender"] Versionsnummer aktualisieren

Vergleich & Abgrenzung

Häufige Fragen (FAQ)

F: Wo finde ich die vollständige Blender Python API-Dokumentation? A: Offizielle API-Dokumentation: https://docs.blender.org/api/current/ – generiert direkt aus dem Blender-Quellcode, immer versionsspezifisch. Tipp: Die Versionsnummer in der URL anpassen (z. B. /4.2/ statt /current/) für ältere Blender-Versionen. In Blender selbst: Rechtsklick auf jedes UI-Element → „Copy Python Command" oder „Online Python Reference" für direkten Link.

F: Wie kann ich Python-Bibliotheken von außen (z. B. NumPy, Pillow) in Blender nutzen? A: Blender bringt ein eigenes Python-Environment mit. Externe Bibliotheken können über den eingebauten pip installiert werden: ``python import subprocess, sys subprocess.call([sys.executable, "-m", "pip", "install", "pillow"]) `` Oder über die Kommandozeile: Blenders Python-Executable direkt nutzen. NumPy ist seit Blender 2.8x standardmäßig enthalten.

Verwandte Einträge

• Blender Interface – Überblick und Navigation
• Geometry Nodes – prozedurale Geometrie
• Video Sequence Editor (VSE) in Blender

Weiterführend

• Blender Python API Documentation –
• Blender Manual: Scripting & Extending –
• Blender Artists: Python Support –
• Blender Development Blog:
• CG Cookie: Blender Python for Beginners –