SceneKit: ce este, scene 3D și graful scenei

Ce este SceneKit?

SceneKit — este un framework pentru grafică 3D care face parte din SDK-ul Apple și a fost introdus în iOS 8 (2014). SceneKit oferă o API complet scriptabilă care funcționează pe Metal și OpenGL pentru crearea de scene 3D interactive. Framework-ul suportă importul de modele în formatele Collada (DAE), Alembic (ABC), USD și GLTF prin Model I/O.

Spre deosebire de API-urile de nivel jos (Metal, Vulkan), SceneKit preia gestionarea randării, iluminării și fizicii. Dezvoltatorul descrie scena declarativ: adaugă noduri, setează materiale și animații. SceneKit optimizează automat geometria, combină draw calls și gestionează LOD atunci când este necesar.

SceneKit poate lucra împreună cu ARKit pentru afișarea obiectelor 3D în lumea reală, precum și cu Core ML pentru vederea artificială și analiza scenei. Conform Apple (2025), cea mai recentă versiune SceneKit utilizează doar API-ul Metal cu suport pentru Metal 3 și GPU Family 9 pe cipurile Apple Silicon.

Istoria SceneKit

SceneKit a apărut pe macOS în 2012 ca parte a OS X Mountain Lion și inițial folosea OpenGL pentru randare. Odată cu lansarea iOS 8, framework-ul a devenit disponibil pe dispozitive mobile. Versiunea SceneKit 2.0 (iOS 10) a adăugat suport pentru materiale PBR, iluminare HDR și integrare cu Model I/O pentru importul modelelor.

În iOS 12, SceneKit a trecut complet la Metal. iOS 15 a introdus suport pentru formatul USDZ și AR Quick Look. Cu iOS 18 (2024), SceneKit a primit accelerarea hardware a trasării de raze pe dispozitivele cu cip A17 Pro și M4, permițând umbre și reflecții realiste în timp real pe dispozitive mobile.

Arhitectura SceneKit: graful scenei și nodurile

Arhitectura SceneKit se bazează pe graful scenei, unde SCNScene este elementul rădăcină ce conține ierarhia SCNNode. Fiecare nod are noduri copil și poate conține geometrie, cameră, lumină sau corp fizic. Poziția nodului este definită prin SCNVector3 (x, y, z) în sistemul de coordonate stâng.

SCNScene — containerul rădăcină

SCNScene conține întreaga stare a lumii 3D: nodul rădăcină rootNode, setările de fundal (background), sursele de lumină și lumea fizică (SCNPhysicsWorld). Scena poate fi încărcată dintr-un fișier .scn (SceneKit Scene Format) sau creată programatic. Formatul .scn este deschis și bazat pe JSON.

import SceneKit
 
let scene = SCNScene()
scene.background.contents = UIColor.darkGray
 
// Crearea camerei
let cameraNode = SCNNode()
cameraNode.camera = SCNCamera()
cameraNode.position = SCNVector3(0, 5, 10)
scene.rootNode.addChildNode(cameraNode)
 
// Crearea cubului cu fizică
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)

Clasa SCNCamera configurează proiecția perspectivă sau ortografică. Parametri: fieldOfView (unghiul de vizualizare, implicit 45°), zNear/zFar (planul de tăiere apropiat/depărtat). SceneKit gestionează automat matricea de proiecție pe baza acestor parametri și a raportului de aspect al ecranului.

SCNNode — nodurile scenei

SCNNode conectează geometria, transformarea și corpul fizic. Nodurile pot fi goale (containere pentru alte noduri) sau pot conține geometrie prin proprietatea geometry. Fiecare nod are un nume (name) pentru căutare programatică și poate fi animat prin CAAnimation sau SCNTransaction predefinite.

Transformarea nodului este definită prin proprietățile position (SCNVector3), rotation (SCNVector4) și scale (SCNVector3). Pentru transformări complexe se utilizează proprietatea transform (SCNMatrix4). De asemenea, sunt disponibile pivot — deplasarea centrului de transformare și worldPosition — poziția absolută în spațiul mondial independent de ierarhie.

