SceneKit : définition, scènes 3D et graphe de scène

Qu’est-ce que SceneKit ?

SceneKit est un framework pour les graphiques 3D faisant partie du SDK Apple et présenté dans iOS 8 (2014). SceneKit fournit une API entièrement basée sur les scènes fonctionnant sur Metal et OpenGL pour créer des scènes 3D interactives. Le framework prend en charge l’importation de modèles aux formats Collada (DAE), Alembic (ABC), USD et GLTF via Model I/O.

Contrairement aux API de bas niveau (Metal, Vulkan), SceneKit gère le rendu, l’éclairage et la physique. Le développeur décrit la scène de manière déclarative : ajoute des nœuds, définit des matériaux et des animations. SceneKit optimise automatiquement la géométrie, fusionne les draw calls et gère le LOD si nécessaire.

SceneKit peut fonctionner avec ARKit pour afficher des objets 3D dans le monde réel, ainsi qu’avec Core ML pour la vision artificielle et l’analyse de scène. Selon Apple (2025), la dernière version de SceneKit utilise exclusivement l’API Metal avec prise en charge de Metal 3 et GPU Family 9 sur les puces Apple Silicon.

Histoire de SceneKit

SceneKit est apparu sur macOS en 2012 dans OS X Mountain Lion et utilisait initialement OpenGL pour le rendu. Avec la sortie d’iOS 8, le framework est devenu disponible sur les appareils mobiles. SceneKit 2.0 (iOS 10) a ajouté la prise en charge des matériaux PBR, de l’éclairage HDR et de l’intégration avec Model I/O pour l’importation de modèles.

Dans iOS 12, SceneKit est passé entièrement à Metal. iOS 15 a introduit la prise en charge du format USDZ et d’AR Quick Look. Avec iOS 18 (2024), SceneKit a reçu l’accélération matérielle du ray tracing sur les appareils avec puce A17 Pro et M4, permettant des ombres et des reflets réalistes en temps réel sur les appareils mobiles.

Architecture de SceneKit : graphe de scène et nœuds

L’architecture de SceneKit est basée sur un graphe de scène, où SCNScene est l’élément racine contenant une hiérarchie de SCNNode. Chaque nœud a des nœuds enfants et peut contenir de la géométrie, une caméra, une lumière ou un corps physique. La position du nœud est définie via SCNVector3 (x, y, z) dans un système de coordonnées gauche.

SCNScene — conteneur racine

SCNScene contient tout l’état du monde 3D : le nœud racine rootNode, les paramètres d’arrière-plan, les sources lumineuses et le monde physique (SCNPhysicsWorld). La scène peut être chargée à partir d’un fichier .scn (SceneKit Scene Format) ou créée par programmation. Le format .scn est ouvert et basé sur JSON.

import SceneKit
 
let scene = SCNScene()
scene.background.contents = UIColor.darkGray
 
// Création d’une caméra
let cameraNode = SCNNode()
cameraNode.camera = SCNCamera()
cameraNode.position = SCNVector3(0, 5, 10)
scene.rootNode.addChildNode(cameraNode)
 
// Création d’un cube avec physique
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 configure la projection perspective ou orthographique. Paramètres : fieldOfView (angle de vue, par défaut 45°), zNear/zFar (plan de coupe proche/loin). SceneKit gère automatiquement la matrice de projection en fonction de ces paramètres et du rapport d’aspect de l’écran.

SCNNode — nœuds de scène

SCNNode connecte la géométrie, la transformation et le corps physique. Les nœuds peuvent être vides (conteneurs pour d’autres nœuds) ou contenir de la géométrie via la propriété geometry. Chaque nœud a un nom (name) pour la recherche programmatique et peut être animé via CAAnimation ou SCNTransaction prédéfinie.

La transformation du nœud est définie via les propriétés position (SCNVector3), rotation (SCNVector4) et scale (SCNVector3). Pour les transformations complexes, la propriété transform (SCNMatrix4) est utilisée. Sont également disponibles pivot — décalage du centre de transformation, et worldPosition — position absolue dans l’espace monde indépendamment de la hiérarchie.

