Recent Changes - Search:

Blender Technical Director?

pmwiki.org

edit SideBar

BTD /

Modul2

BTD/Modul 2: Python-Tools, Automatisierung, Add-ons

Inhalte:

  • Aufbau der Blender Python-API
  • Automatisierte Asset-Erzeugung
  • Custom Operators, Panels, Hotkeys
  • Batch Processing und Rendering-Automation
  • Add-on-Entwicklung

Vorlesung 2

Python-Tools, Automatisierung und Add-ons in Blender

Diese Vorlesung führt systematisch in die praktische Nutzung der Blender Python-API ein. Der Schwerpunkt liegt auf Automatisierung, Tool-Entwicklung und der sauberen Strukturierung von Code für Produktionsumgebungen.

1. Rolle von Python in Blender-Pipelines

Python ist die zentrale Schnittstelle für technische Erweiterungen in Blender. Nahezu alle internen Funktionen sind über die Python-API zugänglich.

Typische Einsatzgebiete von Python in Blender:

  • Automatisierung repetitiver Aufgaben
  • Analyse und Validierung von Szenen
  • Tool- und Add-on-Entwicklung
  • Pipeline-Integration
  • Batch Processing (Import, Export, Rendering)

Für Technical Directors ist Python kein optionales Werkzeug, sondern ein Kernbestandteil der täglichen Arbeit.

2. Grundstruktur der Blender Python-API

Der Zugriff auf Blender erfolgt über das Modul bpy.

Zentrale Namensräume:

  • bpy.data Zugriff auf alle Data Blocks (Meshes, Objects, Materials, Images, …)
  • bpy.context Aktueller Kontext (aktive Szene, ausgewählte Objekte, Modus)
  • bpy.ops Operatoren für Aktionen (z. B. Transform, Import, Render)
  • bpy.types Definition von Klassen (Operatoren, Panels, PropertyGroups)

Ein zentrales Prinzip ist die Trennung von:

  • Daten (Data Blocks)
  • Kontext (aktueller Zustand der Benutzeroberfläche)
  • Aktionen (Operatoren)

3. Automatisierte Asset-Erzeugung

Ein häufiger Anwendungsfall ist die automatisierte Erzeugung von Assets.

Typische Schritte:

  • Erzeugen eines Data Blocks (z. B. Mesh)
  • Erzeugen eines Objects, das auf diesen Data Block verweist
  • Platzierung und Konfiguration des Objekts
  • Zuweisung von Materialien
  • Organisation in Collections

Wichtige Aspekte für TDs:

  • saubere Benennung
  • reproduzierbare Ergebnisse
  • parametrisierbare Werte
  • klare Trennung von Daten und Logik

Diese Konzepte bilden die Grundlage für die erste Übung dieses Moduls.

4. Custom Operators

Custom Operators sind die Basis interaktiver Tools in Blender.

Eigenschaften eines Operators:

  • kapselt eine Aktion
  • kann Undo unterstützen
  • kann Parameter besitzen
  • kann über UI, Hotkeys oder Skripte aufgerufen werden

Ein Operator besteht typischerweise aus:

  • Klassen-Definition
  • Properties (Parameter)
  • execute-Methode
  • optional: invoke-Methode

Für Technical Directors sind Operatoren essenziell, um Tools für Artists zugänglich zu machen.

5. Panels und Benutzeroberflächen

Panels ermöglichen es, Operatoren und Parameter in die Benutzeroberfläche zu integrieren.

Wichtige Aspekte beim UI-Design:

  • klare Gruppierung von Funktionen
  • sinnvolle Default-Werte
  • minimale, aber informative Interfaces
  • Konsistenz mit Blender-UI-Konventionen

Ein Panel:

  • referenziert Operatoren
  • zeigt Properties an
  • verbindet technische Logik mit künstlerischer Nutzung

In der zweiten Übung dieses Moduls werden Operator und Panel kombiniert.

6. Hotkeys und Tool-Zugänglichkeit

Für produktive Workflows ist die Zugänglichkeit von Tools entscheidend.

