SceneKit: co to jest, sceny 3D i graf sceny

Czym jest SceneKit?

SceneKit — to framework do grafiki 3D wchodzący w skład SDK Apple i wprowadzony w iOS 8 (2014). SceneKit zapewnia w pełni skryptowe API działające na Metal i OpenGL do tworzenia interaktywnych scen 3D. Framework obsługuje import modeli w formatach Collada (DAE), Alembic (ABC), USD i GLTF poprzez Model I/O.

W przeciwieństwie do niskopoziomowych API (Metal, Vulkan), SceneKit przejmuje zarządzanie renderowaniem, oświetleniem i fizyką. Deweloper opisuje scenę deklaratywnie: dodaje węzły, ustawia materiały i animacje. SceneKit automatycznie optymalizuje geometrię, łączy draw calls i zarządza LOD w razie potrzeby.

SceneKit może działać w parze z ARKit do wyświetlania obiektów 3D w rzeczywistym świecie, a także z Core ML do widzenia maszynowego i analizy sceny. Według Apple (2025), SceneKit najnowszej wersji używa tylko Metal API z obsługą Metal 3 i GPU Family 9 na układach Apple Silicon.

Historia SceneKit

SceneKit pojawił się na macOS w 2012 roku w składzie OS X Mountain Lion i początkowo używał OpenGL do renderowania. Wraz z wydaniem iOS 8 framework stał się dostępny na urządzeniach mobilnych. Wersja SceneKit 2.0 (iOS 10) dodała obsługę materiałów PBR, oświetlenia HDR i integrację z Model I/O do importu modeli.

W iOS 12 SceneKit całkowicie przeszedł na Metal. iOS 15 wprowadził obsługę formatu USDZ i AR Quick Look. Z iOS 18 (2024) SceneKit otrzymał sprzętowe przyspieszenie śledzenia promieni na urządzeniach z układem A17 Pro i M4, co pozwoliło na użycie realistycznych cieni i odbić w czasie rzeczywistym na urządzeniach mobilnych.

Architektura SceneKit: graf sceny i węzły

Architektura SceneKit opiera się na grafie sceny, gdzie SCNScene jest głównym elementem zawierającym hierarchię SCNNode. Każdy węzeł ma węzły potomne i może zawierać geometrię, kamerę, światło lub ciało fizyczne. Położenie węzła jest określane przez SCNVector3 (x, y, z) w lewostronnym układzie współrzędnych.

SCNScene — główny kontener

SCNScene zawiera cały stan świata 3D: główny węzeł rootNode, ustawienia tła (background), źródła światła i świat fizyczny (SCNPhysicsWorld). Scena może być załadowana z pliku .scn (SceneKit Scene Format) lub utworzona programowo. Format .scn jest otwarty i oparty na JSON.

import SceneKit
 
let scene = SCNScene()
scene.background.contents = UIColor.darkGray
 
// Tworzenie kamery
let cameraNode = SCNNode()
cameraNode.camera = SCNCamera()
cameraNode.position = SCNVector3(0, 5, 10)
scene.rootNode.addChildNode(cameraNode)
 
// Tworzenie kostki z fizyką
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)

Klasa SCNCamera konfiguruje projekcję perspektywiczną lub ortograficzną. Parametry: fieldOfView (kąt widzenia, domyślnie 45°), zNear/zFar (bliska/daleka płaszczyzna odcięcia). SceneKit automatycznie zarządza macierzą projekcji na podstawie tych parametrów i proporcji ekranu.

SCNNode — węzły sceny

SCNNode łączy geometrię, transformację i ciało fizyczne. Węzły mogą być puste (kontenery dla innych węzłów) lub zawierać geometrię poprzez właściwość geometry. Każdy węzeł ma nazwę (name) do programowego wyszukiwania i może być animowany przez CAAnimation lub predefiniowane SCNTransaction.

Transformacja węzła jest określana przez właściwości position (SCNVector3), rotation (SCNVector4) i scale (SCNVector3). Dla złożonych transformacji używa się właściwości transform (SCNMatrix4). Dostępne są również pivot — przesunięcie środka transformacji i worldPosition — bezwzględna pozycja w przestrzeni świata niezależnie od hierarchii.

SCNView — renderowanie

