pt — apa itu, Poin dan penskalaan di iOS

Apa itu pt di iOS?

pt (point) — satuan ukuran logis di iOS yang memungkinkan pengembang mendeskripsikan antarmuka dalam koordinat abstrak, independen dari resolusi fisik layar. Apple memperkenalkan konsep point dengan dirilisnya iPhone 4 dan layar Retina pada tahun 2010. Sebelum Retina, pengembang menggunakan piksel secara langsung — satu piksel UI setara dengan satu piksel fisik.

Sistem koordinat iOS dibangun di atas titik: titik (0,0) berada di sudut kiri atas layar, sumbu X mengarah ke kanan, sumbu Y ke bawah. Ukuran layar dalam titik tetap konstan untuk setiap kelas perangkat: iPhone SE — 375×667 pt, iPhone 15 Pro — 393×852 pt, iPad — 768×1024 pt (potret), 1024×768 pt (lanskap). Resolusi fisik bisa 1179×2556 px (iPhone 15 Pro) — tetapi pengembang bekerja dengan titik.

Menurut Apple Human Interface Guidelines, titik adalah abstraksi fundamental UIKit. Semua framework — UIKit, SwiftUI, Core Graphics, SpriteKit — beroperasi dengan titik. Konversi ke piksel terjadi secara otomatis pada tahap rendering melalui UIScreen.nativeScale.

Faktor skala: @1x, @2x, @3x

Faktor skala (scale factor) menentukan berapa banyak piksel fisik yang sesuai dengan satu titik logis. Apple menggunakan tiga tingkat: @1x — 1 pt = 1 px (iPad mini tanpa Retina, model lama), @2x — 1 pt = 2 px (sebagian besar iPhone hingga 2020, iPad Retina), @3x — 1 pt = 3 px (iPhone X dan lebih baru, termasuk iPhone 15 Pro).

Nilai scale factor tersedia melalui UIScreen.main.scale (untuk UIKit) dan @Environment(\.displayScale) (untuk SwiftUI). Digunakan saat memuat aset: sistem secara otomatis memilih gambar dengan akhiran @2x atau @3x dari Assets.xcassets. Pengembang tidak memuat gambar @1x pada perangkat Retina — ini menurunkan kinerja dan kualitas.

CGPoint dan koordinat dalam titik

Struktur CGPoint — tipe dasar untuk representasi koordinat di iOS dan macOS. Berisi dua bidang: x (CGFloat) dan y (CGFloat), nilai diberikan dalam titik. CGPoint digunakan di semua framework Apple: UIKit (frame.origin), Core Graphics (CGContext), SpriteKit (SKNode.position), Core Animation (CALayer.position).

// CGPoint — bekerja dengan koordinat dalam titik
import UIKit

// Membuat titik
let point = CGPoint(x: 100.0, y: 200.0)
print("Koordinat: \(point.x), \(point.y)")

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

// Jarak antar titik
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)
}

// Konversi titik ke piksel
extension CGPoint {
    func toPixels(scale: CGFloat) -> CGPoint {
        CGPoint(x: x * scale, y: y * scale)
    }
}

Metode toPixels dalam contoh mendemonstrasikan konversi titik ke piksel fisik melalui UIScreen.main.scale. Di UIKit konversi ini terjadi secara otomatis saat rendering, tetapi di Core Graphics dan saat bekerja dengan Metal, pengembang mungkin memerlukan konversi eksplisit ke piksel. Semua perhitungan animasi, deteksi tabrakan, dan tata letak dilakukan dalam titik.

UIFont.pointSize dan tipografi

Properti UIFont.pointSize mengembalikan ukuran font dalam titik — ini adalah satuan tipografi standar di iOS, yang diwarisi dari percetakan (1 pt = 1/72 inci). Apple menggunakan pt untuk font sejak versi pertama Mac OS. Di iOS ukuran font diatur dalam titik melalui UIFont.systemFont(ofSize:) atau melalui SwiftUI Font.system(size:).

// Bekerja dengan UIFont.pointSize di Swift
import UIKit

// Membuat font dengan ukuran dalam pt
let titleFont = UIFont.systemFont(ofSize: 28.0, weight: .bold)
let bodyFont = UIFont.systemFont(ofSize: 17.0)
let captionFont = UIFont.systemFont(ofSize: 12.0)

// Membaca pointSize
print("Ukuran judul: \(titleFont.pointSize) pt")

// Tipe dinamis — penskalaan otomatis
let scaledFont = UIFontMetrics.default.scaledFont(for: bodyFont)
print("Diskalakan: \(scaledFont.pointSize) pt")

// Membandingkan ukuran font
func font(from size: CGFloat, weight: UIFont.Weight) -> UIFont {
    UIFont.systemFont(ofSize: size, weight: weight)
}

UIFontMetrics — mekanisme penskalaan dinamis font, ditambahkan di iOS 11. Secara otomatis menyesuaikan pointSize berdasarkan pengaturan aksesibilitas pengguna (Settings > Display & Brightness > Text Size). Tanpa menggunakan UIFontMetrics, font tidak akan diskalakan, yang melanggar persyaratan aksesibilitas WCAG.

pt vs px: perbedaan

Perbedaan antara pt dan px sangat penting untuk memahami pengembangan iOS. pt — satuan logis, px — satuan fisik. Satu titik dapat setara dengan 1, 2, atau 3 piksel tergantung pada scale factor. Pengembang beroperasi dengan titik, sistem mengubahnya menjadi piksel pada tahap rasterisasi.

Konsekuensi utama: ukuran antarmuka dalam titik sama di semua perangkat dari kelas yang sama. Layar selebar 375 pt — ini adalah iPhone SE dan iPhone 14 (model dasar). Perbedaannya hanya pada berapa banyak piksel fisik yang muat dalam 375 pt ini. Ini memastikan UI yang seragam tanpa adaptasi manual untuk setiap perangkat.

pt di SwiftUI

Di SwiftUI pengembang tidak beroperasi secara eksplisit dengan titik — semua ukuran diberikan melalui Dp (device-independent points, setara dengan pt). SwiftUI secara otomatis menerapkan scale factor saat rendering, tetapi menyediakan akses melalui environment value displayScale.

// SwiftUI — bekerja dengan titik dan scale factor
import SwiftUI

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

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

            Text("Teks utama contoh")
                .font(.body)

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

SwiftUI mengabstraksikan pt di tingkat framework. .font(.body) secara otomatis menggunakan Dynamic Type — ukuran font menyesuaikan dengan pengaturan pengguna. SwiftUI tidak mengizinkan pengaturan ukuran font dalam piksel — hanya melalui Font dan sistem tipografi. Ini menjamin aksesibilitas antarmuka tanpa upaya tambahan dari pengembang.