SceneKit: wat is het, 3D-scènes en de scènegraaf

Wat is SceneKit?

SceneKit — is een framework voor 3D-graphics dat deel uitmaakt van de Apple SDK en werd geïntroduceerd in iOS 8 (2014). SceneKit biedt een volledig scriptbare API die werkt op Metal en OpenGL voor het maken van interactieve 3D-scènes. Het framework ondersteunt het importeren van modellen in Collada (DAE), Alembic (ABC), USD en GLTF via Model I/O.

In tegenstelling tot low-level API's (Metal, Vulkan) neemt SceneKit het beheer van rendering, verlichting en fysica over. De ontwikkelaar beschrijft de scène declaratief: voegt knooppunten toe, stelt materialen en animaties in. SceneKit optimaliseert automatisch de geometrie, combineert draw calls en beheert LOD wanneer nodig.

SceneKit kan samenwerken met ARKit voor het weergeven van 3D-objecten in de echte wereld, en met Core ML voor machinevisie en scèneanalyse. Volgens Apple (2025) gebruikt de nieuwste versie van SceneKit alleen de Metal API met ondersteuning voor Metal 3 en GPU Family 9 op Apple Silicon-chips.

Geschiedenis van SceneKit

SceneKit verscheen op macOS in 2012 als onderdeel van OS X Mountain Lion en gebruikte aanvankelijk OpenGL voor rendering. Met de release van iOS 8 werd het framework beschikbaar op mobiele apparaten. SceneKit 2.0 (iOS 10) voegde ondersteuning toe voor PBR-materialen, HDR-verlichting en integratie met Model I/O voor het importeren van modellen.

In iOS 12 schakelde SceneKit volledig over op Metal. iOS 15 introduceerde ondersteuning voor USDZ-formaat en AR Quick Look. Met iOS 18 (2024) kreeg SceneKit hardwareversnelling van ray tracing op apparaten met de A17 Pro- en M4-chip, wat realistische schaduwen en reflecties in realtime op mobiele apparaten mogelijk maakte.

SceneKit-architectuur: scènegraaf en knooppunten

De architectuur van SceneKit is gebaseerd op de scènegraaf, waarin SCNScene het root-element is dat de SCNNode-hiërarchie bevat. Elk knooppunt heeft onderliggende knooppunten en kan geometrie, een camera, licht of een fysiek lichaam bevatten. De positie van een knooppunt wordt bepaald via SCNVector3 (x, y, z) in een linkshandig coördinatenstelsel.

SCNScene — de rootcontainer

SCNScene bevat de volledige toestand van de 3D-wereld: het root-knooppunt rootNode, achtergrondinstellingen (background), lichtbronnen en de fysieke wereld (SCNPhysicsWorld). De scène kan worden geladen uit een .scn-bestand (SceneKit Scene Format) of programmatisch worden gemaakt. Het .scn-formaat is open en gebaseerd op JSON.

import SceneKit
 
let scene = SCNScene()
scene.background.contents = UIColor.darkGray
 
// Camera maken
let cameraNode = SCNNode()
cameraNode.camera = SCNCamera()
cameraNode.position = SCNVector3(0, 5, 10)
scene.rootNode.addChildNode(cameraNode)
 
// Kubus met fysica maken
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)

De klasse SCNCamera configureert perspectivische of orthografische projectie. Parameters: fieldOfView (gezichtsveld, standaard 45°), zNear/zFar (nabije/verre afsnijvlak). SceneKit beheert automatisch de projectiematrix op basis van deze parameters en de beeldverhouding van het scherm.

SCNNode — scèneknooppunten

SCNNode verbindt geometrie, transformatie en fysiek lichaam. Knooppunten kunnen leeg zijn (containers voor andere knooppunten) of geometrie bevatten via de eigenschap geometry. Elk knooppunt heeft een naam (name) voor programmatisch zoeken en kan worden geanimeerd via CAAnimation of vooraf gedefinieerde SCNTransaction.

De transformatie van een knooppunt wordt bepaald door de eigenschappen position (SCNVector3), rotation (SCNVector4) en scale (SCNVector3). Voor complexe transformaties wordt de eigenschap transform (SCNMatrix4) gebruikt. Ook beschikbaar zijn pivot — verschuiving van het transformatiecentrum en worldPosition — absolute positie in de wereldruimte onafhankelijk van de hiërarchie.