Möglichkeiten:

  • Buttons in Panels
  • Einträge in Menüs
  • Tastenkombinationen (Hotkeys)
  • Kontextabhängige Operatoren

TDs müssen dabei abwägen:

  • Häufigkeit der Nutzung
  • Risiko unbeabsichtigter Aktionen
  • Lernaufwand für Artists

7. Batch Processing und Automatisierung

Batch Processing ist ein zentraler Bestandteil technischer Workflows.

Typische Anwendungsfälle:

  • Import vieler Assets
  • Konvertierung von Dateiformaten
  • automatisiertes Rendering
  • Massenänderungen an Szenen

Beim Rendering bedeutet dies:

  • Iteration über Szenen
  • Setzen von Output-Pfaden
  • Starten von Renderprozessen
  • Logging von Status und Laufzeiten

Diese Konzepte werden in der dritten Übung praktisch umgesetzt.

8. Einführung in die Add-on-Entwicklung

Ein Add-on ist eine strukturierte Sammlung von:

  • Operatoren
  • Panels
  • Properties
  • Registrierungslogik

Grundprinzipien:

  • saubere Modulstruktur
  • klare Trennung von UI und Logik
  • einfache Installation und Aktualisierung
  • Wartbarkeit des Codes

In diesem Modul wird noch kein vollständiges Add-on umgesetzt, aber alle technischen Grundlagen dafür gelegt.

9. Verbindung zu den Übungen

Die Übungen zu dieser Vorlesung vertiefen:

  • automatisierte Asset-Erzeugung
  • Entwicklung interaktiver Tools
  • Batch Rendering und Logging

Die Aufgaben finden Sie unter Modul 2 – Übungen.

Vorlesung 2

Python-Tools, Automatisierung und Add-ons in Blender

Diese Vorlesung demonstriert anhand vieler isolierter Code-Beispiele, wie Blender technisch erweitert und automatisiert werden kann. Alle Snippets sind eigenständig ausführbar und dienen als Grundlage für Übungen, Experimente und spätere Tool-Entwicklung.

1. Zugriff auf Blender über bpy

Das zentrale Einstiegspunkt-Modul ist bpy. 

import bpy

print("Aktive Szene:", bpy.context.scene.name)
print("Anzahl Objekte:", len(bpy.context.scene.objects))

Wichtiger Unterschied:

  • bpy.data → globale Daten
  • bpy.context → aktueller UI- und Auswahlzustand

2. Arbeiten mit Data Blocks

  1. 2.1 Alle Objekte einer Szene auflisten 
import bpy

for obj in bpy.data.objects:
    print(obj.name, obj.type)
  1. 2.2 Ungenutzte Data Blocks erkennen 
import bpy

for mesh in bpy.data.meshes:
    if mesh.users == 0:
        print("Ungenutztes Mesh:", mesh.name)

Dieses Prinzip ist zentral für technische Qualitätssicherung.

3. Automatisierte Asset-Erzeugung

  1. 3.1 Einfaches parametrisches Objekt erzeugen 
import bpy

size = 2.0

bpy.ops.mesh.primitive_cube_add(size=size)
obj = bpy.context.active_object
obj.name = "AutoCube"
  1. 3.2 Objekt in neue Collection einsortieren 
import bpy

collection = bpy.data.collections.new("AutoAssets")
bpy.context.scene.collection.children.link(collection)

obj = bpy.context.active_object
collection.objects.link(obj)
bpy.context.scene.collection.objects.unlink(obj)

4. Materialien automatisiert zuweisen

import bpy

mat = bpy.data.materials.new(name="AutoMaterial")
mat.use_nodes = True

obj = bpy.context.active_object
obj.data.materials.append(mat)

Typischer TD-Anwendungsfall: standardisierte Materialien für große Asset-Mengen.

5. Custom Operator – Grundstruktur

  1. 5.1 Minimaler Operator 
import bpy

class SimpleOperator(bpy.types.Operator):
    bl_idname = "object.simple_operator"
    bl_label = "Simple Operator"

    def execute(self, context):
        print("Operator ausgeführt")
        return {'FINISHED'}

