Tutorial 12 mnt baca

Panduan Lengkap Chart3D di SwiftUI iOS 26: Visualisasi Data 3D Tanpa Library Tambahan

Pelajari cara menggunakan Chart3D di SwiftUI iOS 26 untuk membuat visualisasi data 3D yang interaktif. Dari PointMark, SurfacePlot, kustomisasi kamera, sampai best practices — lengkap dengan contoh kode yang bisa langsung dipakai.

Editorial Team

Pendahuluan: Swift Charts Sekarang Bisa 3D

Kalau kamu pernah pakai Swift Charts untuk bikin grafik di aplikasi iOS, pasti tahu betapa mudahnya. Beberapa baris kode, dan — boom — bar chart, line chart, atau scatter plot langsung jadi. Tapi selama ini, semua itu cuma dua dimensi. Butuh grafik 3D? Yah, siap-siap cari library pihak ketiga, atau malah harus turun ke SceneKit yang setupnya... lumayan bikin pusing.

Nah, di iOS 26, Apple akhirnya membawa Swift Charts ke dimensi ketiga lewat Chart3D. Sekarang kamu bisa bikin scatter plot 3D, surface plot, dan berbagai visualisasi tiga dimensi langsung pakai SwiftUI — tanpa library tambahan, tanpa SceneKit.

Yang bikin saya excited? API-nya terasa sangat familiar kalau kamu sudah pernah pakai Swift Charts 2D. Transisinya mulus banget. Dan yang paling penting: chart-nya interaktif secara bawaan — user bisa drag untuk rotate, zoom, dan explore data dari berbagai sudut pandang.

Di artikel ini, kita bahas tuntas tentang Chart3D di SwiftUI iOS 26. Mulai dari konsep dasar, berbagai jenis mark, SurfacePlot, kustomisasi kamera, sampai best practices. Ayo mulai.

Persyaratan Sebelum Mulai

Sebelum coding, pastikan environment kamu sudah siap:

  • Xcode 26 atau lebih baru
  • iOS 26 SDK (juga tersedia di macOS 26, watchOS 26, dan visionOS 26)
  • Deployment target minimal iOS 26.0
  • Import framework Charts di file Swift kamu

Perlu dicatat, Chart3D ini fitur baru di iOS 26 — jadi nggak ada backward compatibility ke versi sebelumnya. Tapi kalau kamu lagi mulai proyek baru atau target audiensmu memang sudah banyak yang update, fitur ini sangat worth it untuk dicoba.

Mengenal Chart3D: Container Utama untuk Grafik 3D

Kalau di Swift Charts 2D kamu pakai Chart, untuk 3D tinggal ganti jadi Chart3D. Sesimpel itu. Struktur dasarnya sangat mirip:

import Charts
import SwiftUI

struct Basic3DChartView: View {
    var body: some View {
        Chart3D {
            // Mark-mark kamu di sini
        }
        .frame(height: 400)
    }
}

Di dalam Chart3D, kamu bisa pakai mark-mark yang sudah familiar — PointMark, RuleMark, RectangleMark — semuanya sekarang mendukung sumbu Z. Plus, ada satu mark baru yang eksklusif untuk 3D: SurfacePlot. (Kita bahas detailnya nanti.)

PointMark 3D: Scatter Plot Tiga Dimensi

Kita mulai dari yang paling dasar dan mungkin paling sering kamu pakai: PointMark dengan tiga sumbu. Konsepnya simpel — setiap data point punya posisi X, Y, dan Z.

Menyiapkan Data Model

Pertama, kita butuh data tiga dimensi. Sebagai contoh, kita pakai dataset sensor cuaca — ini cukup relatable dan gampang dibayangkan:

struct WeatherReading: Identifiable {
    let id = UUID()
    let temperature: Double  // Suhu (°C)
    let humidity: Double     // Kelembaban (%)
    let windSpeed: Double    // Kecepatan angin (km/h)
    let location: String     // Lokasi

