SceneKit: qué es, escenas 3D y grafo de escena

¿Qué es SceneKit?

SceneKit es un framework para gráficos 3D que forma parte del SDK de Apple y se presentó en iOS 8 (2014). SceneKit proporciona una API completamente basada en escenas que funciona sobre Metal y OpenGL para crear escenas 3D interactivas. El framework admite la importación de modelos en formatos Collada (DAE), Alembic (ABC), USD y GLTF a través de Model I/O.

A diferencia de las API de bajo nivel (Metal, Vulkan), SceneKit se encarga de la gestión del renderizado, la iluminación y la física. El desarrollador describe la escena de forma declarativa: añade nodos, define materiales y animaciones. SceneKit optimiza automáticamente la geometría, fusiona draw calls y gestiona LOD cuando es necesario.

SceneKit puede funcionar junto con ARKit para mostrar objetos 3D en el mundo real, así como con Core ML para visión artificial y análisis de escenas. Según Apple (2025), la última versión de SceneKit utiliza exclusivamente la API de Metal con soporte para Metal 3 y GPU Family 9 en chips Apple Silicon.

Historia de SceneKit

SceneKit apareció en macOS en 2012 como parte de OS X Mountain Lion e inicialmente usaba OpenGL para renderizar. Con el lanzamiento de iOS 8, el framework estuvo disponible en dispositivos móviles. SceneKit 2.0 (iOS 10) añadió soporte para materiales PBR, iluminación HDR e integración con Model I/O para importación de modelos.

En iOS 12, SceneKit hizo la transición completa a Metal. iOS 15 introdujo soporte para el formato USDZ y AR Quick Look. Con iOS 18 (2024), SceneKit recibió aceleración por hardware de trazado de rayos en dispositivos con chip A17 Pro y M4, lo que permite sombras y reflejos realistas en tiempo real en dispositivos móviles.

Arquitectura de SceneKit: grafo de escena y nodos

La arquitectura de SceneKit se basa en un grafo de escena, donde SCNScene es el elemento raíz que contiene una jerarquía de SCNNode. Cada nodo tiene nodos hijos y puede contener geometría, una cámara, una luz o un cuerpo físico. La posición del nodo se define mediante SCNVector3 (x, y, z) en un sistema de coordenadas zurdo.

SCNScene — contenedor raíz

SCNScene contiene todo el estado del mundo 3D: el nodo raíz rootNode, la configuración de fondo, las fuentes de luz y el mundo físico (SCNPhysicsWorld). La escena se puede cargar desde un archivo .scn (SceneKit Scene Format) o crearse mediante programación. El formato .scn es abierto y está basado en JSON.

import SceneKit
 
let scene = SCNScene()
scene.background.contents = UIColor.darkGray
 
// Creación de una cámara
let cameraNode = SCNNode()
cameraNode.camera = SCNCamera()
cameraNode.position = SCNVector3(0, 5, 10)
scene.rootNode.addChildNode(cameraNode)
 
// Creación de un cubo con 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)

La clase SCNCamera configura la proyección en perspectiva u ortográfica. Parámetros: fieldOfView (ángulo de visión, por defecto 45°), zNear/zFar (plano de recorte cercano/lejano). SceneKit gestiona automáticamente la matriz de proyección basándose en estos parámetros y la relación de aspecto de la pantalla.

SCNNode — nodos de escena

SCNNode conecta geometría, transformación y cuerpo físico. Los nodos pueden estar vacíos (contenedores para otros nodos) o contener geometría mediante la propiedad geometry. Cada nodo tiene un nombre (name) para búsqueda programática y puede animarse mediante CAAnimation o SCNTransaction predefinidas.

La transformación del nodo se define mediante las propiedades position (SCNVector3), rotation (SCNVector4) y scale (SCNVector3). Para transformaciones complejas se utiliza la propiedad transform (SCNMatrix4). También están disponibles pivot — desplazamiento del centro de transformación, y worldPosition — posición absoluta en el espacio mundial independientemente de la jerarquía.

