SceneKit: vad är det, 3D-scener och scengrafen

Vad är SceneKit?

SceneKit — är ett ramverk för 3D-grafik som ingår i Apples SDK och introducerades i iOS 8 (2014). SceneKit tillhandahåller ett helt skriptbart API som fungerar på Metal och OpenGL för att skapa interaktiva 3D-scener. Ramverket stöder import av modeller i formaten Collada (DAE), Alembic (ABC), USD och GLTF via Model I/O.

Till skillnad från lågnivå-API:er (Metal, Vulkan) tar SceneKit över hanteringen av rendering, belysning och fysik. Utvecklaren beskriver scenen deklarativt: lägger till noder, ställer in material och animationer. SceneKit optimerar automatiskt geometrin, slår samman draw calls och hanterar LOD när det behövs.

SceneKit kan arbeta tillsammans med ARKit för att visa 3D-objekt i den verkliga världen, samt med Core ML för maskinseende och scenanalys. Enligt Apple (2025) använder den senaste versionen av SceneKit endast Metal API med stöd för Metal 3 och GPU Family 9 på Apple Silicon-chips.

SceneKits historia

SceneKit dök upp på macOS 2012 som en del av OS X Mountain Lion och använde ursprungligen OpenGL för rendering. Med lanseringen av iOS 8 blev ramverket tillgängligt på mobila enheter. Version SceneKit 2.0 (iOS 10) lade till stöd för PBR-material, HDR-belysning och integration med Model I/O för import av modeller.

I iOS 12 övergick SceneKit helt till Metal. iOS 15 introducerade stöd för USDZ-format och AR Quick Look. Med iOS 18 (2024) fick SceneKit hårdvaruacceleration av ray tracing på enheter med A17 Pro- och M4-chip, vilket möjliggjorde realistiska skuggor och reflektioner i realtid på mobila enheter.

SceneKit-arkitektur: scengraf och noder

SceneKits arkitektur är baserad på scengrafen, där SCNScene är rotelementet som innehåller SCNNode-hierarkin. Varje nod har undernoder och kan innehålla geometri, kamera, ljus eller fysisk kropp. Nodens position bestäms via SCNVector3 (x, y, z) i ett vänsterorienterat koordinatsystem.

SCNScene — rotbehållaren

SCNScene innehåller hela tillståndet för 3D-världen: rotnoden rootNode, bakgrundsinställningar (background), ljuskällor och den fysiska världen (SCNPhysicsWorld). Scenen kan laddas från en .scn-fil (SceneKit Scene Format) eller skapas programmatiskt. Formatet .scn är öppet och baserat på JSON.

import SceneKit
 
let scene = SCNScene()
scene.background.contents = UIColor.darkGray
 
// Skapa kamera
let cameraNode = SCNNode()
cameraNode.camera = SCNCamera()
cameraNode.position = SCNVector3(0, 5, 10)
scene.rootNode.addChildNode(cameraNode)
 
// Skapa kub med fysik
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)

Klassen SCNCamera konfigurerar perspektivisk eller ortografisk projektion. Parametrar: fieldOfView (synvinkel, standard 45°), zNear/zFar (nära/avlägsen klippningsplan). SceneKit hanterar automatiskt projektionsmatrisen baserat på dessa parametrar och skärmens bildförhållande.

SCNNode — scenens noder

SCNNode kopplar samman geometri, transformation och fysisk kropp. Noder kan vara tomma (behållare för andra noder) eller innehålla geometri via egenskapen geometry. Varje nod har ett namn (name) för programmatisk sökning och kan animeras via CAAnimation eller fördefinierade SCNTransaction.

Nodens transformation bestäms av egenskaperna position (SCNVector3), rotation (SCNVector4) och scale (SCNVector3). För komplexa transformationer används egenskapen transform (SCNMatrix4). Även pivot är tillgänglig — förskjutning av transformationscentrum och worldPosition — absolut position i världsrymden oberoende av hierarkin.

SCNView — rendering

SCNView — UIView för att visa SCNScene. Egenskapen allowsCameraControl aktiverar användarkontroll av kameran via gester (flytta, rotera, zooma). För felsökning finns showsStatistics (FPS, draw calls, polygoner) och debugOptions (wireframe, bounding boxes).

I SwiftUI bäddas SceneKit in via SceneView, som omsluter SCNView och stöder bindningar till scenparametrar. Enligt Apple (2025) använder SceneView samma Metal-renderer som SCNView, utan extra overhead för bron mellan SwiftUI och UIKit.

Material, belysning och fysik i SceneKit

SCNMaterial bestämmer hur geometrins yta interagerar med ljus. SceneKit stöder PBR (Physically Based Rendering) via SCNMaterial.LightingModel.physicallyBased, som använder parametrarna roughness, metalness, albedo och normal. PBR-material ser realistiska ut i vilken belysning som helst utan manuell konfiguration av glans.

SCNMaterial och texturer

SCNMaterial har flera kanaler: diffuse (färg/textur), specular (spegelglans), normal (normalmap), emission (ljusutstrålning), roughness (ojämnhet) och metalness (metallicitet). Varje kanal kan innehålla UIColor, UIImage, CALayer eller SKScene för animerade texturer.

// PBR-material för 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)

Parametern roughness 0.3 med metalness 0.8 skapar ett material som liknar polerad metall med matt yta. För dielektrika (trä, plast) ställs metalness in på 0, och för metaller — nära 1.0. PBR-material anpassar sig automatiskt till scenens HDR-belysning.

Belysning i SceneKit

