SceneKit: o que é, cenas 3D e grafo de cena

O que é SceneKit?

SceneKit é um framework para gráficos 3D que faz parte do SDK da Apple e foi apresentado no iOS 8 (2014). O SceneKit fornece uma API totalmente baseada em cenas que funciona sobre Metal e OpenGL para criar cenas 3D interativas. O framework suporta importação de modelos nos formatos Collada (DAE), Alembic (ABC), USD e GLTF através do Model I/O.

Ao contrário das APIs de baixo nível (Metal, Vulkan), o SceneKit gerencia renderização, iluminação e física. O desenvolvedor descreve a cena declarativamente: adiciona nós, define materiais e animações. SceneKit otimiza automaticamente a geometria, mescla draw calls e gerencia LOD quando necessário.

O SceneKit pode trabalhar em conjunto com o ARKit para exibir objetos 3D no mundo real, bem como com o Core ML para visão computacional e análise de cena. De acordo com a Apple (2025), a versão mais recente do SceneKit usa apenas a API Metal com suporte para Metal 3 e GPU Family 9 em chips Apple Silicon.

História do SceneKit

O SceneKit apareceu no macOS em 2012 como parte do OS X Mountain Lion e inicialmente usava OpenGL para renderização. Com o lançamento do iOS 8, o framework tornou-se disponível em dispositivos móveis. O SceneKit 2.0 (iOS 10) adicionou suporte para materiais PBR, iluminação HDR e integração com Model I/O para importação de modelos.

No iOS 12, o SceneKit fez a transição completa para Metal. O iOS 15 introduziu suporte para o formato USDZ e AR Quick Look. Com o iOS 18 (2024), o SceneKit recebeu aceleração de hardware para ray tracing em dispositivos com chip A17 Pro e M4, permitindo sombras e reflexos realistas em tempo real em dispositivos móveis.

Arquitetura do SceneKit: grafo de cena e nós

A arquitetura do SceneKit é baseada em um grafo de cena, onde SCNScene é o elemento raiz contendo uma hierarquia de SCNNode. Cada nó tem nós filhos e pode conter geometria, câmera, luz ou corpo físico. A posição do nó é definida via SCNVector3 (x, y, z) em um sistema de coordenadas canhoto.

SCNScene — contêiner raiz

SCNScene contém todo o estado do mundo 3D: o nó raiz rootNode, configurações de fundo, fontes de luz e o mundo físico (SCNPhysicsWorld). A cena pode ser carregada de um arquivo .scn (SceneKit Scene Format) ou criada programaticamente. O formato .scn é aberto e baseado em JSON.

import SceneKit
 
let scene = SCNScene()
scene.background.contents = UIColor.darkGray
 
// Criação de uma câmera
let cameraNode = SCNNode()
cameraNode.camera = SCNCamera()
cameraNode.position = SCNVector3(0, 5, 10)
scene.rootNode.addChildNode(cameraNode)
 
// Criação de um cubo com física
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)

A classe SCNCamera configura projeção perspectiva ou ortográfica. Parâmetros: fieldOfView (ângulo de visão, padrão 45°), zNear/zFar (plano de corte próximo/distante). O SceneKit gerencia automaticamente a matriz de projeção com base nesses parâmetros e na proporção da tela.

SCNNode — nós da cena

SCNNode conecta geometria, transformação e corpo físico. Os nós podem estar vazios (contêineres para outros nós) ou conter geometria através da propriedade geometry. Cada nó tem um nome (name) para busca programática e pode ser animado via CAAnimation ou SCNTransaction predefinida.

A transformação do nó é definida através das propriedades position (SCNVector3), rotation (SCNVector4) e scale (SCNVector3). Para transformações complexas, a propriedade transform (SCNMatrix4) é usada. Também estão disponíveis pivot — deslocamento do centro de transformação, e worldPosition — posição absoluta no espaço mundial independentemente da hierarquia.

SCNView — renderização

SCNView é uma UIView para exibir SCNScene. A propriedade allowsCameraControl permite o controle da câmera por gestos (panorâmica, rotação, zoom). Para depuração, estão disponíveis showsStatistics (FPS, draw calls, polígonos) e debugOptions (wireframe, bounding boxes).

No SwiftUI, o SceneKit é incorporado via SceneView, que envolve SCNView e suporta ligações a parâmetros da cena. De acordo com a Apple (2025), o SceneView usa o mesmo renderizador Metal que o SCNView, sem sobrecarga adicional para a ponte entre SwiftUI e UIKit.

Materiais, iluminação e física no SceneKit

SCNMaterial define como a superfície da geometria interage com a luz. O SceneKit suporta PBR (Physically Based Rendering) através de SCNMaterial.LightingModel.physicallyBased, que usa os parâmetros roughness, metalness, albedo e normal. Os materiais PBR parecem realistas sob qualquer iluminação sem ajuste manual de brilho.

SCNMaterial e texturas

SCNMaterial tem vários slots: diffuse (cor/textura), specular (brilho especular), normal (mapa de normais), emission (brilho), roughness (rugosidade) e metalness (metalicidade). Cada slot pode conter UIColor, UIImage, CALayer ou SKScene para texturas animadas.

// Material PBR para um objeto 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)

O parâmetro roughness 0.3 com metalness 0.8 cria um material semelhante a metal polido com acabamento fosco. Para dielétricos (madeira, plástico), metalness é definido como 0, e para metais próximo de 1.0. Os materiais PBR adaptam-se automaticamente à iluminação HDR da cena.

Iluminação no SceneKit

