SceneKit: Was es ist, 3D-Szenen und Szenengraph

Was ist SceneKit?

SceneKit ist ein Framework für 3D-Grafiken, das Teil des Apple SDK ist und in iOS 8 (2014) eingeführt wurde. SceneKit bietet eine vollständig szenenbasierte API, die auf Metal und OpenGL aufsetzt, um interaktive 3D-Szenen zu erstellen. Das Framework unterstützt den Import von Modellen in den Formaten Collada (DAE), Alembic (ABC), USD und GLTF über Model I/O.

Im Gegensatz zu Low-Level-APIs (Metal, Vulkan) übernimmt SceneKit die Verwaltung von Rendering, Beleuchtung und Physik. Der Entwickler beschreibt die Szene deklarativ: fügt Knoten hinzu, legt Materialien und Animationen fest. SceneKit optimiert automatisch die Geometrie, fasst Draw Calls zusammen und verwaltet LOD bei Bedarf.

SceneKit kann zusammen mit ARKit zur Darstellung von 3D-Objekten in der realen Welt sowie mit Core ML für maschinelles Sehen und Szenenanalyse arbeiten. Laut Apple (2025) verwendet die neueste Version von SceneKit ausschließlich die Metal-API mit Unterstützung für Metal 3 und GPU Family 9 auf Apple Silicon-Chips.

Geschichte von SceneKit

SceneKit erschien 2012 auf macOS als Teil von OS X Mountain Lion und verwendete zunächst OpenGL für das Rendering. Mit der Veröffentlichung von iOS 8 wurde das Framework auf mobilen Geräten verfügbar. SceneKit 2.0 (iOS 10) fügte Unterstützung für PBR-Materialien, HDR-Beleuchtung und Integration mit Model I/O für den Modellimport hinzu.

In iOS 12 wechselte SceneKit vollständig zu Metal. iOS 15 führte Unterstützung für das USDZ-Format und AR Quick Look ein. Mit iOS 18 (2024) erhielt SceneKit hardwarebeschleunigtes Ray Tracing auf Geräten mit A17 Pro- und M4-Chip, was realistische Schatten und Reflexionen in Echtzeit auf mobilen Geräten ermöglicht.

SceneKit-Architektur: Szenengraph und Knoten

Die SceneKit-Architektur basiert auf einem Szenengraphen, wobei SCNScene das Wurzelelement ist, das eine Hierarchie von SCNNode enthält. Jeder Knoten hat Kindknoten und kann Geometrie, eine Kamera, ein Licht oder einen Physikkörper enthalten. Die Knotenposition wird über SCNVector3 (x, y, z) in einem linkshändigen Koordinatensystem festgelegt.

SCNScene — Root-Container

SCNScene enthält den gesamten Zustand der 3D-Welt: den rootNode, Hintergrundeinstellungen, Lichtquellen und die Physikwelt (SCNPhysicsWorld). Die Szene kann aus einer .scn-Datei (SceneKit Scene Format) geladen oder programmatisch erstellt werden. Das .scn-Format ist offen und JSON-basiert.

import SceneKit
 
let scene = SCNScene()
scene.background.contents = UIColor.darkGray
 
// Erstellung einer Kamera
let cameraNode = SCNNode()
cameraNode.camera = SCNCamera()
cameraNode.position = SCNVector3(0, 5, 10)
scene.rootNode.addChildNode(cameraNode)
 
// Erstellung eines Würfels mit Physik
let box = SCNBox(width: 2, height: 2, length: 2, chamferRadius: 0)
let boxNode = SCNNode(geometry: box)
boxNode.physicsBody = SCNPhysicsBody(type: SCNPhysicsBodyType.dynamic,
    shape: SCNPhysicsShape(geometry: box))
scene.rootNode.addChildNode(boxNode)

Die SCNCamera-Klasse konfiguriert die Perspektiv- oder Orthogonalprojektion. Parameter: fieldOfView (Sichtfeld, Standard 45°), zNear/zFar (nahe/ferne Clipping-Ebene). SceneKit verwaltet die Projektionsmatrix automatisch basierend auf diesen Parametern und dem Seitenverhältnis des Bildschirms.

SCNNode — Szenenknoten

SCNNode verbindet Geometrie, Transformation und Physikkörper. Knoten können leer sein (Container für andere Knoten) oder Geometrie über die geometry-Eigenschaft enthalten. Jeder Knoten hat einen Namen (name) für die programmatische Suche und kann über CAAnimation oder vordefinierte SCNTransaction animiert werden.

Die Knotentransformation wird über die Eigenschaften position (SCNVector3), rotation (SCNVector4) und scale (SCNVector3) festgelegt. Für komplexe Transformationen wird die transform-Eigenschaft (SCNMatrix4) verwendet. Ebenfalls verfügbar sind pivot — Versatz des Transformationszentrums, und worldPosition — absolute Position im Weltraum unabhängig von der Hierarchie.

SCNView — Rendering

