Blender Technical Director

BTD/Modul 4: Shading & Rendering Pipelines

Inhalte:

Cycles vs. Eevee: technische Unterschiede
Shader Nodes und Node Groups
Light Linking und Lightpath-Optimierung
Render Layers, Passes, Cryptomatte
On-Farm Rendering und automatisiertes Compositing

Vorlesung 4

Shading & Rendering Pipelines – Technische Material- und Render-Systeme

Diese Vorlesung behandelt Shading und Rendering aus der Perspektive des Pipeline Engineerings. Im Fokus stehen reproduzierbare Materialsysteme, kontrollierte Lichtinteraktion und automatisierbare Render-Setups.

1. Rolle von Shading & Rendering im Pipeline-Kontext

Shading und Rendering sind keine rein künstlerischen Disziplinen. Für Technical Directors stehen folgende Fragen im Mittelpunkt:

Wie lassen sich Materialien standardisieren?
Wie bleiben Render-Ergebnisse reproduzierbar?
Wie werden Render-Setups automatisiert?
Wie lassen sich Renderzeiten und Speicherbedarf optimieren?

Eine saubere Shading- und Render-Pipeline ist Voraussetzung für skalierbare Produktionen.

2. Cycles vs. Eevee – Technische Unterschiede

Cycles

Path Tracing
physikalisch korrekt
höhere Renderzeiten
geeignet für Final-Frames

Eevee

Rasterisierung
approximierte Beleuchtung
sehr schnell
geeignet für Lookdev und Echtzeit

TD-relevante Unterschiede:

unterschiedliche Node-Unterstützung
unterschiedliche Light- und Shadow-Modelle
unterschiedliche Render-Passes
abweichende Limitierungen bei Light Linking

import bpy

scene = bpy.context.scene
scene.render.engine = 'CYCLES'
print("Aktive Engine:", scene.render.engine)

3. Shader Nodes – Technische Grundlagen

Shader in Blender basieren auf Node Trees.

Wichtige Konzepte:

Nodes sind Data Blocks
Verbindungen definieren Datenfluss
Node Groups ermöglichen Wiederverwendung
Parametersteuerung erfolgt über Sockets

import bpy

mat = bpy.data.materials.new("TD_Material")
mat.use_nodes = True
nodes = mat.node_tree.nodes

for node in nodes:
    print(node.name, node.type)

4. Automatisierter Shader-Aufbau (Grundlage Aufgabe 1)

4.1 Leeres Node Tree initialisieren

import bpy

mat = bpy.data.materials.new("AutoShader")
mat.use_nodes = True
nodes = mat.node_tree.nodes
nodes.clear()

4.2 Principled BSDF erzeugen und verbinden

import bpy

nodes = bpy.context.object.active_material.node_tree.nodes
links = bpy.context.object.active_material.node_tree.links

bsdf = nodes.new("ShaderNodeBsdfPrincipled")
output = nodes.new("ShaderNodeOutputMaterial")

links.new(bsdf.outputs["BSDF"], output.inputs["Surface"])

4.3 Texture Image und Mapping hinzufügen

import bpy

nodes = bpy.context.object.active_material.node_tree.nodes
links = bpy.context.object.active_material.node_tree.links

tex = nodes.new("ShaderNodeTexImage")
mapping = nodes.new("ShaderNodeMapping")
texcoord = nodes.new("ShaderNodeTexCoord")

links.new(texcoord.outputs["UV"], mapping.inputs["Vector"])
links.new(mapping.outputs["Vector"], tex.inputs["Vector"])
links.new(tex.outputs["Color"], bsdf.inputs["Base Color"])

5. Parametrisierung von Shadern

TDs sollten Shader steuerbar machen.

bsdf.inputs["Roughness"].default_value = 0.4
bsdf.inputs["Base Color"].default_value = (1.0, 0.2, 0.2, 1.0)
mapping.inputs["Scale"].default_value = (2.0, 2.0, 2.0)

Diese Technik bildet die Grundlage für modulare Materialsysteme.

6. Node Groups für wiederverwendbare Shader-Logik

Node Groups ermöglichen:

Standardisierung
zentrale Wartung
konsistente Lookdev-Ergebnisse

import bpy

group = bpy.data.node_groups.new("TD_BaseShader", 'ShaderNodeTree')
print("Node Group erstellt:", group.name)

7. Lichtsysteme und Light Linking

Light Linking erlaubt die gezielte Zuordnung von Lichtern zu Objekten.

TD-relevante Aspekte:

Kontrolle von Renderzeiten
gezielte Ausleuchtung
Vermeidung unerwünschter Lichtinteraktion

import bpy

light = bpy.context.object
print("Licht:", light.name)

8. Light Linking per Python (Grundlage Aufgabe 2)

import bpy

view_layer = bpy.context.view_layer

light = bpy.data.objects["Light"]
target = bpy.data.objects["Cube"]

view_layer.lightgroups.new(name="KeyLight")
light.lightgroup = "KeyLight"
target.lightgroup = "KeyLight"

Hinweis: Light Linking ist engine-abhängig und muss getestet werden.

9. Render Layers und View Layers

View Layers trennen logische Render-Bereiche.

Typische Layer:

Background
Characters
Effects
Props

import bpy

scene = bpy.context.scene
layer = scene.view_layers.new("Characters")
print("View Layer:", layer.name)

10. Render Passes

Render Passes liefern zusätzliche Bildinformationen.

Wichtige Passes:

Diffuse
Specular
Shadow
Normal
Cryptomatte

layer = bpy.context.scene.view_layers["Characters"]
layer.use_pass_diffuse_color = True
layer.use_pass_specular = True
layer.use_pass_shadow = True

11. Cryptomatte für Compositing

Cryptomatte ermöglicht objektbasierte Maskierung.

TD-relevant:

automatisierte Compositing-Pipelines
konsistente Objekt-IDs
Nachbearbeitung ohne Re-Render

layer.use_pass_cryptomatte_object = True
layer.use_pass_cryptomatte_material = True

12. Automatisiertes Render-Layer Setup (Grundlage Aufgabe 3)

import bpy

scene = bpy.context.scene

layers = ["Background", "Characters", "Effects"]

for name in layers:
    vl = scene.view_layers.new(name)
    vl.use_pass_diffuse_color = True
    vl.use_pass_specular = True
    print("Layer erzeugt:", vl.name)

13. Logging von Render-Informationen

import bpy

for vl in bpy.context.scene.view_layers:
    print("View Layer:", vl.name)
    print("  Diffuse:", vl.use_pass_diffuse_color)
    print("  Specular:", vl.use_pass_specular)
    print("  Shadow:", vl.use_pass_shadow)

Logging ist essenziell für Render-Farms und Debugging.

14. On-Farm Rendering – Pipeline-Sicht

Typische Anforderungen:

headless Blender
konsistente Szeneneinstellungen
automatisierte Übergabe an Compositoren
reproduzierbare Ergebnisse

Python bildet die zentrale Steuerungsebene zwischen DCC und Farm.

15. Verbindung zu den Übungen

Die Übungen dieses Moduls basieren direkt auf den vorgestellten Konzepten:

automatisierter Shader-Aufbau
gezielte Lichtzuordnung
systematisches Render-Layer- und Pass-Setup

Die Aufgaben finden Sie unter Modul 4 – Übungen.

Modul4