SCNLight stöder flera typer av ljuskällor: omni (punkt), directional (riktad), spot (strålkastare), ambient (omgivning) och area (yt). Varje källa har intensitet (intensity), färg (color) och kan kasta skuggor (castsShadow). SceneKit hanterar automatiskt skuggor via shadow maps.

SceneKit stöder HDR-belysning med tonkompression (tone mapping). Egenskapen wantsHDR på SCNView aktiverar utökat dynamiskt område. Kameraattribut: whitePoint, adaptativeLuminance och exposure anpassar bilden till scenens ljusstyrka och skapar en fotografisk exponeringseffekt.

Fysik SCNPhysicsBody

SCNPhysicsBody simulerar fysik för fasta kroppar: gravitation, kollisioner och friktion. Kroppstyper: .static (orörlig), .dynamic (under påverkan av krafter) och .kinematic (programmatiskt styrd). Kroppens form bestäms av SCNPhysicsShape, som kan baseras på nodens geometri eller en förenklad form (box, sphere, concave polyhedron).

SCNPhysicsWorld hanterar scenens globala fysik: gravitation (gravity), simuleringshastighet (speed) och kollisionsdetektering via delegaten SCNPhysicsContactDelegate. SceneKit stöder fysiska leder (SCNPhysicsHingeJoint, SCNPhysicsBallJoint, SCNPhysicsSliderJoint) för att skapa mekanismer och sammankopplade objekt.

Utveckling av 3D-scener i SceneKit

Utveckling i SceneKit börjar vanligtvis med att ladda en 3D-modell via Model I/O eller en .scn-fil. Scenredigeraren i Xcode (Scene Editor) gör det möjligt att visuellt placera objekt, konfigurera material och belysning utan kod. .scn-filer sparas i JSON-format och stöder versionshantering via git.

Import av 3D-modeller

Model I/O (ModelIO.framework) — ett kraftfullt verktyg för import, export och bearbetning av 3D-modeller. SceneKit kan direkt använda MDLAsset-objekt och omvandla dem till SCNScene. Stödda format: USD, USDZ, OBJ, STL, PLY, Collada (DAE) och Alembic (ABC). Modeller med animationer (skelettanimation, morphing) importeras också.

// Ladda 3D-modell 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)
 
// Söka noder efter namn för konfiguration
if let robot = scene.rootNode.childNode(
    withName: "RobotArmature", recursively: true
) {
    robot.position = SCNVector3(0, 0, -3)
}

Efter import kan modellen animeras via CAAnimation, kopierad från MDLAnimation, eller via SCNTransaction för mjuka ändringar av egenskaper. SceneKits animationssystem stöder blandning av animationer och synkronisering med fysik för att skapa realistiska rörelser.

Animation och transaktioner

SCNTransaction gör det möjligt att gruppera ändringar av scenparametrar i ett animationsblock med angiven varaktighet. Metoderna begin() och commit() omger ändringarna, och duration anger animeringens längd. Kapslade transaktioner stöds för parallella animationer med olika längd. Completion-blocket körs efter att animeringen är klar.

För skelettanimation stöder SceneKit SCNAnimation och SCNMorpher för blend-shapes (morph targets). Varje animation kan loopas, tidsskalas och blandas med andra animationer via additive blending. Enligt Apple (2025) stöder SceneKit upp till 4 samtidigt blandade animationer på ett skelett.

Partikelsystem SCNParticleSystem

SCNParticleSystem — inbyggt partikelsystem för att skapa effekter: rök, eld, regn och gnistor. Partiklar kan emitteras från en punkt, sfär, kub eller geometriyta. Parametrar: birthRate, particleLifeSpan, speed, acceleration och colorOverLife. Partikelsystem fungerar på GPU för maximal prestanda.

Enligt Apple (2025) stöder SCNParticleSystem upp till 100 tusen partiklar med 60 FPS på enheter med A16+. Partiklar kan reagera på kollisioner med scenens fysiska kroppar. För komplexa effekter kan flera partikelsystem med olika parametrar kombineras och kopplas till rörliga noder.

SceneKit och ARKit: förstärkt verklighet

SceneKit är det föredragna högnivåramverket för ARKit-applikationer. ARSCNView utökar SCNView och synkroniserar automatiskt den virtuella 3D-världen med den verkliga miljön. Bildanalys, plank detection och ansiktsövervakning utförs av ARKit, och rendering av SceneKit.

ARSCNView och ARAnchor

ARSCNView stöder alla funktioner i SCNView, men ersätter scenkameran med enhetens riktiga kamera. ARKit analyserar video från kameran och skapar ARAnchor, som SceneKit omvandlar till SCNNode. ARKit-sessionen hanteras via egenskapen session, som konfigureras med en konfiguration (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
    }
}

Egenskapen autoenablesDefaultLighting lägger till inbyggd belysning som motsvarar den verkliga miljön. ARKit 6 (iOS 18) stöder Location Anchors för att fästa 3D-objekt till geografiska koordinater och Room Tracking för kartläggning av inomhusutrymmen med detalj ner till möbler.

Plane detection och objektplacering

ARKit detekterar horisontella och vertikala plan (golv, bord, väggar) via delegaten didAdd/didUpdate/didRemove anchor. SceneKit-noden som är bunden till ARPlaneAnchor följer automatiskt planets position i realtid. För objektplacering används metoden hitTest på ARSCNView eller raycastQuery.

Enligt Apple (2025) är det maximala avståndet för ARKit-spårning på A17 Pro 50 meter vid belysning på 10 lux. SceneKit + ARKit ger en end-to-end-fördröjning (motion-to-photon) på mindre än 20 ms, vilket är kritiskt för AR-spel och industriella applikationer med överlagring av 3D-instruktioner på verklig utrustning.