SCNView — randarea

SCNView — UIView pentru afișarea SCNScene. Proprietatea allowsCameraControl activează controlul utilizatorului asupra camerei prin gesturi (deplasare, rotire, scalare). Pentru depanare sunt disponibile showsStatistics (FPS, draw calls, poligoane) și debugOptions (wireframe, bounding boxes).

În SwiftUI, SceneKit este încorporat prin SceneView, care îmbrășează SCNView și suportă legături la parametrii scenei. Conform Apple (2025), SceneView utilizează același renderer Metal ca SCNView, fără costuri suplimentare pentru puntea dintre SwiftUI și UIKit.

Materiale, iluminare și fizică în SceneKit

SCNMaterial definește modul în care suprafața geometriei interacționează cu lumina. SceneKit suportă PBR (Physically Based Rendering) prin SCNMaterial.LightingModel.physicallyBased, care utilizează parametrii roughness, metalness, albedo și normal. Materialele PBR arată realist în orice iluminare fără configurare manuală a strălucirii.

SCNMaterial și texturi

SCNMaterial are mai multe canale: diffuse (culoare/textură), specular (strălucire oglindă), normal (hartă normalelor), emission (emisie), roughness (rugozitate) și metalness (metalicitate). Fiecare canal poate conține UIColor, UIImage, CALayer sau SKScene pentru texturi animate.

// Material PBR pentru obiectul 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)

Parametrul roughness 0.3 cu metalness 0.8 creează un material asemănător metalului lustruit cu finisaj mat. Pentru dielectrici (lemn, plastic) metalness se setează la 0, iar pentru metale — aproape de 1.0. Materialele PBR se adaptează automat la iluminarea HDR a scenei.

Iluminarea în SceneKit

SCNLight suportă mai multe tipuri de surse de lumină: omni (punctuală), directional (direcțională), spot (reflector), ambient (ambientală) și area (de suprafață). Fiecare sursă are intensitate (intensity), culoare (color) și poate arunca umbre (castsShadow). SceneKit gestionează automat umbrele prin shadow maps.

SceneKit suportă iluminarea HDR cu compresie tonală (tone mapping). Proprietatea wantsHDR pe SCNView activează gama dinamică extinsă. Atributele camerei: whitePoint, adaptativeLuminance și exposure adaptează imaginea la luminozitatea scenei, creând un efect de expunere fotografică.

Fizica SCNPhysicsBody

SCNPhysicsBody simulează fizica corpurilor solide: gravitație, coliziuni și frecare. Tipuri de corpuri: .static (fix), .dynamic (sub acțiunea forțelor) și .kinematic (controlat programatic). Forma corpului este definită prin SCNPhysicsShape, care poate fi bazată pe geometria nodului sau pe o formă simplificată (box, sphere, concave polyhedron).

SCNPhysicsWorld gestionează fizica globală a scenei: gravitație (gravity), viteza de simulare (speed) și detectarea coliziunilor prin delegatul SCNPhysicsContactDelegate. SceneKit suportă articulații fizice (SCNPhysicsHingeJoint, SCNPhysicsBallJoint, SCNPhysicsSliderJoint) pentru crearea de mecanisme și obiecte conectate.

Dezvoltarea scenelor 3D în SceneKit

Dezvoltarea în SceneKit începe de obicei cu încărcarea unui model 3D prin Model I/O sau dintr-un fișier .scn. Editorul de scene din Xcode (Scene Editor) permite plasarea vizuală a obiectelor, configurarea materialelor și a iluminării fără cod. Fișierele .scn sunt salvate în format JSON și suportă controlul versiunilor prin git.

Importul modelelor 3D

Model I/O (ModelIO.framework) — un instrument puternic pentru importul, exportul și procesarea modelelor 3D. SceneKit poate utiliza direct obiectele MDLAsset, transformându-le în SCNScene. Formatele suportate: USD, USDZ, OBJ, STL, PLY, Collada (DAE) și Alembic (ABC). Modelele cu animații (animație scheletică, morphing) sunt de asemenea importate.

