pt — qué es, Points y escalado en iOS

¿Qué es pt en iOS?

pt (point) — unidad lógica de medida en iOS que permite al desarrollador describir la interfaz en coordenadas abstractas, independientes de la resolución física de la pantalla. Apple introdujo el concepto de points con el lanzamiento del iPhone 4 y la pantalla Retina en 2010. Antes de Retina, los desarrolladores usaban píxeles directamente — un píxel de UI equivalía a un píxel físico.

El sistema de coordenadas de iOS se basa en puntos: el punto (0,0) está en la esquina superior izquierda de la pantalla, el eje X va hacia la derecha, el eje Y hacia abajo. El tamaño de pantalla en puntos permanece constante para cada clase de dispositivo: iPhone SE — 375×667 pt, iPhone 15 Pro — 393×852 pt, iPad — 768×1024 pt (vertical), 1024×768 pt (horizontal). La resolución física puede ser 1179×2556 px (iPhone 15 Pro) — pero el desarrollador trabaja con puntos.

Según las Apple Human Interface Guidelines, los puntos son la abstracción fundamental de UIKit. Todos los frameworks — UIKit, SwiftUI, Core Graphics, SpriteKit — operan en puntos. La conversión a píxeles ocurre automáticamente durante el renderizado a través de UIScreen.nativeScale.

Factores de escala: @1x, @2x, @3x

El factor de escala determina cuántos píxeles físicos corresponden a un punto lógico. Apple usa tres niveles: @1x — 1 pt = 1 px (iPad mini sin Retina, modelos antiguos), @2x — 1 pt = 2 px (la mayoría de iPhones anteriores a 2020, iPad Retina), @3x — 1 pt = 3 px (iPhone X y posteriores, incluido iPhone 15 Pro).

El factor de escala está disponible a través de UIScreen.main.scale (para UIKit) y @Environment(\.displayScale) (para SwiftUI). Se usa al cargar assets: el sistema selecciona automáticamente la imagen con el sufijo @2x o @3x de Assets.xcassets. El desarrollador no debe cargar imágenes @1x en dispositivos Retina — esto reduce el rendimiento y la calidad.

CGPoint y coordenadas en puntos

La estructura CGPoint es el tipo básico para representar coordenadas en iOS y macOS. Contiene dos campos: x (CGFloat) e y (CGFloat), los valores se especifican en puntos. CGPoint se usa en todos los frameworks de Apple: UIKit (frame.origin), Core Graphics (CGContext), SpriteKit (SKNode.position), Core Animation (CALayer.position).

// CGPoint — trabajo con coordenadas en puntos
import UIKit

// Creación de un punto
let point = CGPoint(x: 100.0, y: 200.0)
print("Coordenadas: \(point.x), \(point.y)")

// Operaciones matemáticas
let offset = CGPoint(x: 16.0, y: 8.0)
let translated = CGPoint(
    x: point.x + offset.x,
    y: point.y + offset.y
)

// Distancia entre puntos
func distance(from a: CGPoint, to b: CGPoint) -> CGFloat {
    let dx = b.x - a.x
    let dy = b.y - a.y
    return sqrt(dx * dx + dy * dy)
}

// Conversión de puntos a píxeles
extension CGPoint {
    func toPixels(scale: CGFloat) -> CGPoint {
        CGPoint(x: x * scale, y: y * scale)
    }
}

El método toPixels del ejemplo demuestra la conversión de puntos a píxeles físicos mediante UIScreen.main.scale. En UIKit esta conversión ocurre automáticamente durante el renderizado, pero en Core Graphics y al trabajar con Metal, el desarrollador puede necesitar una conversión explícita a píxeles. Todos los cálculos de animaciones, detección de colisiones y layout se realizan en puntos.

UIFont.pointSize y tipografía

La propiedad UIFont.pointSize devuelve el tamaño de fuente en puntos — es la unidad estándar de tipografía en iOS, heredada de la imprenta (1 pt = 1/72 pulgada). Apple usa pt para fuentes desde las primeras versiones de Mac OS. En iOS, el tamaño de fuente se especifica en puntos mediante UIFont.systemFont(ofSize:) o mediante SwiftUI Font.system(size:).

// Trabajo con UIFont.pointSize en Swift
import UIKit

// Creación de una fuente con tamaño en pt
let titleFont = UIFont.systemFont(ofSize: 28.0, weight: .bold)
let bodyFont = UIFont.systemFont(ofSize: 17.0)
let captionFont = UIFont.systemFont(ofSize: 12.0)

// Lectura de pointSize
print("Tamaño del título: \(titleFont.pointSize) pt")

// Dynamic Type — escalado automático
let scaledFont = UIFontMetrics.default.scaledFont(for: bodyFont)
print("Escalado: \(scaledFont.pointSize) pt")

// Comparación de tamaños de fuente
func font(from size: CGFloat, weight: UIFont.Weight) -> UIFont {
    UIFont.systemFont(ofSize: size, weight: weight)
}

UIFontMetrics es un mecanismo de escalado dinámico de fuentes añadido en iOS 11. Ajusta automáticamente el pointSize según la configuración de accesibilidad del usuario (Settings > Display & Brightness > Text Size). Sin UIFontMetrics, las fuentes no se escalan, lo que incumple los requisitos de accesibilidad WCAG.

pt vs px: diferencias

La diferencia entre pt y px es crítica para entender el desarrollo en iOS. pt es una unidad lógica, px es una unidad física. Un punto puede corresponder a 1, 2 o 3 píxeles según el factor de escala. El desarrollador opera en puntos, el sistema los convierte a píxeles en la etapa de rasterización.

Conclusión clave: el tamaño de la interfaz en puntos es el mismo en todos los dispositivos de la misma clase. Una pantalla de 375 pt de ancho — esto aplica tanto al iPhone SE como al iPhone 14 (modelo base). La única diferencia es cuántos píxeles físicos caben en esos 375 pt. Esto garantiza una UI uniforme sin adaptación manual para cada dispositivo.

pt en SwiftUI

En SwiftUI, el desarrollador no opera explícitamente con puntos — todos los tamaños se especifican mediante Dp (points independientes del dispositivo, equivalente a pt). SwiftUI aplica automáticamente el factor de escala durante el renderizado, pero proporciona acceso a él a través del valor de entorno displayScale.

// SwiftUI — trabajo con puntos y factor de escala
import SwiftUI

struct ContentView: View {
    @Environment(\.displayScale) private var displayScale

    var body: some View {
        VStack(spacing: 16) {
            Text("Título")
                .font(.system(size: 28, weight: .bold))

            Text("Texto de ejemplo del cuerpo")
                .font(.body)

            HStack {
                Text("Factor de escala:")
                    .font(.caption)
                Text("\(displayScale, specifier: "%.1f")")
                    .font(.caption.weight(.bold))
            }
        }
        .padding(20)
        .frame(width: 300)
    }
}

SwiftUI abstrae pt a nivel de framework. .font(.body) usa automáticamente Dynamic Type — el tamaño de fuente se ajusta a la configuración del usuario. SwiftUI no permite especificar el tamaño de fuente en píxeles — solo a través de Font y el sistema tipográfico. Esto garantiza la accesibilidad de la interfaz sin esfuerzo adicional del desarrollador.