SceneKit: cos'è, scene 3D e grafo di scena

Cos’è SceneKit?

SceneKit è un framework per la grafica 3D che fa parte dell’SDK Apple ed è stato introdotto in iOS 8 (2014). SceneKit fornisce un’API completamente basata su scene che funziona su Metal e OpenGL per creare scene 3D interattive. Il framework supporta l’importazione di modelli nei formati Collada (DAE), Alembic (ABC), USD e GLTF tramite Model I/O.

A differenza delle API di basso livello (Metal, Vulkan), SceneKit si occupa della gestione del rendering, dell’illuminazione e della fisica. Lo sviluppatore descrive la scena in modo dichiarativo: aggiunge nodi, imposta materiali e animazioni. SceneKit ottimizza automaticamente la geometria, unisce le draw call e gestisce il LOD quando necessario.

SceneKit può funzionare insieme a ARKit per visualizzare oggetti 3D nel mondo reale, oltre che con Core ML per la visione artificiale e l’analisi della scena. Secondo Apple (2025), l’ultima versione di SceneKit utilizza esclusivamente l’API Metal con supporto per Metal 3 e GPU Family 9 sui chip Apple Silicon.

Storia di SceneKit

SceneKit è apparso su macOS nel 2012 come parte di OS X Mountain Lion e inizialmente utilizzava OpenGL per il rendering. Con il rilascio di iOS 8, il framework è diventato disponibile sui dispositivi mobili. SceneKit 2.0 (iOS 10) ha aggiunto il supporto per materiali PBR, illuminazione HDR e integrazione con Model I/O per l’importazione di modelli.

In iOS 12, SceneKit è passato completamente a Metal. iOS 15 ha introdotto il supporto per il formato USDZ e AR Quick Look. Con iOS 18 (2024), SceneKit ha ricevuto l’accelerazione hardware del ray tracing sui dispositivi con chip A17 Pro e M4, consentendo ombre e riflessi realistici in tempo reale sui dispositivi mobili.

Architettura di SceneKit: grafo di scena e nodi

L’architettura di SceneKit si basa su un grafo di scena, dove SCNScene è l’elemento radice che contiene una gerarchia di SCNNode. Ogni nodo ha nodi figli e può contenere geometria, una telecamera, una luce o un corpo fisico. La posizione del nodo viene impostata tramite SCNVector3 (x, y, z) in un sistema di coordinate sinistro.

SCNScene — contenitore radice

SCNScene contiene l’intero stato del mondo 3D: il nodo radice rootNode, le impostazioni di sfondo, le sorgenti luminose e il mondo fisico (SCNPhysicsWorld). La scena può essere caricata da un file .scn (SceneKit Scene Format) o creata programmaticamente. Il formato .scn è aperto e basato su JSON.

import SceneKit
 
let scene = SCNScene()
scene.background.contents = UIColor.darkGray
 
// Creazione di una telecamera
let cameraNode = SCNNode()
cameraNode.camera = SCNCamera()
cameraNode.position = SCNVector3(0, 5, 10)
scene.rootNode.addChildNode(cameraNode)
 
// Creazione di un cubo con fisica
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)

La classe SCNCamera configura la proiezione prospettica o ortografica. Parametri: fieldOfView (angolo di campo, default 45°), zNear/zFar (piano di taglio vicino/lontano). SceneKit gestisce automaticamente la matrice di proiezione in base a questi parametri e al rapporto d’aspetto dello schermo.

SCNNode — nodi della scena

SCNNode collega geometria, trasformazione e corpo fisico. I nodi possono essere vuoti (contenitori per altri nodi) o contenere geometria tramite la proprietà geometry. Ogni nodo ha un nome (name) per la ricerca programmatica e può essere animato tramite CAAnimation o SCNTransaction predefinita.

La trasformazione del nodo viene impostata tramite le proprietà position (SCNVector3), rotation (SCNVector4) e scale (SCNVector3). Per trasformazioni complesse, viene utilizzata la proprietà transform (SCNMatrix4). Sono inoltre disponibili pivot — offset del centro di trasformazione, e worldPosition — posizione assoluta nello spazio mondiale indipendentemente dalla gerarchia.