SCNView — rendu

SCNView est une UIView pour afficher SCNScene. La propriété allowsCameraControl permet le contrôle de la caméra par gestes (panoramique, rotation, zoom). Pour le débogage, showsStatistics (FPS, draw calls, polygones) et debugOptions (wireframe, bounding boxes) sont disponibles.

Dans SwiftUI, SceneKit est intégré via SceneView, qui enveloppe SCNView et prend en charge les liaisons aux paramètres de la scène. Selon Apple (2025), SceneView utilise le même rendu Metal que SCNView, sans surcharge supplémentaire pour le pont entre SwiftUI et UIKit.

Matériaux, éclairage et physique dans SceneKit

SCNMaterial définit comment la surface de la géométrie interagit avec la lumière. SceneKit prend en charge le PBR (Physically Based Rendering) via SCNMaterial.LightingModel.physicallyBased, qui utilise les paramètres roughness, metalness, albedo et normal. Les matériaux PBR semblent réalistes sous n’importe quel éclairage sans réglage manuel des reflets.

SCNMaterial et textures

SCNMaterial a plusieurs canaux : diffuse (couleur/texture), specular (brillant spéculaire), normal (carte de normales), emission (lueur), roughness (rugosité) et metalness (métalicité). Chaque canal peut contenir un UIColor, UIImage, CALayer ou SKScene pour des textures animées.

// Matériau PBR pour un objet 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)

Le paramètre roughness 0.3 avec metalness 0.8 crée un matériau semblable au métal poli avec une finition mate. Pour les diélectriques (bois, plastique), metalness est défini sur 0, et pour les métaux près de 1.0. Les matériaux PBR s’adaptent automatiquement à l’éclairage HDR de la scène.

Éclairage dans SceneKit

SCNLight prend en charge plusieurs types de sources lumineuses : omni (ponctuelle), directional (directionnelle), spot (projecteur), ambient (ambiante) et area (surface). Chaque source a une intensité, une couleur et peut projeter des ombres (castsShadow). SceneKit gère automatiquement les ombres via des shadow maps.

SceneKit prend en charge l’éclairage HDR avec compression tonale (tone mapping). La propriété wantsHDR sur SCNView active la plage dynamique étendue. Attributs de la caméra : whitePoint, adaptativeLuminance et exposure adaptent l’image à la luminosité de la scène, créant un effet d’exposition photographique.

Physique SCNPhysicsBody

SCNPhysicsBody simule la physique des corps rigides : gravité, collisions et frottement. Types de corps : .static (immobile), .dynamic (sous l’effet de forces) et .kinematic (contrôlé par programmation). La forme du corps est définie via SCNPhysicsShape, qui peut être basée sur la géométrie du nœud ou sur une forme simplifiée (box, sphere, concave polyhedron).

SCNPhysicsWorld gère la physique globale de la scène : gravité, vitesse de simulation et détection de collisions via le délégué SCNPhysicsContactDelegate. SceneKit prend en charge les articulations physiques (SCNPhysicsHingeJoint, SCNPhysicsBallJoint, SCNPhysicsSliderJoint) pour créer des mécanismes et des objets connectés.

Développement de scènes 3D avec SceneKit

Le développement avec SceneKit commence généralement par le chargement d’un modèle 3D via Model I/O ou un fichier .scn. L’éditeur de scènes dans Xcode (Scene Editor) permet de placer visuellement des objets, de configurer des matériaux et l’éclairage sans code. Les fichiers .scn sont enregistrés au format JSON et prennent en charge le contrôle de version via git.

Importation de modèles 3D

Model I/O (ModelIO.framework) est un outil puissant pour importer, exporter et traiter des modèles 3D. SceneKit peut utiliser directement les objets MDLAsset, en les convertissant en SCNScene. Formats pris en charge : USD, USDZ, OBJ, STL, PLY, Collada (DAE) et Alembic (ABC). Les modèles animés (animation squelettique, morphing) sont également importés.