    static let sampleData: [WeatherReading] = [
        WeatherReading(temperature: 28, humidity: 75, windSpeed: 12, location: "Jakarta"),
        WeatherReading(temperature: 32, humidity: 60, windSpeed: 8, location: "Jakarta"),
        WeatherReading(temperature: 25, humidity: 85, windSpeed: 15, location: "Bandung"),
        WeatherReading(temperature: 22, humidity: 90, windSpeed: 20, location: "Bandung"),
        WeatherReading(temperature: 30, humidity: 65, windSpeed: 10, location: "Surabaya"),
        WeatherReading(temperature: 34, humidity: 55, windSpeed: 6, location: "Surabaya"),
        WeatherReading(temperature: 27, humidity: 80, windSpeed: 18, location: "Yogyakarta"),
        WeatherReading(temperature: 24, humidity: 88, windSpeed: 22, location: "Yogyakarta"),
        WeatherReading(temperature: 31, humidity: 70, windSpeed: 9, location: "Semarang"),
        WeatherReading(temperature: 29, humidity: 72, windSpeed: 14, location: "Semarang"),
    ]
}

Membuat Scatter Plot 3D

Sekarang bikin chart-nya:

struct WeatherScatterView: View {
    var body: some View {
        Chart3D(WeatherReading.sampleData) { reading in
            PointMark(
                x: .value("Suhu", reading.temperature),
                y: .value("Kelembaban", reading.humidity),
                z: .value("Kecepatan Angin", reading.windSpeed)
            )
            .foregroundStyle(by: .value("Lokasi", reading.location))
        }
        .chartXAxisLabel("Suhu (°C)")
        .chartYAxisLabel("Kelembaban (%)")
        .chartZAxisLabel("Kecepatan Angin (km/h)")
        .frame(height: 400)
    }
}

Dan... itu saja. Kamu sekarang punya scatter plot 3D yang menampilkan hubungan antara suhu, kelembaban, dan kecepatan angin di berbagai kota. Setiap lokasi punya warna berbeda berkat .foregroundStyle(by:), dan user bisa drag chart untuk melihatnya dari berbagai sudut. Tanpa satu baris kode interaksi tambahan.

Jujur aja, pertama kali saya coba ini dan lihat chart-nya bisa dirotasi pakai gesture, saya langsung kagum sendiri. Terasa seperti "ini beneran gratis dari framework?"

Mengubah Simbol 3D

Secara default, PointMark di 3D pakai simbol sphere (bola). Tapi kamu bisa ganti:

PointMark(
    x: .value("Suhu", reading.temperature),
    y: .value("Kelembaban", reading.humidity),
    z: .value("Kecepatan Angin", reading.windSpeed)
)
.symbol(.cube)       // Bisa: .sphere, .cube, .cylinder, .cone
.symbolSize(0.05)    // Mengatur ukuran simbol

Pilihan simbol yang tersedia:

  • .sphere — bola (default), cocok untuk scatter plot umum
  • .cube — kubus, bagus untuk data kategorikal
  • .cylinder — silinder, cocok untuk data temporal
  • .cone — kerucut, bisa menunjukkan arah atau tren

SurfacePlot: Visualisasi Permukaan Matematika

Ini yang benar-benar baru dan cuma ada di Chart3D. SurfacePlot memungkinkan kamu memvisualisasikan fungsi matematika sebagai permukaan tiga dimensi yang kontinu. Kalau kamu pernah lihat grafik 3D di buku kalkulus — ya, sekarang kamu bisa bikin itu di SwiftUI.

Konsepnya begini: kamu kasih closure yang menerima dua parameter (nilai X dan Z) dan mengembalikan satu nilai (Y). Chart3D mengevaluasi ekspresi ini untuk berbagai nilai X dan Z, lalu membangun permukaan dari hasilnya.

SurfacePlot Sederhana

struct SimpleSurfaceView: View {
    var body: some View {
        Chart3D {
            SurfacePlot(x: "X", y: "Tinggi", z: "Z") { x, z in
                sin(x) * cos(z)
            }
            .foregroundStyle(.heightBased)
        }
        .frame(height: 400)
    }
}

Hasilnya? Permukaan gelombang yang cukup indah, di mana warnanya berubah berdasarkan ketinggian. Modifier .foregroundStyle(.heightBased) otomatis memberikan warna berbeda berdasarkan nilai Y — titik tinggi beda warna dengan titik rendah. Simpel tapi efeknya lumayan dramatis.

Opsi foregroundStyle untuk SurfacePlot

SurfacePlot punya beberapa opsi khusus untuk styling permukaan:

  • .heightBased — mewarnai berdasarkan ketinggian permukaan
  • .normalBased — mewarnai berdasarkan sudut atau kemiringan permukaan
  • LinearGradient — gradient linier custom
  • EllipticalGradient — gradient elips custom