SCNView — UIView do wyświetlania SCNScene. Właściwość allowsCameraControl włącza sterowanie kamerą za pomocą gestów (przesuwanie, obracanie, skalowanie). Do debugowania dostępne są showsStatistics (FPS, draw calls, poligony) i debugOptions (wireframe, bounding boxes).

W SwiftUI SceneKit jest osadzany poprzez SceneView, która opakowuje SCNView i obsługuje powiązania z parametrami sceny. Według Apple (2025), SceneView używa tego samego rendere Metal co SCNView, bez dodatkowych narzutów na most między SwiftUI i UIKit.

Materiały, oświetlenie i fizyka w SceneKit

SCNMaterial określa, jak powierzchnia geometrii oddziałuje ze światłem. SceneKit obsługuje PBR (Physically Based Rendering) poprzez SCNMaterial.LightingModel.physicallyBased, który używa parametrów roughness, metalness, albedo i normal. Materiały PBR wyglądają realistycznie przy każdym oświetleniu bez ręcznej konfiguracji połysku.

SCNMaterial i tekstury

SCNMaterial ma kilka kanałów: diffuse (kolor/tekstura), specular (połysk), normal (mapa normalnych), emission (emitowanie światła), roughness (chropowatość) i metalness (metaliczność). Każdy kanał może zawierać UIColor, UIImage, CALayer lub SKScene dla animowanych tekstur.

// Materiał PBR dla obiektu 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)

Parametr roughness 0.3 z metalness 0.8 tworzy materiał przypominający polerowany metal z matowym wykończeniem. Dla dielektryków (drewno, plastik) metalness ustawia się na 0, a dla metali — blisko 1.0. Materiały PBR automatycznie dostosowują się do oświetlenia HDR sceny.

Oświetlenie w SceneKit

SCNLight obsługuje kilka typów źródeł światła: omni (punktowe), directional (kierunkowe), spot (reflektor), ambient (otoczenia) i area (powierzchniowe). Każde źródło ma intensywność (intensity), kolor (color) i może rzucać cienie (castsShadow). SceneKit automatycznie zarządza cieniami przez shadow maps.

SceneKit obsługuje oświetlenie HDR z kompresją tonalną (tone mapping). Właściwość wantsHDR na SCNView włącza rozszerzony zakres dynamiki. Atrybuty kamery: whitePoint, adaptativeLuminance i exposure dostosowują obraz do jasności sceny, tworząc efekt fotograficznej ekspozycji.

Fizyka SCNPhysicsBody

SCNPhysicsBody symuluje fizykę ciał stałych: grawitację, kolizje i tarcie. Typy ciał: .static (nieruchome), .dynamic (pod wpływem sił) i .kinematic (sterowane programowo). Kształt ciała jest określany przez SCNPhysicsShape, która może być oparta na geometrii węzła lub na uproszczonej formie (box, sphere, concave polyhedron).

SCNPhysicsWorld zarządza globalną fizyką sceny: grawitacja (gravity), prędkość symulacji (speed) i wykrywanie kolizji przez delegata SCNPhysicsContactDelegate. SceneKit obsługuje połączenia fizyczne (SCNPhysicsHingeJoint, SCNPhysicsBallJoint, SCNPhysicsSliderJoint) do tworzenia mechanizmów i połączonych obiektów.

Tworzenie scen 3D w SceneKit

Tworzenie w SceneKit zwykle rozpoczyna się od załadowania modelu 3D przez Model I/O lub plik .scn. Edytor scen w Xcode (Scene Editor) pozwala wizualnie rozmieszczać obiekty, konfigurować materiały i oświetlenie bez kodu. Pliki .scn są zapisywane w formacie JSON i obsługują kontrolę wersji przez git.

Import modeli 3D

Model I/O (ModelIO.framework) — potężne narzędzie do importu, eksportu i przetwarzania modeli 3D. SceneKit może bezpośrednio używać obiektów MDLAsset, przekształcając je w SCNScene. Obsługiwane formaty: USD, USDZ, OBJ, STL, PLY, Collada (DAE) i Alembic (ABC). Modele z animacjami (animacja szkieletowa, morphing) również są importowane.

// Wczytywanie modelu 3D przez Model I/O
import ModelIO
 