// Chargement d’un modèle 3D 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)
 
// Recherche de nœuds par nom pour configuration
if let robot = scene.rootNode.childNode(
    withName: "RobotArmature", recursively: true
) {
    robot.position = SCNVector3(0, 0, -3)
}

Après l’importation, le modèle peut être animé via CAAnimation copiée depuis MDLAnimation, ou via SCNTransaction pour des changements de propriétés en douceur. Le système d’animation de SceneKit prend en charge le mélange entre animations et la synchronisation avec la physique pour créer des mouvements réalistes.

Animation et transactions

SCNTransaction permet de regrouper les changements de paramètres de la scène dans un bloc d’animation avec une durée spécifiée. Les méthodes begin() et commit() encadrent les changements, et duration définit le temps d’animation. Les transactions imbriquées sont prises en charge pour les animations parallèles avec des durées différentes. Un bloc completion s’exécute après la fin de l’animation.

Pour l’animation squelettique, SceneKit prend en charge SCNAnimation et SCNMorpher pour les blend shapes (morph targets). Chaque animation peut être bouclée, mise à l’échelle dans le temps et mélangée avec d’autres animations via un mélange additif. Selon Apple (2025), SceneKit prend en charge jusqu’à 4 animations mélangées simultanément par squelette.

Système de particules SCNParticleSystem

SCNParticleSystem est un système de particules intégré pour créer des effets : fumée, feu, pluie et étincelles. Les particules peuvent être émises depuis un point, une sphère, un cube ou une surface de géométrie. Paramètres : birthRate, particleLifeSpan, speed, acceleration et colorOverLife. Les systèmes de particules fonctionnent sur le GPU pour des performances maximales.

Selon Apple (2025), SCNParticleSystem prend en charge jusqu’à 100 000 particules à 60 FPS sur les appareils avec A16+. Les particules peuvent réagir aux collisions avec les corps physiques de la scène. Pour les effets complexes, plusieurs systèmes de particules avec des paramètres différents peuvent être combinés et attachés à des nœuds en mouvement.

SceneKit et ARKit : réalité augmentée

SceneKit est le framework de haut niveau préféré pour les applications ARKit. ARSCNView étend SCNView et synchronise automatiquement le monde 3D virtuel avec l’environnement réel. L’analyse d’image, la détection de plans et le suivi facial sont effectués par ARKit, tandis que le rendu est assuré par SceneKit.

ARSCNView et ARAnchor

ARSCNView prend en charge toutes les fonctionnalités de SCNView, mais remplace la caméra de la scène par la caméra réelle de l’appareil. ARKit analyse la vidéo de la caméra et crée des ARAnchors, que SceneKit convertit en SCNNodes. La session ARKit est gérée via la propriété session, configurée avec une configuration (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 propriété autoenablesDefaultLighting ajoute un éclairage intégré correspondant à l’environnement réel. ARKit 6 (iOS 18) prend en charge les Location Anchors pour lier des objets 3D à des coordonnées géographiques et le Room Tracking pour cartographier les espaces intérieurs avec un niveau de détail allant jusqu’aux meubles.

Détection de plans et placement d’objets

ARKit détecte les plans horizontaux et verticaux (sols, tables, murs) via le délégué didAdd/didUpdate/didRemove. Un nœud SceneKit lié à ARPlaneAnchor suit automatiquement la position du plan en temps réel. Pour placer des objets, on utilise la méthode hitTest sur ARSCNView ou raycastQuery.

Selon Apple (2025), la distance maximale de suivi d’ARKit sur A17 Pro est de 50 mètres avec un éclairage à partir de 10 lux. SceneKit + ARKit offrent une latence de bout en bout (motion-to-photon) inférieure à 20 ms, ce qui est essentiel pour les jeux AR et les applications industrielles avec superposition d’instructions 3D sur des équipements réels.