SCNView ist ein UIView zur Anzeige von SCNScene. Die Eigenschaft allowsCameraControl ermöglicht die Kamerasteuerung durch Gesten (Schwenken, Drehen, Zoomen). Zum Debuggen stehen showsStatistics (FPS, Draw Calls, Polygone) und debugOptions (Drahtgitter, Bounding Boxes) zur Verfügung.

In SwiftUI wird SceneKit über SceneView eingebettet, das SCNView umschließt und Bindungen an Szenenparameter unterstützt. Laut Apple (2025) verwendet SceneView denselben Metal-Renderer wie SCNView, ohne zusätzlichen Overhead für die Brücke zwischen SwiftUI und UIKit.

Materialien, Beleuchtung und Physik in SceneKit

SCNMaterial definiert, wie die Oberfläche der Geometrie mit Licht interagiert. SceneKit unterstützt PBR (Physically Based Rendering) über SCNMaterial.LightingModel.physicallyBased, das die Parameter roughness, metalness, albedo und normal verwendet. PBR-Materialien sehen unter jeder Beleuchtung realistisch aus, ohne manuelle Anpassung der Glanzlichter.

SCNMaterial und Texturen

SCNMaterial hat mehrere Slots: diffuse (Farbe/Textur), specular (Spiegelglanz), normal (Normalenmap), emission (Glühen), roughness (Rauheit) und metalness (Metallizität). Jeder Slot kann ein UIColor, UIImage, CALayer oder SKScene für animierte Texturen enthalten.

// PBR-Material für ein 3D-Objekt
let sphere = SCNSphere(radius: 1.5)
let material = SCNMaterial()
material.lightingModel = SCNMaterial.LightingModel.physicallyBased
material.diffuse.contents = UIColor.orange
material.roughness.contents = 0.3
material.metalness.contents = 0.8
sphere.materials = [material]
 
let sphereNode = SCNNode(geometry: sphere)
sphereNode.position = SCNVector3(0, 2, -5)

Der Parameter roughness 0.3 mit metalness 0.8 erzeugt ein Material, das poliertem Metall mit matter Oberfläche ähnelt. Für Dielektrika (Holz, Kunststoff) wird metalness auf 0 gesetzt, für Metalle nahe 1.0. PBR-Materialien passen sich automatisch an die HDR-Beleuchtung der Szene an.

Beleuchtung in SceneKit

SCNLight unterstützt mehrere Arten von Lichtquellen: omni (punktuell), directional (gerichtet), spot (Scheinwerfer), ambient (Umgebungslicht) und area (Flächenlicht). Jede Quelle hat Intensität, Farbe und kann Schatten werfen (castsShadow). SceneKit verwaltet Schatten automatisch über Shadow Maps.

SceneKit unterstützt HDR-Beleuchtung mit Tonkompression (Tone Mapping). Die Eigenschaft wantsHDR auf SCNView aktiviert den erweiterten Dynamikbereich. Kameraattribute: whitePoint, adaptativeLuminance und exposure passen das Bild an die Szenenhelligkeit an und erzeugen einen fotografischen Belichtungseffekt.

SCNPhysicsBody-Physik

SCNPhysicsBody simuliert Starrkörperphysik: Schwerkraft, Kollisionen und Reibung. Körpertypen: .static (unbeweglich), .dynamic (unter Krafteinwirkung) und .kinematic (programmatisch gesteuert). Die Körperform wird über SCNPhysicsShape definiert, die auf der Knotengeometrie oder einer vereinfachten Form (Box, Sphere, Concave Polyhedron) basieren kann.

SCNPhysicsWorld verwaltet die globale Szenenphysik: Schwerkraft, Simulationsgeschwindigkeit und Kollisionserkennung über den SCNPhysicsContactDelegate. SceneKit unterstützt physikalische Gelenke (SCNPhysicsHingeJoint, SCNPhysicsBallJoint, SCNPhysicsSliderJoint) zur Erstellung von Mechanismen und verbundenen Objekten.

Entwicklung von 3D-Szenen mit SceneKit

Die Entwicklung mit SceneKit beginnt typischerweise mit dem Laden eines 3D-Modells über Model I/O oder eine .scn-Datei. Der Szeneneditor in Xcode (Scene Editor) ermöglicht das visuelle Platzieren von Objekten, Konfigurieren von Materialien und Beleuchtung ohne Code. .scn-Dateien werden im JSON-Format gespeichert und unterstützen Versionskontrolle über git.

Import von 3D-Modellen

Model I/O (ModelIO.framework) ist ein leistungsstarkes Werkzeug zum Importieren, Exportieren und Verarbeiten von 3D-Modellen. SceneKit kann MDLAsset-Objekte direkt verwenden und sie in SCNScene konvertieren. Unterstützte Formate: USD, USDZ, OBJ, STL, PLY, Collada (DAE) und Alembic (ABC). Animierte Modelle (Skelettanimation, Morphing) werden ebenfalls importiert.