SCNLight suporta vários tipos de fontes de luz: omni (pontual), directional (direcional), spot (foco), ambient (ambiente) e area (área). Cada fonte tem intensidade, cor e pode projetar sombras (castsShadow). O SceneKit gerencia automaticamente as sombras através de shadow maps.

O SceneKit suporta iluminação HDR com compressão tonal (tone mapping). A propriedade wantsHDR no SCNView ativa a faixa dinâmica estendida. Atributos de câmera: whitePoint, adaptativeLuminance e exposure adaptam a imagem ao brilho da cena, criando um efeito de exposição fotográfica.

Física SCNPhysicsBody

SCNPhysicsBody simula física de corpos rígidos: gravidade, colisões e atrito. Tipos de corpo: .static (imóvel), .dynamic (sob ação de forças) e .kinematic (controlado programaticamente). A forma do corpo é definida via SCNPhysicsShape, que pode ser baseada na geometria do nó ou em uma forma simplificada (box, sphere, concave polyhedron).

SCNPhysicsWorld gerencia a física global da cena: gravidade, velocidade de simulação e detecção de colisões através do delegado SCNPhysicsContactDelegate. O SceneKit suporta articulações físicas (SCNPhysicsHingeJoint, SCNPhysicsBallJoint, SCNPhysicsSliderJoint) para criar mecanismos e objetos conectados.

Desenvolvimento de cenas 3D com SceneKit

O desenvolvimento com SceneKit normalmente começa com o carregamento de um modelo 3D através do Model I/O ou de um arquivo .scn. O editor de cenas no Xcode (Scene Editor) permite posicionar objetos visualmente, configurar materiais e iluminação sem código. Os arquivos .scn são salvos em formato JSON e suportam controle de versão via git.

Importação de modelos 3D

Model I/O (ModelIO.framework) é uma ferramenta poderosa para importar, exportar e processar modelos 3D. O SceneKit pode usar diretamente objetos MDLAsset, convertendo-os em SCNScene. Formatos suportados: USD, USDZ, OBJ, STL, PLY, Collada (DAE) e Alembic (ABC). Modelos animados (animação esquelética, morphing) também são importados.

// Carregamento de um modelo 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)
 
// Busca de nós por nome para configuração
if let robot = scene.rootNode.childNode(
    withName: "RobotArmature", recursively: true
) {
    robot.position = SCNVector3(0, 0, -3)
}

Após a importação, o modelo pode ser animado via CAAnimation copiada do MDLAnimation, ou via SCNTransaction para alterações suaves de propriedades. O sistema de animação do SceneKit suporta blending entre animações e sincronização com a física para criar movimentos realistas.

Animação e transações

SCNTransaction permite agrupar alterações de parâmetros da cena em um bloco de animação com duração especificada. Os métodos begin() e commit() envolvem as alterações, e duration define o tempo de animação. Transações aninhadas são suportadas para animações paralelas com durações diferentes. Um bloco completion é executado após a animação terminar.

Para animação esquelética, o SceneKit suporta SCNAnimation e SCNMorpher para blend shapes (morph targets). Cada animação pode ser repetida em loop, escalada no tempo e misturada com outras animações através de additive blending. De acordo com a Apple (2025), o SceneKit suporta até 4 animações misturadas simultaneamente por esqueleto.

Sistema de partículas SCNParticleSystem

SCNParticleSystem é um sistema de partículas integrado para criar efeitos: fumaça, fogo, chuva e faíscas. As partículas podem ser emitidas de um ponto, esfera, cubo ou superfície de geometria. Parâmetros: birthRate, particleLifeSpan, speed, acceleration e colorOverLife. Os sistemas de partículas funcionam na GPU para máximo desempenho.

De acordo com a Apple (2025), o SCNParticleSystem suporta até 100 mil partículas a 60 FPS em dispositivos com A16+. As partículas podem reagir a colisões com corpos físicos da cena. Para efeitos complexos, vários sistemas de partículas com parâmetros diferentes podem ser combinados e anexados a nós em movimento.

SceneKit e ARKit: realidade aumentada

SceneKit é o framework de alto nível preferido para aplicações ARKit. ARSCNView estende SCNView e sincroniza automaticamente o mundo 3D virtual com o ambiente real. A análise de imagem, detecção de planos e rastreamento facial são realizados pelo ARKit, enquanto a renderização é feita pelo SceneKit.

ARSCNView e ARAnchor

ARSCNView suporta todos os recursos do SCNView, mas substitui a câmera da cena pela câmera real do dispositivo. O ARKit analisa o vídeo da câmera e cria ARAnchors, que o SceneKit converte em SCNNodes. A sessão do ARKit é gerenciada através da propriedade session, configurada com uma configuração (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
    }
}

A propriedade autoenablesDefaultLighting adiciona iluminação embutida que corresponde ao ambiente real. O ARKit 6 (iOS 18) suporta Location Anchors para vincular objetos 3D a coordenadas geográficas e Room Tracking para mapear espaços internos com detalhes ao nível de mobiliário.

Detecção de planos e colocação de objetos

O ARKit detecta planos horizontais e verticais (pisos, mesas, paredes) através do delegado didAdd/didUpdate/didRemove anchor. Um nó do SceneKit vinculado ao ARPlaneAnchor rastreia automaticamente a posição do plano em tempo real. Para colocação de objetos, usa-se o método hitTest no ARSCNView ou raycastQuery.

De acordo com a Apple (2025), a distância máxima de rastreamento do ARKit no A17 Pro é de 50 metros com iluminação a partir de 10 lux. SceneKit + ARKit fornecem latência de ponta a ponta (motion-to-photon) inferior a 20 ms, o que é crítico para jogos AR e aplicações industriais com sobreposição de instruções 3D em equipamentos reais.