SCNView — rendering

SCNView — UIView voor het weergeven van SCNScene. De eigenschap allowsCameraControl schakelt gebruikersbediening van de camera via gebaren (verplaatsen, roteren, schalen) in. Voor debugging zijn showsStatistics (FPS, draw calls, polygonen) en debugOptions (wireframe, bounding boxes) beschikbaar.

In SwiftUI wordt SceneKit ingebed via SceneView, die SCNView omhult en bindingen aan scèneparameters ondersteunt. Volgens Apple (2025) gebruikt SceneView dezelfde Metal-renderer als SCNView, zonder extra overhead voor de brug tussen SwiftUI en UIKit.

Materialen, verlichting en fysica in SceneKit

SCNMaterial bepaalt hoe het oppervlak van geometrie met licht interageert. SceneKit ondersteunt PBR (Physically Based Rendering) via SCNMaterial.LightingModel.physicallyBased, dat de parameters roughness, metalness, albedo en normal gebruikt. PBR-materialen zien er realistisch uit onder elke verlichting zonder handmatige configuratie van glans.

SCNMaterial en texturen

SCNMaterial heeft meerdere kanalen: diffuse (kleur/textuur), specular (spiegelglans), normal (normaalmap), emission (lichtuitstraling), roughness (ruwheid) en metalness (metaalachtigheid). Elk kanaal kan UIColor, UIImage, CALayer of SKScene bevatten voor geanimeerde texturen.

// PBR-materiaal voor 3D-object
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)

De parameter roughness 0.3 met metalness 0.8 creëert een materiaal dat lijkt op gepolijst metaal met een matte afwerking. Voor diëlektrica (hout, plastic) wordt metalness ingesteld op 0, en voor metalen — dicht bij 1.0. PBR-materialen passen zich automatisch aan de HDR-verlichting van de scène aan.

Verlichting in SceneKit

SCNLight ondersteunt meerdere soorten lichtbronnen: omni (punt), directional (gericht), spot (schijnwerper), ambient (omgeving) en area (oppervlak). Elke bron heeft intensiteit (intensity), kleur (color) en kan schaduwen werpen (castsShadow). SceneKit beheert schaduwen automatisch via shadow maps.

SceneKit ondersteunt HDR-verlichting met tonale compressie (tone mapping). De eigenschap wantsHDR op SCNView schakelt het uitgebreide dynamische bereik in. Camera-attributen: whitePoint, adaptativeLuminance en exposure passen het beeld aan de helderheid van de scène aan, waardoor een fotografisch belichtingseffect ontstaat.

Fysica SCNPhysicsBody

SCNPhysicsBody simuleert de fysica van vaste lichamen: zwaartekracht, botsingen en wrijving. Lichaamstypen: .static (onbeweeglijk), .dynamic (onder invloed van krachten) en .kinematic (programmatisch bestuurd). De vorm van het lichaam wordt bepaald door SCNPhysicsShape, die gebaseerd kan zijn op de geometrie van het knooppunt of op een vereenvoudigde vorm (box, sphere, concave polyhedron).

SCNPhysicsWorld beheert de globale fysica van de scène: zwaartekracht (gravity), simulatiesnelheid (speed) en botsingsdetectie via de delegate SCNPhysicsContactDelegate. SceneKit ondersteunt fysieke verbindingen (SCNPhysicsHingeJoint, SCNPhysicsBallJoint, SCNPhysicsSliderJoint) voor het maken van mechanismen en verbonden objecten.

3D-scènes ontwikkelen in SceneKit

Ontwikkeling in SceneKit begint meestal met het laden van een 3D-model via Model I/O of een .scn-bestand. De scène-editor in Xcode (Scene Editor) maakt het mogelijk om objecten visueel te plaatsen, materialen en verlichting te configureren zonder code. .scn-bestanden worden opgeslagen in JSON-formaat en ondersteunen versiebeheer via git.

Importeren van 3D-modellen

Model I/O (ModelIO.framework) — een krachtige tool voor het importeren, exporteren en verwerken van 3D-modellen. SceneKit kan direct MDLAsset-objecten gebruiken en deze omzetten naar SCNScene. Ondersteunde formaten: USD, USDZ, OBJ, STL, PLY, Collada (DAE) en Alembic (ABC). Modellen met animaties (skeletanimatie, morphing) worden ook geïmporteerd.