// Contoh dengan gradient custom
SurfacePlot(x: "X", y: "Y", z: "Z") { x, z in
    sin(x) * cos(z)
}
.foregroundStyle(
    EllipticalGradient(colors: [.red, .orange, .yellow, .green, .blue])
)

Contoh Praktis: Visualisasi Topografi

SurfacePlot cocok banget untuk kasus nyata seperti visualisasi topografi atau model prediksi. Ini contoh yang lebih realistis:

struct TopographyView: View {
    var body: some View {
        Chart3D {
            SurfacePlot(
                x: "Longitude",
                y: "Elevasi",
                z: "Latitude"
            ) { longitude, latitude in
                // Simulasi terrain dengan kombinasi fungsi sinus
                let hill1 = 3.0 * exp(-((longitude - 2) * (longitude - 2) + (latitude - 2) * (latitude - 2)) / 2)
                let hill2 = 2.0 * exp(-((longitude + 1) * (longitude + 1) + (latitude + 1) * (latitude + 1)) / 3)
                let valley = -1.5 * exp(-((longitude) * (longitude) + (latitude - 1) * (latitude - 1)) / 1.5)
                return hill1 + hill2 + valley
            }
            .foregroundStyle(.heightBased)
        }
        .chartXAxisLabel("Longitude")
        .chartYAxisLabel("Elevasi (m)")
        .chartZAxisLabel("Latitude")
        .frame(height: 450)
    }
}

Kode di atas mensimulasikan terrain sederhana dengan dua bukit dan satu lembah. Di aplikasi nyata, kamu tinggal ganti closure ini dengan data elevasi dari API atau database. Menurut saya, ini salah satu use case paling menarik dari SurfacePlot.

RuleMark dan RectangleMark 3D

Selain PointMark dan SurfacePlot, kamu juga bisa pakai RuleMark dan RectangleMark di dalam Chart3D. Keduanya sekarang support sumbu Z.

RuleMark 3D — Garis Referensi dalam Ruang 3D

RuleMark berguna untuk menambahkan garis referensi atau threshold. Misalnya, menandai batas suhu rata-rata:

Chart3D(WeatherReading.sampleData) { reading in
    PointMark(
        x: .value("Suhu", reading.temperature),
        y: .value("Kelembaban", reading.humidity),
        z: .value("Angin", reading.windSpeed)
    )
    .foregroundStyle(by: .value("Lokasi", reading.location))

    // Garis referensi suhu rata-rata
    RuleMark(x: .value("Rata-rata Suhu", 28))
        .foregroundStyle(.red.opacity(0.5))
}

RectangleMark 3D — Area dan Region

RectangleMark cocok untuk menandai region atau zona tertentu di ruang 3D. Misalnya, highlighting "zona nyaman" dalam dataset cuaca:

Chart3D {
    // Data points
    ForEach(WeatherReading.sampleData) { reading in
        PointMark(
            x: .value("Suhu", reading.temperature),
            y: .value("Kelembaban", reading.humidity),
            z: .value("Angin", reading.windSpeed)
        )
    }

    // Region "zona nyaman"
    RectangleMark(
        xStart: .value("Min Suhu", 24),
        xEnd: .value("Max Suhu", 30),
        yStart: .value("Min Kelembaban", 60),
        yEnd: .value("Max Kelembaban", 80)
    )
    .foregroundStyle(.green.opacity(0.2))
}

Dengan menggabungkan berbagai mark ini, kamu bisa bikin visualisasi 3D yang informatif sekaligus mudah dipahami. Nggak harus rumit untuk terlihat profesional.

Mengatur Kamera: Chart3DPose dan Proyeksi

So, salah satu aspek paling krusial dari grafik 3D adalah sudut pandang. Chart yang sama bisa terlihat sangat berbeda tergantung dari mana kamu melihatnya. Di sinilah Chart3DPose dan sistem proyeksi berperan.

Chart3DPose — Mengatur Sudut Pandang

Chart3DPose mengontrol dari sudut mana chart dilihat. Dua parameter utamanya:

  • Azimuth — rotasi horizontal (kiri-kanan)
  • Inclination — kemiringan vertikal (atas-bawah)
Chart3D {
    // marks...
}
.chart3DPose(
    Chart3DPose(
        azimuth: .degrees(30),
        inclination: .degrees(15)
    )
)

Ada juga beberapa pose predefined yang bisa langsung dipakai:

  • .default — sudut pandang standar
  • .front — tampilan depan
  • .back — tampilan belakang
  • .left — tampilan samping kiri
  • .right — tampilan samping kanan

