pt — co to jest, punkty i skalowanie w iOS

Czym jest pt w iOS?

pt (point) — logiczna jednostka miary w iOS, która pozwala programiście opisywać interfejs w abstrakcyjnych współrzędnych, niezależnych od fizycznej rozdzielczości wyświetlacza. Apple wprowadziło pojęcie pointów wraz z premierą iPhone 4 i wyświetlacza Retina w 2010 roku. Przed Retina programiści używali pikseli bezpośrednio — jeden piksel UI równał się jednemu fizycznemu pikselowi.

System współrzędnych iOS jest zbudowany na punktach: punkt (0,0) znajduje się w lewym górnym rogu ekranu, oś X skierowana w prawo, oś Y — w dół. Rozmiar ekranu w punktach pozostaje stały dla każdej klasy urządzeń: iPhone SE — 375×667 pt, iPhone 15 Pro — 393×852 pt, iPad — 768×1024 pt (pion), 1024×768 pt (poziom). Fizyczna rozdzielczość może przy tym wynosić 1179×2556 px (iPhone 15 Pro) — ale programista pracuje z punktami.

Według Apple Human Interface Guidelines, punkty są fundamentalną abstrakcją UIKit. Wszystkie frameworki — UIKit, SwiftUI, Core Graphics, SpriteKit — operują na punktach. Konwersja na piksele odbywa się automatycznie na etapie renderowania przez UIScreen.nativeScale.

Współczynniki skali: @1x, @2x, @3x

Współczynnik skali (scale factor) określa, ile fizycznych pikseli odpowiada jednemu logicznemu punktowi. Apple używa trzech poziomów: @1x — 1 pt = 1 px (iPad mini bez Retina, starsze modele), @2x — 1 pt = 2 px (większość iPhone'ów do 2020 roku, iPad Retina), @3x — 1 pt = 3 px (iPhone X i nowsze, w tym iPhone 15 Pro).

Wartość scale factor jest dostępna przez UIScreen.main.scale (dla UIKit) i @Environment(\.displayScale) (dla SwiftUI). Używana przy ładowaniu zasobów: system automatycznie wybiera obraz z sufiksem @2x lub @3x z Assets.xcassets. Programista nie ładuje obrazów @1x na urządzeniach z Retina — obniża to wydajność i jakość.

CGPoint i współrzędne w punktach

Struktura CGPoint — podstawowy typ do reprezentacji współrzędnych w iOS i macOS. Zawiera dwa pola: x (CGFloat) i y (CGFloat), wartości podawane są w punktach. CGPoint jest używany we wszystkich frameworkach Apple: UIKit (frame.origin), Core Graphics (CGContext), SpriteKit (SKNode.position), Core Animation (CALayer.position).

// CGPoint — praca z współrzędnymi w punktach
import UIKit

// Tworzenie punktu
let point = CGPoint(x: 100.0, y: 200.0)
print("Współrzędne: \(point.x), \(point.y)")

// Operacje matematyczne
let offset = CGPoint(x: 16.0, y: 8.0)
let translated = CGPoint(
    x: point.x + offset.x,
    y: point.y + offset.y
)

// Odległość między punktami
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)
}

// Konwersja punktu na piksele
extension CGPoint {
    func toPixels(scale: CGFloat) -> CGPoint {
        CGPoint(x: x * scale, y: y * scale)
    }
}

Metoda toPixels w przykładzie demonstruje konwersję punktów na fizyczne piksele przez UIScreen.main.scale. W UIKit ta konwersja odbywa się automatycznie podczas renderowania, ale w Core Graphics i przy pracy z Metal programista może potrzebować jawnego przeliczenia na piksele. Wszystkie obliczenia animacji, wykrywanie kolizji i układ są wykonywane w punktach.

UIFont.pointSize i typografia

Właściwość UIFont.pointSize zwraca rozmiar czcionki w punktach — to standardowa jednostka typografii w iOS, odziedziczona z poligrafii (1 pt = 1/72 cala). Apple używa pt dla czcionek od pierwszych wersji Mac OS. W iOS rozmiar czcionki ustawia się w punktach przez UIFont.systemFont(ofSize:) lub przez SwiftUI Font.system(size:).

// Praca z UIFont.pointSize w Swift
import UIKit

// Tworzenie czcionki z rozmiarem w pt
let titleFont = UIFont.systemFont(ofSize: 28.0, weight: .bold)
let bodyFont = UIFont.systemFont(ofSize: 17.0)
let captionFont = UIFont.systemFont(ofSize: 12.0)

// Odczyt pointSize
print("Rozmiar nagłówka: \(titleFont.pointSize) pt")

// Typ dynamiczny — automatyczne skalowanie
let scaledFont = UIFontMetrics.default.scaledFont(for: bodyFont)
print("Skalowany: \(scaledFont.pointSize) pt")

// Porównanie rozmiarów czcionek
func font(from size: CGFloat, weight: UIFont.Weight) -> UIFont {
    UIFont.systemFont(ofSize: size, weight: weight)
}

UIFontMetrics — mechanizm dynamicznego skalowania czcionek, dodany w iOS 11. Automatycznie koryguje pointSize w zależności od ustawień dostępności użytkownika (Settings > Display & Brightness > Text Size). Bez użycia UIFontMetrics czcionki nie są skalowane, co narusza wymagania WCAG dotyczące dostępności.

pt vs px: czym się różnią

Różnica między pt a px jest kluczowa dla zrozumienia iOS developmentu. pt — jednostka logiczna, px — fizyczna. Jeden punkt może odpowiadać 1, 2 lub 3 pikselom w zależności od scale factor. Programista operuje na punktach, system przekształca je na piksele na etapie rasteryzacji.

Kluczowa konsekwencja: rozmiar interfejsu w punktach jest taki sam na wszystkich urządzeniach tej samej klasy. Ekran o szerokości 375 pt — to zarówno iPhone SE, jak i iPhone 14 (model podstawowy). Różnica polega tylko na tym, ile fizycznych pikseli mieści się w tych 375 pt. Zapewnia to jednolity UI bez ręcznej adaptacji pod każde urządzenie.

pt w SwiftUI

W SwiftUI programista nie operuje jawnie na punktach — wszystkie rozmiary są podawane przez Dp (device-independent points, odpowiednik pt). SwiftUI automatycznie stosuje scale factor podczas renderowania, ale udostępnia do niego dostęp przez environment value displayScale.

// SwiftUI — praca z punktami i scale factor
import SwiftUI

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

    var body: some View {
        VStack(spacing: 16) {
            Text("Nagłówek")
                .font(.system(size: 28, weight: .bold))

            Text("Główny tekst przykładu")
                .font(.body)

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

SwiftUI abstrahuje pt na poziomie frameworka. .font(.body) automatycznie używa Dynamic Type — rozmiar czcionki dostosowuje się do ustawień użytkownika. SwiftUI nie pozwala ustawić rozmiaru czcionki w pikselach — tylko przez Font i system typografii. Gwarantuje to dostępność interfejsu bez dodatkowego wysiłku ze strony programisty.