SCNView — rendering

SCNView è una UIView per visualizzare SCNScene. La proprietà allowsCameraControl abilita il controllo della telecamera tramite gesti (panoramica, rotazione, zoom). Per il debug, sono disponibili showsStatistics (FPS, draw call, poligoni) e debugOptions (wireframe, bounding box).

In SwiftUI, SceneKit viene incorporato tramite SceneView, che avvolge SCNView e supporta i binding ai parametri della scena. Secondo Apple (2025), SceneView utilizza lo stesso renderer Metal di SCNView, senza overhead aggiuntivo per il ponte tra SwiftUI e UIKit.

Materiali, illuminazione e fisica in SceneKit

SCNMaterial definisce come la superficie della geometria interagisce con la luce. SceneKit supporta il PBR (Physically Based Rendering) tramite SCNMaterial.LightingModel.physicallyBased, che utilizza i parametri roughness, metalness, albedo e normal. I materiali PBR appaiono realistici sotto qualsiasi illuminazione senza regolazione manuale dei riflessi.

SCNMaterial e texture

SCNMaterial ha diversi canali: diffuse (colore/texture), specular (riflesso speculare), normal (mappa delle normali), emission (bagliore), roughness (ruvidità) e metalness (metallicità). Ogni canale può contenere un UIColor, UIImage, CALayer o SKScene per texture animate.

// Materiale PBR per un oggetto 3D
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)

Il parametro roughness 0.3 con metalness 0.8 crea un materiale simile al metallo lucidato con finitura opaca. Per i dielettrici (legno, plastica), metalness viene impostato a 0, e per i metalli vicino a 1.0. I materiali PBR si adattano automaticamente all’illuminazione HDR della scena.

Illuminazione in SceneKit

SCNLight supporta diversi tipi di sorgenti luminose: omni (puntiforme), directional (direzionale), spot (faretto), ambient (ambiente) e area (superficiale). Ogni sorgente ha intensità, colore e può proiettare ombre (castsShadow). SceneKit gestisce automaticamente le ombre tramite shadow map.

SceneKit supporta l’illuminazione HDR con compressione tonale (tone mapping). La proprietà wantsHDR su SCNView attiva la gamma dinamica estesa. Attributi della telecamera: whitePoint, adaptativeLuminance e exposure adattano l’immagine alla luminosità della scena, creando un effetto di esposizione fotografica.

Fisica SCNPhysicsBody

SCNPhysicsBody simula la fisica dei corpi rigidi: gravità, collisioni e attrito. Tipi di corpo: .static (immobile), .dynamic (sotto l’azione di forze) e .kinematic (controllato programmaticamente). La forma del corpo viene definita tramite SCNPhysicsShape, che può essere basata sulla geometria del nodo o su una forma semplificata (box, sphere, concave polyhedron).

SCNPhysicsWorld gestisce la fisica globale della scena: gravità, velocità di simulazione e rilevamento delle collisioni tramite il delegato SCNPhysicsContactDelegate. SceneKit supporta giunti fisici (SCNPhysicsHingeJoint, SCNPhysicsBallJoint, SCNPhysicsSliderJoint) per creare meccanismi e oggetti connessi.

Sviluppo di scene 3D con SceneKit

Lo sviluppo con SceneKit inizia tipicamente con il caricamento di un modello 3D tramite Model I/O o un file .scn. L’editor di scene in Xcode (Scene Editor) consente di posizionare visivamente gli oggetti, configurare materiali e illuminazione senza codice. I file .scn vengono salvati in formato JSON e supportano il controllo versione tramite git.

Importazione di modelli 3D

Model I/O (ModelIO.framework) è un potente strumento per importare, esportare e elaborare modelli 3D. SceneKit può utilizzare direttamente gli oggetti MDLAsset, convertendoli in SCNScene. Formati supportati: USD, USDZ, OBJ, STL, PLY, Collada (DAE) e Alembic (ABC). Vengono importati anche modelli animati (animazione scheletrica, morphing).