// 3D-model laden via Model I/O
import ModelIO
 
let url = Bundle.main.url(forResource: "robot",
    withExtension: "usdz")!
let asset = MDLAsset(url: url)
let scene = SCNScene(mdlAsset: asset)
 
// Knooppunten zoeken op naam voor configuratie
if let robot = scene.rootNode.childNode(
    withName: "RobotArmature", recursively: true
) {
    robot.position = SCNVector3(0, 0, -3)
}

Na het importeren kan het model worden geanimeerd via CAAnimation, gekopieerd uit MDLAnimation, of via SCNTransaction voor vloeiende wijzigingen van eigenschappen. Het animatiesysteem van SceneKit ondersteunt blending tussen animaties en synchronisatie met fysica voor realistische bewegingen.

Animatie en transacties

SCNTransaction maakt het mogelijk om wijzigingen van scèneparameters te groeperen in een animatieblok met een bepaalde duur. De methoden begin() en commit() omvatten de wijzigingen, en duration bepaalt de animatieduur. Geneste transacties worden ondersteund voor parallelle animaties met verschillende duren. Het Completion-blok wordt uitgevoerd na afloop van de animatie.

Voor skeletanimatie ondersteunt SceneKit SCNAnimation en SCNMorpher voor blend-shapes (morph targets). Elke animatie kan worden geloopt, in tijd worden geschaald en met andere animaties worden gemengd via additive blending. Volgens Apple (2025) ondersteunt SceneKit tot 4 gelijktijdig gemengde animaties op één skelet.

Deeltjessystemen SCNParticleSystem

SCNParticleSystem — het ingebouwde deeltjessysteem voor het maken van effecten: rook, vuur, regen en vonken. Deeltjes kunnen worden uitgezonden vanuit een punt, bol, kubus of het oppervlak van geometrie. Parameters: birthRate, particleLifeSpan, speed, acceleration en colorOverLife. Deeltjessystemen werken op de GPU voor maximale prestaties.

Volgens Apple (2025) ondersteunt SCNParticleSystem tot 100 duizend deeltjes met 60 FPS op apparaten met A16+. Deeltjes kunnen reageren op botsingen met fysieke lichamen in de scène. Voor complexe effecten kunnen meerdere deeltjessystemen met verschillende parameters worden gecombineerd en aan bewegende knooppunten worden gebonden.

SceneKit en ARKit: augmented reality

SceneKit is het voorkeursframework op hoog niveau voor ARKit-applicaties. ARSCNView breidt SCNView uit en synchroniseert automatisch de virtuele 3D-wereld met de echte omgeving. Beeldanalyse, vlakdetectie en gezichtsvolging worden uitgevoerd door ARKit, en rendering door SceneKit.

ARSCNView en ARAnchor

ARSCNView ondersteunt alle functies van SCNView, maar vervangt de scènecamera door de echte camera van het apparaat. ARKit analyseert video van de camera en creëert ARAnchors, die SceneKit omzet naar SCNNodes. De ARKit-sessie wordt beheerd via de eigenschap session, die wordt geconfigureerd met een configuratie (ARWorldTrackingConfiguration, ARFaceTrackingConfiguration).

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

De eigenschap autoenablesDefaultLighting voegt ingebouwde verlichting toe die overeenkomt met de echte omgeving. ARKit 6 (iOS 18) ondersteunt Location Anchors voor het verankeren van 3D-objecten aan geografische coördinaten en Room Tracking voor het in kaart brengen van binnenruimtes met detaillering tot aan meubels.

Vlakdetectie en objectplaatsing

ARKit detecteert horizontale en verticale vlakken (vloeren, tafels, muren) via de delegate didAdd/didUpdate/didRemove anchor. Het SceneKit-knooppunt dat aan ARPlaneAnchor is gekoppeld, volgt automatisch de positie van het vlak in realtime. Voor het plaatsen van objecten wordt de methode hitTest op ARSCNView of raycastQuery gebruikt.

Volgens Apple (2025) bedraagt de maximale volgafstand van ARKit op A17 Pro 50 meter bij een verlichting van 10 lux. SceneKit + ARKit zorgen voor een end-to-end vertraging (motion-to-photon) van minder dan 20 ms, wat cruciaal is voor AR-games en industriële toepassingen met 3D-instructies over echte apparatuur.