// Laden eines 3D-Modells über Model I/O
import ModelIO
 
let url = Bundle.main.url(forResource: "robot",
    withExtension: "usdz")!
let asset = MDLAsset(url: url)
let scene = SCNScene(mdlAsset: asset)
 
// Suche von Knoten nach Namen zur Konfiguration
if let robot = scene.rootNode.childNode(
    withName: "RobotArmature", recursively: true
) {
    robot.position = SCNVector3(0, 0, -3)
}

Nach dem Import kann das Modell über CAAnimation (kopiert von MDLAnimation) oder über SCNTransaction für sanfte Eigenschaftsänderungen animiert werden. Das Animationssystem von SceneKit unterstützt das Blending zwischen Animationen und die Synchronisation mit der Physik für realistische Bewegungen.

Animation und Transaktionen

SCNTransaction ermöglicht das Gruppieren von Szenenparameteränderungen in einem Animationsblock mit einer bestimmten Dauer. Die Methoden begin() und commit() umschließen die Änderungen, und duration legt die Animationszeit fest. Verschachtelte Transaktionen werden für parallele Animationen mit unterschiedlichen Dauern unterstützt. Ein completion-Block wird nach Abschluss der Animation ausgeführt.

Für Skelettanimation unterstützt SceneKit SCNAnimation und SCNMorpher für Blend-Shapes (Morph-Targets). Jede Animation kann geloopt, zeitlich skaliert und mit anderen Animationen über additives Blending gemischt werden. Laut Apple (2025) unterstützt SceneKit bis zu 4 gleichzeitig gemischte Animationen pro Skelett.

SCNParticleSystem-Partikelsystem

SCNParticleSystem ist ein integriertes Partikelsystem zur Erstellung von Effekten: Rauch, Feuer, Regen und Funken. Partikel können von einem Punkt, einer Kugel, einem Würfel oder einer Geometrieoberfläche emittiert werden. Parameter: birthRate, particleLifeSpan, speed, acceleration und colorOverLife. Partikelsysteme laufen auf der GPU für maximale Leistung.

Laut Apple (2025) unterstützt SCNParticleSystem bis zu 100.000 Partikel bei 60 FPS auf Geräten mit A16+. Partikel können auf Kollisionen mit Szenenphysikkörpern reagieren. Für komplexe Effekte können mehrere Partikelsysteme mit unterschiedlichen Parametern kombiniert und an bewegliche Knoten angehängt werden.

SceneKit und ARKit: Erweiterte Realität

SceneKit ist das bevorzugte High-Level-Framework für ARKit-Anwendungen. ARSCNView erweitert SCNView und synchronisiert automatisch die virtuelle 3D-Welt mit der realen Umgebung. Bildanalyse, Ebenenerkennung und Gesichtsverfolgung werden von ARKit durchgeführt, während das Rendering von SceneKit übernommen wird.

ARSCNView und ARAnchor

ARSCNView unterstützt alle SCNView-Funktionen, ersetzt jedoch die Szenenkamera durch die reale Kamera des Geräts. ARKit analysiert das Video der Kamera und erstellt ARAnchors, die SceneKit in SCNNodes umwandelt. Die ARKit-Sitzung wird über die session-Eigenschaft verwaltet, die mit einer Konfiguration (ARWorldTrackingConfiguration, ARFaceTrackingConfiguration) eingerichtet wird.

import ARKit
 
class ARViewController: UIViewController,
    ARSessionDelegate {
    let sceneView = ARSCNView()
     
    override func viewDidLoad() {
        super.viewDidLoad()
        sceneView.session.run(
            ARWorldTrackingConfiguration()
        )
        sceneView.autoenablesDefaultLighting = true
        sceneView.delegate = self
    }
}

Die Eigenschaft autoenablesDefaultLighting fügt integrierte Beleuchtung hinzu, die der realen Umgebung entspricht. ARKit 6 (iOS 18) unterstützt Location Anchors zur Bindung von 3D-Objekten an geografische Koordinaten und Room Tracking zur Kartierung von Innenräumen mit Details auf Möbelebene.

Ebenenerkennung und Objektplatzierung

ARKit erkennt horizontale und vertikale Ebenen (Böden, Tische, Wände) über den didAdd/didUpdate/didRemove-Ankerdelegaten. Ein an ARPlaneAnchor gebundener SceneKit-Knoten verfolgt automatisch die Position der Ebene in Echtzeit. Zur Objektplatzierung wird die hitTest-Methode auf ARSCNView oder raycastQuery verwendet.

Laut Apple (2025) beträgt die maximale Tracking-Entfernung von ARKit auf A17 Pro 50 Meter bei einer Beleuchtung ab 10 Lux. SceneKit + ARKit bieten eine Ende-zu-Ende-Latenz (Motion-to-Photon) von weniger als 20 ms, was für AR-Spiele und industrielle Anwendungen mit 3D-Anweisungseinblendungen auf realen Geräten entscheidend ist.