// Caricamento di un modello 3D tramite Model I/O
import ModelIO
 
let url = Bundle.main.url(forResource: "robot",
    withExtension: "usdz")!
let asset = MDLAsset(url: url)
let scene = SCNScene(mdlAsset: asset)
 
// Ricerca di nodi per nome per configurazione
if let robot = scene.rootNode.childNode(
    withName: "RobotArmature", recursively: true
) {
    robot.position = SCNVector3(0, 0, -3)
}

Dopo l’importazione, il modello può essere animato tramite CAAnimation copiata da MDLAnimation, o tramite SCNTransaction per modifiche graduali delle proprietà. Il sistema di animazione di SceneKit supporta il blending tra animazioni e la sincronizzazione con la fisica per creare movimenti realistici.

Animazione e transazioni

SCNTransaction consente di raggruppare le modifiche dei parametri della scena in un blocco di animazione con una durata specificata. I metodi begin() e commit() racchiudono le modifiche, e duration imposta il tempo di animazione. Le transazioni annidate sono supportate per animazioni parallele con durate diverse. Un blocco completion viene eseguito dopo il termine dell’animazione.

Per l’animazione scheletrica, SceneKit supporta SCNAnimation e SCNMorpher per blend shape (morph target). Ogni animazione può essere ripetuta in loop, ridimensionata nel tempo e miscelata con altre animazioni tramite additive blending. Secondo Apple (2025), SceneKit supporta fino a 4 animazioni miscelate simultaneamente per scheletro.

Sistema particellare SCNParticleSystem

SCNParticleSystem è un sistema particellare integrato per creare effetti: fumo, fuoco, pioggia e scintille. Le particelle possono essere emesse da un punto, sfera, cubo o superficie di geometria. Parametri: birthRate, particleLifeSpan, speed, acceleration e colorOverLife. I sistemi particellari funzionano sulla GPU per prestazioni massime.

Secondo Apple (2025), SCNParticleSystem supporta fino a 100.000 particelle a 60 FPS su dispositivi con A16+. Le particelle possono reagire alle collisioni con i corpi fisici della scena. Per effetti complessi, è possibile combinare più sistemi particellari con parametri diversi e collegarli a nodi in movimento.

SceneKit e ARKit: realtà aumentata

SceneKit è il framework di alto livello preferito per le applicazioni ARKit. ARSCNView estende SCNView e sincronizza automaticamente il mondo 3D virtuale con l’ambiente reale. L’analisi dell’immagine, il rilevamento dei piani e il tracciamento facciale sono eseguiti da ARKit, mentre il rendering è gestito da SceneKit.

ARSCNView e ARAnchor

ARSCNView supporta tutte le funzionalità di SCNView ma sostituisce la telecamera della scena con la telecamera reale del dispositivo. ARKit analizza il video della telecamera e crea ARAnchor, che SceneKit converte in SCNNode. La sessione ARKit viene gestita tramite la proprietà session, configurata con una configurazione (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
    }
}

La proprietà autoenablesDefaultLighting aggiunge illuminazione integrata corrispondente all’ambiente reale. ARKit 6 (iOS 18) supporta Location Anchors per vincolare oggetti 3D a coordinate geografiche e Room Tracking per mappare spazi interni con dettagli a livello di arredi.

Rilevamento piani e posizionamento oggetti

ARKit rileva piani orizzontali e verticali (pavimenti, tavoli, pareti) tramite il delegato didAdd/didUpdate/didRemove anchor. Un nodo SceneKit collegato ad ARPlaneAnchor traccia automaticamente la posizione del piano in tempo reale. Per posizionare oggetti, si utilizza il metodo hitTest su ARSCNView o raycastQuery.

Secondo Apple (2025), la distanza massima di tracciamento di ARKit su A17 Pro è di 50 metri con illuminazione da 10 lux. SceneKit + ARKit forniscono una latenza end-to-end (motion-to-photon) inferiore a 20 ms, fondamentale per i giochi AR e le applicazioni industriali con sovrapposizione di istruzioni 3D su apparecchiature reali.