SCNView — renderizado

SCNView es un UIView para mostrar SCNScene. La propiedad allowsCameraControl permite el control de la cámara mediante gestos (desplazamiento, rotación, zoom). Para depuración están disponibles showsStatistics (FPS, draw calls, polígonos) y debugOptions (wireframe, bounding boxes).

En SwiftUI, SceneKit se integra mediante SceneView, que envuelve SCNView y admite enlaces a parámetros de la escena. Según Apple (2025), SceneView utiliza el mismo renderizador Metal que SCNView, sin sobrecarga adicional por el puente entre SwiftUI y UIKit.

Materiales, iluminación y física en SceneKit

SCNMaterial define cómo la superficie de la geometría interactúa con la luz. SceneKit admite PBR (Physically Based Rendering) mediante SCNMaterial.LightingModel.physicallyBased, que utiliza los parámetros roughness, metalness, albedo y normal. Los materiales PBR se ven realistas bajo cualquier iluminación sin necesidad de ajuste manual de brillos.

SCNMaterial y texturas

SCNMaterial tiene varios canales: diffuse (color/textura), specular (brillo especular), normal (mapa de normales), emission (brillo), roughness (rugosidad) y metalness (metalidad). Cada canal puede contener un UIColor, UIImage, CALayer o SKScene para texturas animadas.

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

El parámetro roughness 0.3 con metalness 0.8 crea un material similar al metal pulido con acabado mate. Para dieléctricos (madera, plástico), metalness se establece en 0, y para metales cerca de 1.0. Los materiales PBR se adaptan automáticamente a la iluminación HDR de la escena.

Iluminación en SceneKit

SCNLight admite varios tipos de fuentes de luz: omni (puntual), directional (direccional), spot (foco), ambient (ambiental) y area (de área). Cada fuente tiene intensidad, color y puede proyectar sombras (castsShadow). SceneKit gestiona automáticamente las sombras mediante shadow maps.

SceneKit admite iluminación HDR con compresión tonal (tone mapping). La propiedad wantsHDR en SCNView activa el rango dinámico ampliado. Atributos de cámara: whitePoint, adaptativeLuminance y exposure adaptan la imagen al brillo de la escena, creando un efecto de exposición fotográfica.

Física SCNPhysicsBody

SCNPhysicsBody simula la física de cuerpos rígidos: gravedad, colisiones y fricción. Tipos de cuerpo: .static (inmóvil), .dynamic (bajo la acción de fuerzas) y .kinematic (controlado mediante programación). La forma del cuerpo se define mediante SCNPhysicsShape, que puede basarse en la geometría del nodo o en una forma simplificada (box, sphere, concave polyhedron).

SCNPhysicsWorld gestiona la física global de la escena: gravedad, velocidad de simulación y detección de colisiones a través del delegado SCNPhysicsContactDelegate. SceneKit admite articulaciones físicas (SCNPhysicsHingeJoint, SCNPhysicsBallJoint, SCNPhysicsSliderJoint) para crear mecanismos y objetos conectados.

Desarrollo de escenas 3D con SceneKit

El desarrollo con SceneKit normalmente comienza con la carga de un modelo 3D mediante Model I/O o un archivo .scn. El editor de escenas en Xcode (Scene Editor) permite colocar objetos visualmente, configurar materiales e iluminación sin código. Los archivos .scn se guardan en formato JSON y admiten control de versiones mediante git.

Importación de modelos 3D

Model I/O (ModelIO.framework) es una herramienta potente para importar, exportar y procesar modelos 3D. SceneKit puede utilizar directamente objetos MDLAsset, convirtiéndolos en SCNScene. Formatos compatibles: USD, USDZ, OBJ, STL, PLY, Collada (DAE) y Alembic (ABC). También se importan modelos con animaciones (animación esquelética, morphing).