Interaksi Drag-to-Rotate

Ini fitur yang bikin Chart3D benar-benar terasa hidup. Dengan meng-bind pose ke @State variable, user bisa memutar chart pakai gesture drag:

struct InteractiveChartView: View {
    @State private var pose = Chart3DPose(
        azimuth: .degrees(30),
        inclination: .degrees(15)
    )

    var body: some View {
        Chart3D(WeatherReading.sampleData) { reading in
            PointMark(
                x: .value("Suhu", reading.temperature),
                y: .value("Kelembaban", reading.humidity),
                z: .value("Angin", reading.windSpeed)
            )
            .foregroundStyle(by: .value("Lokasi", reading.location))
        }
        .chart3DPose($pose)  // Binding! Sekarang bisa di-drag
        .frame(height: 400)
    }
}

Perhatikan bedanya: kalau kamu pass value Chart3DPose biasa (tanpa $), pose-nya fixed. Kalau pass binding (dengan $), user bisa rotate secara interaktif. Pilih sesuai kebutuhan — kadang kamu memang sengaja ingin sudut pandang yang fixed untuk menekankan pola tertentu.

Animasi Rotasi Otomatis

Mau chart yang berputar terus secara otomatis? Bisa:

struct RotatingChartView: View {
    @State private var azimuthDegrees: Double = 0
    let timer = Timer.publish(every: 0.05, on: .main, in: .common).autoconnect()

    var body: some View {
        Chart3D {
            SurfacePlot(x: "X", y: "Y", z: "Z") { x, z in
                sin(x) * cos(z)
            }
            .foregroundStyle(.heightBased)
        }
        .chart3DPose(
            Chart3DPose(
                azimuth: .degrees(azimuthDegrees),
                inclination: .degrees(20)
            )
        )
        .onReceive(timer) { _ in
            azimuthDegrees += 0.5
            if azimuthDegrees >= 360 {
                azimuthDegrees = 0
            }
        }
        .frame(height: 400)
    }
}

Efek ini cocok banget untuk showcase atau demo, di mana kamu pengen user melihat data dari semua sudut tanpa harus interaksi manual. Cukup efektif untuk presentasi juga, kalau boleh saya tambahkan.

Proyeksi Kamera: Orthographic vs Perspective

Chart3D menawarkan dua jenis proyeksi kamera:

  • Orthographic (default) — Semua objek berukuran sama terlepas dari jaraknya. Perbandingan ukuran dan jarak jadi lebih akurat. Bonus: kalau kamu lihat chart dari samping, ini praktis mengubah chart 3D jadi 2D.
  • Perspective — Objek dekat tampak lebih besar, yang jauh lebih kecil. Memberikan kesan kedalaman yang lebih realistis — sangat cocok untuk visionOS atau pengalaman interaktif.
Chart3D {
    // marks...
}
.chart3DCameraProjection(.perspective)

Kapan pakai yang mana? Gunakan orthographic kalau akurasi data lebih penting. Gunakan perspective kalau kamu prioritaskan pengalaman visual yang imersif.

Kustomisasi Sumbu dan Skala

Sama seperti chart 2D, kamu bisa mengustomisasi skala dan label untuk setiap sumbu. Yang baru di sini: ada modifier untuk sumbu Z.

Mengatur Domain dan Range

Chart3D(WeatherReading.sampleData) { reading in
    PointMark(
        x: .value("Suhu", reading.temperature),
        y: .value("Kelembaban", reading.humidity),
        z: .value("Angin", reading.windSpeed)
    )
}
.chartXScale(domain: 20...36, range: -1.5...1.5)
.chartYScale(domain: 50...95, range: -1.0...1.0)
.chartZScale(domain: 5...25, range: -0.5...0.5)

Parameter domain menentukan rentang data yang ditampilkan, sedangkan range menentukan ukuran fisik chart di ruang 3D. Menyesuaikan range bisa membantu menekankan — atau justru menekan — aspek tertentu dari data kamu.

Label Sumbu

.chartXAxisLabel("Suhu (°C)")
.chartYAxisLabel("Kelembaban (%)")
.chartZAxisLabel("Kecepatan Angin (km/h)")

Selalu tambahkan label sumbu. Ini penting. Grafik 3D bisa sangat membingungkan kalau user nggak tahu sumbu mana yang merepresentasikan apa. Label yang jelas adalah perbedaan antara chart yang informatif dan chart yang cuma kelihatan keren tapi nggak ada gunanya.