// Încărcarea modelului 3D prin Model I/O
import ModelIO
 
let url = Bundle.main.url(forResource: "robot",
    withExtension: "usdz")!
let asset = MDLAsset(url: url)
let scene = SCNScene(mdlAsset: asset)
 
// Căutarea nodurilor după nume pentru configurare
if let robot = scene.rootNode.childNode(
    withName: "RobotArmature", recursively: true
) {
    robot.position = SCNVector3(0, 0, -3)
}

După import, modelul poate fi animat prin CAAnimation, copiat din MDLAnimation, sau prin SCNTransaction pentru modificări line ale proprietăților. Sistemul de animație SceneKit suportă îmbinarea animațiilor și sincronizarea cu fizica pentru crearea de mișcări realiste.

Animație și tranzacții

SCNTransaction permite gruparea modificărilor parametrilor scenei într-un bloc de animație cu durată specificată. Metodele begin() și commit() încadrează modificările, iar duration setează durata animației. Tranzacțiile imbricate sunt suportate pentru animații paralele cu durate diferite. Blocul Completion se execută după încheierea animației.

Pentru animația scheletică, SceneKit suportă SCNAnimation și SCNMorpher pentru blend-shape-uri (morph targets). Fiecare animație poate fi buclată, scalată în timp și amestecată cu alte animații prin additive blending. Conform Apple (2025), SceneKit suportă până la 4 animații amestecate simultan pe un schelet.

Sistemele de particule SCNParticleSystem

SCNParticleSystem — sistemul încorporat de particule pentru crearea de efecte: fum, foc, ploaie și scântei. Particulele pot fi emise dintr-un punct, sferă, cub sau suprafața geometriei. Parametri: birthRate, particleLifeSpan, speed, acceleration și colorOverLife. Sistemele de particule funcționează pe GPU pentru performanță maximă.

Conform Apple (2025), SCNParticleSystem suportă până la 100 de mii de particule la 60 FPS pe dispozitivele cu A16+. Particulele pot reacționa la coliziuni cu corpurile fizice ale scenei. Pentru efecte complexe, pot fi combinate mai multe sisteme de particule cu parametri diferiți și legate de noduri în mișcare.

SceneKit și ARKit: realitate augmentată

SceneKit este framework-ul preferat de nivel înalt pentru aplicațiile ARKit. ARSCNView extinde SCNView și sincronizează automat lumea virtuală 3D cu mediul real. Analiza imaginii, detectarea planurilor și urmărirea feței sunt efectuate de ARKit, iar randarea — de SceneKit.

ARSCNView și ARAnchor

ARSCNView suportă toate funcțiile SCNView, dar înlocuiește camera scenei cu camera reală a dispozitivului. ARKit analizează video de la cameră și creează ARAnchor, pe care SceneKit le transformă în SCNNode. Sesiunea ARKit este gestionată prin proprietatea session, care se configurează cu o configurație (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
    }
}

Proprietatea autoenablesDefaultLighting adaugă iluminare încorporată corespunzătoare mediului real. ARKit 6 (iOS 18) suportă Location Anchors pentru ancorarea obiectelor 3D la coordonate geografice și Room Tracking pentru cartografierea interioarelor cu detaliu până la mobilier.

Detectarea planurilor și plasarea obiectelor

ARKit detectează planuri orizontale și verticale (podele, mese, pereți) prin delegatul didAdd/didUpdate/didRemove anchor. Nodul SceneKit legat de ARPlaneAnchor urmărește automat poziția planului în timp real. Pentru plasarea obiectelor se utilizează metoda hitTest pe ARSCNView sau raycastQuery.

Conform Apple (2025), distanța maximă de urmărire ARKit pe A17 Pro este de 50 de metri la o iluminare de 10 lux. SceneKit + ARKit asigură o întârziere finală (motion-to-photon) sub 20 ms, ceea ce este critic pentru jocurile AR și aplicațiile industriale cu suprapunerea instrucțiunilor 3D pe echipamente reale.