let url = Bundle.main.url(forResource: "robot",
    withExtension: "usdz")!
let asset = MDLAsset(url: url)
let scene = SCNScene(mdlAsset: asset)
 
// Wyszukiwanie węzłów po nazwie do konfiguracji
if let robot = scene.rootNode.childNode(
    withName: "RobotArmature", recursively: true
) {
    robot.position = SCNVector3(0, 0, -3)
}

Po imporcie model można animować przez CAAnimation, skopiowany z MDLAnimation, lub przez SCNTransaction dla płynnych zmian właściwości. System animacji SceneKit obsługuje miksowanie animacji i synchronizację z fizyką do tworzenia realistycznych ruchów.

Animacja i transakcje

SCNTransaction pozwala grupować zmiany parametrów sceny w blok animacyjny z określonym czasem trwania. Metody begin() i commit() otaczają zmiany, a duration określa czas animacji. Zagnieżdżone transakcje są obsługiwane dla równoległych animacji z różnym czasem trwania. Blok Completion jest wykonywany po zakończeniu animacji.

Do animacji szkieletowej SceneKit obsługuje SCNAnimation i SCNMorpher dla blend-shape (morph targets). Każda animacja może być zapętlona, skalowana w czasie i mieszana z innymi animacjami przez additive blending. Według Apple (2025), SceneKit obsługuje do 4 jednocześnie mieszanych animacji na jeden szkielet.

Systemy cząsteczek SCNParticleSystem

SCNParticleSystem — wbudowany system cząsteczek do tworzenia efektów: dymu, ognia, deszczu i iskier. Cząsteczki mogą być emitowane z punktu, sfery, sześcianu lub powierzchni geometrii. Parametry: birthRate, particleLifeSpan, speed, acceleration i colorOverLife. Systemy cząsteczek działają na GPU dla maksymalnej wydajności.

Według Apple (2025), SCNParticleSystem obsługuje do 100 tysięcy cząsteczek z częstotliwością 60 FPS na urządzeniach z A16+. Cząsteczki mogą reagować na kolizje z ciałami fizycznymi sceny. Dla złożonych efektów można łączyć kilka systemów cząsteczek z różnymi parametrami i wiązać z ruchomymi węzłami.

SceneKit i ARKit: rzeczywistość rozszerzona

SceneKit jest preferowanym wysokopoziomowym frameworkiem do aplikacji ARKit. ARSCNView rozszerza SCNView i automatycznie synchronizuje wirtualny świat 3D z rzeczywistym otoczeniem. Analiza obrazu, detekcja płaszczyzn i śledzenie twarzy są wykonywane przez ARKit, a renderowanie — przez SceneKit.

ARSCNView i ARAnchor

ARSCNView obsługuje wszystkie funkcje SCNView, ale zastępuje kamerę sceny rzeczywistą kamerą urządzenia. ARKit analizuje wideo z kamery i tworzy ARAnchor, które SceneKit przekształca w SCNNode. Sesja ARKit jest zarządzana przez właściwość session, która jest konfigurowana z konfiguracją (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
    }
}

Właściwość autoenablesDefaultLighting dodaje wbudowane oświetlenie odpowiadające rzeczywistemu otoczeniu. ARKit 6 (iOS 18) obsługuje Location Anchors do wiązania obiektów 3D ze współrzędnymi geograficznymi i Room Tracking do mapowania wnętrz z detalicznością do mebli.

Wykrywanie płaszczyzn i umieszczanie obiektów

ARKit wykrywa poziome i pionowe płaszczyzny (podłogi, stoły, ściany) przez delegata didAdd/didUpdate/didRemove anchor. Węzeł SceneKit powiązany z ARPlaneAnchor automatycznie śledzi położenie płaszczyzny w czasie rzeczywistym. Do umieszczania obiektów używa się metody hitTest na ARSCNView lub raycastQuery.

Według Apple (2025), maksymalna odległość śledzenia ARKit na A17 Pro wynosi 50 metrów przy oświetleniu od 10 luksów. SceneKit + ARKit zapewniają opóźnienie końcowe (motion-to-photon) poniżej 20 ms, co jest krytyczne dla gier AR i aplikacji przemysłowych z nakładaniem instrukcji 3D na rzeczywiste urządzenia.