Menggabungkan Beberapa Mark dalam Satu Chart

Salah satu kekuatan Chart3D adalah bisa menggabungkan berbagai jenis mark. Kamu bisa overlay PointMark di atas SurfacePlot, atau nambahin RuleMark sebagai referensi di scatter plot.

struct CombinedChartView: View {
    var body: some View {
        Chart3D {
            // Surface sebagai "landscape"
            SurfacePlot(x: "X", y: "Prediksi", z: "Z") { x, z in
                2.0 * x + 1.5 * z + 0.5 * x * z
            }
            .foregroundStyle(.heightBased)
            .opacity(0.6)

            // Data aktual sebagai titik-titik
            ForEach(measurementData) { point in
                PointMark(
                    x: .value("X", point.x),
                    y: .value("Aktual", point.y),
                    z: .value("Z", point.z)
                )
                .foregroundStyle(.red)
                .symbol(.sphere)
                .symbolSize(0.04)
            }
        }
        .chartXAxisLabel("Variabel X")
        .chartYAxisLabel("Nilai")
        .chartZAxisLabel("Variabel Z")
        .frame(height: 450)
    }
}

Contoh di atas menampilkan surface plot semi-transparan sebagai model prediksi, dengan data aktual ditampilkan sebagai titik-titik merah di atasnya. Pola ini sangat umum di data science — membandingkan model dengan observasi nyata. Dan sejujurnya, hasilnya cukup satisfying secara visual.

Best Practices: Kapan Pakai Chart 3D?

Grafik 3D memang keren. Tapi bukan berarti semuanya harus 3D. (Percaya deh, saya juga tergoda awalnya.) Apple sendiri punya panduan yang jelas soal ini.

Gunakan 3D Chart Ketika:

  • Data kamu memang tiga dimensi — misalnya posisi fisik di ruang 3D, atau tiga variabel yang saling berkaitan
  • Bentuk keseluruhan data lebih penting dari nilai eksak — 3D bagus untuk melihat pola, cluster, dan distribusi secara visual
  • Interaktivitas tersedia — 3D chart perlu bisa dirotasi agar benar-benar bermanfaat, jadi pastikan konteksnya mendukung interaksi
  • Platform mendukung — visionOS jelas tempat paling natural untuk grafik 3D

Tetap Pakai 2D Chart Ketika:

  • User perlu membaca nilai eksak — presisi lebih sulit di 3D karena depth perception
  • Data cuma punya dua dimensi — jangan paksa data 2D ke 3D cuma karena bisa
  • Chart ditampilkan sebagai gambar statis — tanpa interaktivitas, 3D chart kehilangan banyak nilainya
  • Aksesibilitas prioritas utama — chart 2D umumnya lebih accessible

Tips: Coba lihat chart kamu dari samping pakai pose .front, .left, atau .right. Dengan proyeksi orthographic, ini efektifnya mengubah chart 3D jadi 2D — berguna untuk membandingkan dua variabel tanpa kehilangan konteks dimensi ketiga.

Contoh Lengkap: Dashboard Cuaca 3D

Oke, saatnya satukan semua konsep yang sudah kita bahas ke dalam satu contoh yang lebih nyata — dashboard cuaca 3D interaktif:

import Charts
import SwiftUI

struct WeatherDashboard3D: View {
    @State private var pose = Chart3DPose(
        azimuth: .degrees(45),
        inclination: .degrees(20)
    )
    @State private var selectedProjection: Chart3DCameraProjection = .orthographic
    @State private var selectedSymbol: BasicChartSymbolShape3D = .sphere

    var body: some View {
        NavigationStack {
            VStack(spacing: 16) {
                // Controls
                controlPanel

                // 3D Chart
                Chart3D(WeatherReading.sampleData) { reading in
                    PointMark(
                        x: .value("Suhu", reading.temperature),
                        y: .value("Kelembaban", reading.humidity),
                        z: .value("Angin", reading.windSpeed)
                    )
                    .foregroundStyle(by: .value("Kota", reading.location))
                    .symbol(selectedSymbol)
                    .symbolSize(0.04)
                }
                .chart3DPose($pose)
                .chart3DCameraProjection(selectedProjection)
                .chartXAxisLabel("Suhu (°C)")
                .chartYAxisLabel("Kelembaban (%)")
                .chartZAxisLabel("Angin (km/h)")
                .chartXScale(domain: 20...36)
                .chartYScale(domain: 50...95)
                .chartZScale(domain: 5...25)
                .frame(height: 400)

                // Pose presets
                posePresets
            }
            .padding()
            .navigationTitle("Dashboard Cuaca 3D")
        }
    }