// Carga de un modelo 3D mediante Model I/O
import ModelIO
 
let url = Bundle.main.url(forResource: "robot",
    withExtension: "usdz")!
let asset = MDLAsset(url: url)
let scene = SCNScene(mdlAsset: asset)
 
// Búsqueda de nodos por nombre para configuración
if let robot = scene.rootNode.childNode(
    withName: "RobotArmature", recursively: true
) {
    robot.position = SCNVector3(0, 0, -3)
}

Después de la importación, el modelo se puede animar mediante CAAnimation copiado de MDLAnimation, o mediante SCNTransaction para cambios suaves de propiedades. El sistema de animación de SceneKit admite blending entre animaciones y sincronización con la física para crear movimientos realistas.

Animación y transacciones

SCNTransaction permite agrupar cambios de parámetros de la escena en un bloque de animación con una duración determinada. Los métodos begin() y commit() rodean los cambios, y duration establece el tiempo de animación. Se admiten transacciones anidadas para animaciones paralelas con diferentes duraciones. Un bloque completion se ejecuta después de que finaliza la animación.

Para animación esquelética, SceneKit admite SCNAnimation y SCNMorpher para blend shapes (morph targets). Cada animación puede repetirse en bucle, escalarse en el tiempo y mezclarse con otras animaciones mediante additive blending. Según Apple (2025), SceneKit admite hasta 4 animaciones mezcladas simultáneamente por esqueleto.

Sistema de partículas SCNParticleSystem

SCNParticleSystem es un sistema de partículas integrado para crear efectos: humo, fuego, lluvia y chispas. Las partículas pueden emitirse desde un punto, esfera, cubo o superficie de geometría. Parámetros: birthRate, particleLifeSpan, speed, acceleration y colorOverLife. Los sistemas de partículas funcionan en la GPU para máximo rendimiento.

Según Apple (2025), SCNParticleSystem admite hasta 100 mil partículas a 60 FPS en dispositivos con A16+. Las partículas pueden reaccionar a colisiones con cuerpos físicos de la escena. Para efectos complejos, se pueden combinar varios sistemas de partículas con diferentes parámetros y vincularlos a nodos en movimiento.

SceneKit y ARKit: realidad aumentada

SceneKit es el framework de alto nivel preferido para aplicaciones ARKit. ARSCNView extiende SCNView y sincroniza automáticamente el mundo 3D virtual con el entorno real. El análisis de imagen, la detección de planos y el seguimiento facial los realiza ARKit, mientras que el renderizado lo realiza SceneKit.

ARSCNView y ARAnchor

ARSCNView admite todas las funciones de SCNView, pero reemplaza la cámara de la escena por la cámara real del dispositivo. ARKit analiza el video de la cámara y crea ARAnchor, que SceneKit convierte en SCNNode. La sesión de ARKit se gestiona mediante la propiedad session, configurada con una configuración (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 propiedad autoenablesDefaultLighting añade iluminación incorporada que coincide con el entorno real. ARKit 6 (iOS 18) admite Location Anchors para vincular objetos 3D a coordenadas geográficas y Room Tracking para mapear espacios interiores con detalle a nivel de mobiliario.

Detección de planos y colocación de objetos

ARKit detecta planos horizontales y verticales (suelos, mesas, paredes) mediante el delegado didAdd/didUpdate/didRemove anchor. Un nodo de SceneKit vinculado a ARPlaneAnchor sigue automáticamente la posición del plano en tiempo real. Para colocar objetos se utiliza el método hitTest en ARSCNView o raycastQuery.

Según Apple (2025), la distancia máxima de seguimiento de ARKit en A17 Pro es de 50 metros con una iluminación desde 10 lux. SceneKit + ARKit proporcionan una latencia de extremo a extremo (motion-to-photon) inferior a 20 ms, lo que es fundamental para juegos AR y aplicaciones industriales con superposición de instrucciones 3D en equipos reales.