bpy.utils.register_class(SimpleOperator)

Der Operator ist nun über die Python-Konsole oder Suche verfügbar.

6. Operator mit Parametern (Properties)

import bpy

class MoveXOperator(bpy.types.Operator):
    bl_idname = "object.move_x_operator"
    bl_label = "Move X Operator"

    distance: bpy.props.FloatProperty(name="Distance", default=1.0)

    def execute(self, context):
        for obj in context.selected_objects:
            obj.location.x += self.distance
        return {'FINISHED'}

bpy.utils.register_class(MoveXOperator)

Dies bildet die Grundlage für interaktive Tools.

7. Undo-Unterstützung

import bpy

class UndoOperator(bpy.types.Operator):
    bl_idname = "object.undo_operator"
    bl_label = "Undo Operator"
    bl_options = {'UNDO'}

    def execute(self, context):
        for obj in context.selected_objects:
            obj.location.z += 1.0
        return {'FINISHED'}

bpy.utils.register_class(UndoOperator)

Undo-Unterstützung ist essenziell für produktionsreife Tools.

8. Panels – Operatoren sichtbar machen

import bpy

class SimplePanel(bpy.types.Panel):
    bl_label = "TD Tools"
    bl_idname = "VIEW3D_PT_td_tools"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'UI'
    bl_category = 'TD'

    def draw(self, context):
        layout = self.layout
        layout.operator("object.simple_operator")

bpy.utils.register_class(SimplePanel)

Panels verbinden technische Logik mit künstlerischer Nutzung.

9. Operator + Panel mit Parametern

import bpy

class MovePanel(bpy.types.Panel):
    bl_label = "Move Tools"
    bl_idname = "VIEW3D_PT_move_tools"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'UI'
    bl_category = 'TD'

    def draw(self, context):
        layout = self.layout
        layout.operator("object.move_x_operator")

bpy.utils.register_class(MovePanel)

10. Hotkeys für Operatoren

import bpy

addon_keymaps = []

wm = bpy.context.window_manager
km = wm.keyconfigs.addon.keymaps.new(name='Object Mode')
kmi = km.keymap_items.new("object.simple_operator", 'Q', 'PRESS')

addon_keymaps.append((km, kmi))

Hotkeys erhöhen Produktivität, müssen aber sorgfältig gewählt werden.

11. Batch Processing – Szenen iterieren

import bpy

for scene in bpy.data.scenes:
    print("Szene:", scene.name)

12. Batch Rendering mehrerer Szenen

import bpy
import os
import time

base_path = "//renders/"

for scene in bpy.data.scenes:
    bpy.context.window.scene = scene
    scene.render.filepath = os.path.join(base_path, scene.name + "_")

    start = time.time()
    bpy.ops.render.render(write_still=True)
    duration = time.time() - start

    print(scene.name, "Renderzeit:", duration)

Dieses Muster ist Grundlage für Render-Automation und Farm-Integration.

13. Einfaches Logging

import bpy
from datetime import datetime

log = []

for obj in bpy.data.objects:
    log.append(f"{datetime.now()} | {obj.name} | {obj.type}")

for line in log:
    print(line)

Logging ist zentral für Debugging und Nachvollziehbarkeit.

14. Grundstruktur eines Add-ons

bl_info = {
    "name": "BTD Example Addon",
    "author": "Technical Direction",
    "version": (1, 0),
    "blender": (3, 0, 0),
    "category": "Object"
}

import bpy

classes = []

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

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

Diese Struktur bildet die Basis für alle produktionsreifen Add-ons.

15. Verbindung zu den Übungen

Alle gezeigten Code-Snippets sind bewusst so gestaltet, dass sie:

  • isoliert getestet werden können
  • direkt erweitert werden können
  • exakt auf die Übungen in Modul 2 vorbereiten

Die zugehörigen Aufgaben finden Sie unter Modul 2 – Übungen.

Edit - History - Print - Recent Changes - Search
Page last modified on December 14, 2025, at 11:44 PM UTC