    private var controlPanel: some View {
        HStack {
            Picker("Proyeksi", selection: $selectedProjection) {
                Text("Ortho").tag(Chart3DCameraProjection.orthographic)
                Text("Perspektif").tag(Chart3DCameraProjection.perspective)
            }
            .pickerStyle(.segmented)
        }
    }

    private var posePresets: some View {
        ScrollView(.horizontal, showsIndicators: false) {
            HStack(spacing: 8) {
                ForEach([
                    ("Default", Chart3DPose.default),
                    ("Depan", Chart3DPose.front),
                    ("Kiri", Chart3DPose.left),
                    ("Kanan", Chart3DPose.right),
                    ("Belakang", Chart3DPose.back),
                ], id: \.0) { label, presetPose in
                    Button(label) {
                        withAnimation(.easeInOut(duration: 0.5)) {
                            pose = presetPose
                        }
                    }
                    .buttonStyle(.bordered)
                }
            }
        }
    }
}

Contoh ini mencakup beberapa konsep sekaligus: drag-to-rotate, switching proyeksi, preset pose dengan animasi halus, kustomisasi simbol, dan pengaturan skala. Ini bisa jadi starting point yang solid untuk fitur visualisasi data di aplikasi kamu.

Dukungan Multi-Platform

Chart3D nggak cuma untuk iOS. API ini tersedia di semua platform Apple versi 26:

  • visionOS 26 — Platform paling natural untuk chart 3D. Di Vision Pro, grafik benar-benar terasa tiga dimensi dan bisa dieksplorasi secara spasial.
  • macOS 26 — Interaksi pakai mouse dan trackpad. Cocok untuk dashboard dan tools analitik.
  • iPadOS 26 — Layar besar plus Apple Pencil, pas untuk eksplorasi data.
  • watchOS 26 — Ya, bahkan di Apple Watch. Meskipun layarnya kecil, chart 3D sederhana bisa berguna untuk quick glance data sensor.

Kode yang sama jalan di semua platform tanpa modifikasi, berkat abstraksi SwiftUI. Kamu mungkin perlu menyesuaikan ukuran frame dan level detail per platform, tapi logika chart-nya tetap identik.

FAQ

Apakah Chart3D bisa dipakai di iOS versi sebelum iOS 26?

Sayangnya tidak. Chart3D adalah API baru yang eksklusif untuk iOS 26, macOS 26, visionOS 26, dan watchOS 26. Kalau perlu mendukung iOS versi lebih lama, kamu harus pakai library pihak ketiga atau bikin solusi custom dengan SceneKit.

Apa perbedaan Chart3D dan SceneKit untuk visualisasi 3D?

Chart3D itu API deklaratif tingkat tinggi yang dirancang khusus untuk visualisasi data — kamu deklarasikan data dan mark-nya, SwiftUI yang urus rendering, interaksi, dan aksesibilitas. SceneKit jauh lebih fleksibel tapi juga jauh lebih kompleks. Cocok untuk game atau pengalaman 3D custom, tapi overkill untuk grafik data.

Bagaimana performa Chart3D dengan dataset besar?

Apple sudah mengoptimalkan Chart3D untuk performa yang baik. Tapi seperti semua visualisasi 3D, dataset yang sangat besar (ribuan data point) bisa memperlambat rendering. Untuk kasus seperti ini, pertimbangkan sampling, agregasi, atau gunakan SurfacePlot sebagai representasi yang lebih ringan.

Apakah Chart3D mendukung gesture selain rotate?

Secara bawaan, Chart3D mendukung drag untuk rotasi saat pakai binding pada chart3DPose. Untuk interaksi tambahan seperti selection atau tooltip, kamu bisa kombinasikan Chart3D dengan gesture modifier SwiftUI standar dan overlay view.

Bisakah saya pakai BarMark di Chart3D?

Belum bisa. Saat ini mark yang didukung di Chart3D adalah PointMark, RuleMark, RectangleMark, dan SurfacePlot. BarMark dan LineMark belum tersedia di 3D. Tapi kamu bisa mensimulasikan efek bar chart 3D pakai RectangleMark dengan pengaturan posisi dan ukuran yang tepat.

Tentang Penulis Editorial Team

Our team of expert writers and editors.

Artikel Terkait