הגענו לגרסה Developer Preview 3 של Android XR SDK, ואנחנו רוצים לקבל מכם משוב! אתם יכולים לנסות את האפשרויות השונות ולפנות אלינו דרך דף התמיכה.

פיתוח ממשק משתמש באמצעות Jetpack Compose ל-XR

עם Jetpack Compose ל-XR, אתם יכולים ליצור את ממשק המשתמש המרחבי והפריסה שלכם באופן הצהרתי באמצעות מושגים מוכרים של Compose, כמו שורות ועמודות. כך תוכלו להרחיב את ממשק המשתמש הקיים שלכם ב-Android למרחב תלת-ממדי או ליצור אפליקציות תלת-ממדיות חדשות לגמרי.

אם אתם מוסיפים מרחביות לאפליקציה קיימת שמבוססת על Android Views, יש לכם כמה אפשרויות פיתוח. אתם יכולים להשתמש בממשקי API של יכולת פעולה הדדית, להשתמש ב-Compose וב-Views ביחד או לעבוד ישירות עם ספריית SceneCore. לפרטים נוספים, אפשר לעיין במדריך שלנו לעבודה עם תצוגות.

Codelab

היסודות של Android XR: חלק 1 – מצבים וחלוניות מרחביות

מידע על תתי-מרחבים ורכיבים מרחביים

כשכותבים אפליקציה ל-Android XR, חשוב להבין את המושגים תת-מרחב ורכיבים מרחביים.

מידע על תת-מרחב

כשמפתחים לאנדרואיד XR, צריך להוסיף Subspace לאפליקציה או לפריסה. תת-מרחב הוא חלוקה של מרחב תלת-ממדי בתוך האפליקציה, שבה אפשר למקם תוכן תלת-ממדי, ליצור פריסות תלת-ממדיות ולהוסיף עומק לתוכן דו-ממדי. מרחב משנה מוצג רק אם מופעלת התכונה 'התאמה מרחבית'. במרחב הביתי או במכשירים שאינם XR, המערכת מתעלמת מכל קוד שנמצא במרחב המשנה הזה.

יש שתי דרכים ליצור מרחב משנה:

‫Subspace: אפשר למקם את רכיב ה-Composable הזה בכל מקום בהיררכיית ממשק המשתמש של האפליקציה, וכך לשמור על פריסות לממשקי משתמש דו-ממדיים ומרחביים בלי לאבד את ההקשר בין הקבצים. כך קל יותר לשתף דברים כמו ארכיטקטורת אפליקציה קיימת בין XR לבין גורמי צורה אחרים, בלי להעביר את המצב דרך כל עץ ממשק המשתמש או לתכנן מחדש את האפליקציה.
‫ApplicationSubspace: הפונקציה הזו יוצרת מרחב משנה ברמת האפליקציה בלבד, והיא צריכה להיות ממוקמת ברמה העליונה ביותר בהיררכיה של ממשק המשתמש המרחבי של האפליקציה. ‫ApplicationSubspace מעבד תוכן מרחבי עם VolumeConstraints אופציונלי. בניגוד ל-Subspace, אי אפשר להטמיע את ApplicationSubspace בתוך Subspace או ApplicationSubspace אחרים.

מידע נוסף זמין במאמר הוספת מרחב משנה לאפליקציה.

מידע על רכיבים מרחביים

רכיבים שניתנים להרכבה של תת-מרחב: אפשר לעבד את הרכיבים האלה רק בתת-מרחב. צריך להוסיף אותם בין התגים Subspace לפני שמציבים אותם בפריסה דו-ממדית. SubspaceModifier מאפשר להוסיף מאפיינים כמו עומק, היסט ומיקום לרכיבים הניתנים להרכבה של תת-המרחב.

רכיבים מרחביים אחרים לא צריכים להיקרא בתוך תת-מרחב. הם מורכבים מרכיבי דו-ממד רגילים שעטופים בקונטיינר מרחבי. אפשר להשתמש ברכיבים האלה בפריסות דו-ממדיות או תלת-ממדיות אם הם מוגדרים לשני הסוגים. אם לא מפעילים את האפשרות 'הוספת מימד מרחבי', המערכת מתעלמת מהתכונות המרחביות שלהם והם חוזרים לתכונות המקבילות הדו-ממדיות.

יצירת לוח מרחבי

SpatialPanel הוא רכיב שניתן להרכבה במרחב משנה, שמאפשר להציג תוכן של אפליקציה – לדוגמה, אפשר להציג הפעלת וידאו, תמונות סטילס או כל תוכן אחר בחלונית מרחבית.

דוגמה לחלונית ממשק משתמש מרחבי

אפשר להשתמש ב-SubspaceModifier כדי לשנות את הגודל, ההתנהגות והמיקום של החלונית המרחבית, כמו בדוגמה הבאה.

Subspace {
    SpatialPanel(
        SubspaceModifier
            .height(824.dp)
            .width(1400.dp),
        dragPolicy = MovePolicy(),
        resizePolicy = ResizePolicy(),
    ) {
        SpatialPanelContent()
    }
}SpatialPanel.kt

@Composable
fun SpatialPanelContent() {
    Box(
        Modifier
            .background(color = Color.Black)
            .height(500.dp)
            .width(500.dp),
        contentAlignment = Alignment.Center
    ) {
        Text(
            text = "Spatial Panel",
            color = Color.White,
            fontSize = 25.sp
        )
    }
}SpatialPanel.kt

מידע חשוב על הקוד

ממשקי ה-API של SpatialPanel הם קומפוזיציות של תת-מרחבים, ולכן צריך להפעיל אותם בתוך Subspace. אם קוראים להם מחוץ למרחב משנה, מוצג חריג.
הגודל של SpatialPanel הוגדר באמצעות המפרטים height ו-width ב-SubspaceModifier. אם לא מציינים את המידות האלה, המידות של החלונית נקבעות לפי המידות של התוכן שלה.
המשתמש יכול להזיז חלונית על ידי הוספת MovePolicy.
המשתמש יכול לשנות את הגודל של החלונית על ידי הוספת ResizePolicy.
פרטים על שינוי הגודל והמיקום זמינים בהנחיות שלנו לעיצוב חלונית מרחבית. מידע נוסף על הטמעת קוד זמין במאמרי העזרה שלנו.

איך `MovePolicy` עובד

כשהמשתמשים מרחיקים את החלונית מהם, כברירת מחדל, MovePolicy החלונית משתנה באופן דומה לשינוי הגודל של החלוניות על ידי המערכת במרחב הביתי. כל התוכן שמוגדר כתוכן לילדים יורש את ההתנהגות הזו. כדי להשבית את ההגדרה הזו, צריך להגדיר את הפרמטר shouldScaleWithDistance לערך false.

יצירת לוויין

רכיב Orbiter הוא רכיב מרחבי בממשק המשתמש. היא מיועדת לצירוף לחלונית מרחבית, לפריסה או לישות תואמת אחרת. בדרך כלל, רכיב ה-Orbiter מכיל פריטי ניווט ופעולות בהקשר שקשורים לישות שהוא מעוגן אליה. לדוגמה, אם יצרתם חלונית תלת-ממדית להצגת תוכן וידאו, תוכלו להוסיף לחצני הפעלה של סרטונים בתוך רכיב orbiter.

דוגמה למסלולן

כמו שמוצג בדוגמה הבאה, מפעילים orbiter בתוך פריסת הדו-ממד ב-SpatialPanel כדי לעטוף את אמצעי הבקרה של המשתמש, כמו ניווט. הפעולה הזו תגרום לחילוץ שלהם מפריסת הדו-ממד ולצירוף שלהם לחלונית המרחבית בהתאם להגדרה שלכם.

Subspace {
    SpatialPanel(
        SubspaceModifier
            .height(824.dp)
            .width(1400.dp),
        dragPolicy = MovePolicy(),
        resizePolicy = ResizePolicy(),
    ) {
        SpatialPanelContent()
        OrbiterExample()
    }
}Orbiter.kt

@Composable
fun OrbiterExample() {
    Orbiter(
        position = ContentEdge.Bottom,
        offset = 96.dp,
        alignment = Alignment.CenterHorizontally
    ) {
        Surface(Modifier.clip(CircleShape)) {
            Row(
                Modifier
                    .background(color = Color.Black)
                    .height(100.dp)
                    .width(600.dp),
                horizontalArrangement = Arrangement.Center,
                verticalAlignment = Alignment.CenterVertically
            ) {
                Text(
                    text = "Orbiter",
                    color = Color.White,
                    fontSize = 50.sp
                )
            }
        }
    }
}Orbiter.kt

מידע חשוב על הקוד

מכיוון שרכיבי ה-UI של המעגלים הם מרחביים, אפשר לעשות שימוש חוזר בקוד בפריסות דו-ממדיות או תלת-ממדיות. בפריסה דו-ממדית, האפליקציה מעבדת רק את התוכן בתוך המעגל ומתעלמת מהמעגל עצמו.
מידע נוסף על אופן השימוש באורביטרים ועל העיצוב שלהם זמין בהנחיות העיצוב שלנו.

הוספת כמה חלוניות מרחביות לפריסה מרחבית

אתם יכולים ליצור כמה חלוניות מרחביות ולמקם אותן בפריסה מרחבית באמצעות SpatialRow, SpatialColumn, SpatialBox ו-SpatialLayoutSpacer.

דוגמה לכמה לוחות מרחביים בפריסה מרחבית

בדוגמה הבאה אפשר לראות איך עושים את זה.

Subspace {
    SpatialRow {
        SpatialColumn {
            SpatialPanel(SubspaceModifier.height(250.dp).width(400.dp)) {
                SpatialPanelContent("Top Left")
            }
            SpatialPanel(SubspaceModifier.height(200.dp).width(400.dp)) {
                SpatialPanelContent("Middle Left")
            }
            SpatialPanel(SubspaceModifier.height(250.dp).width(400.dp)) {
                SpatialPanelContent("Bottom Left")
            }
        }
        SpatialColumn {
            SpatialPanel(SubspaceModifier.height(250.dp).width(400.dp)) {
                SpatialPanelContent("Top Right")
            }
            SpatialPanel(SubspaceModifier.height(200.dp).width(400.dp)) {
                SpatialPanelContent("Middle Right")
            }
            SpatialPanel(SubspaceModifier.height(250.dp).width(400.dp)) {
                SpatialPanelContent("Bottom Right")
            }
        }
    }
}SpatialLayout.kt

@Composable
fun SpatialPanelContent(text: String) {
    Column(
        Modifier
            .background(color = Color.Black)
            .fillMaxSize(),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.Center
    ) {
        Text(
            text = "Panel",
            color = Color.White,
            fontSize = 15.sp
        )
        Text(
            text = text,
            color = Color.White,
            fontSize = 25.sp,
            fontWeight = FontWeight.Bold
        )
    }
}SpatialLayout.kt

מידע חשוב על הקוד

‫SpatialRow, ‏ SpatialColumn, ‏ SpatialBox ו-SpatialLayoutSpacer הם רכיבים שניתן להרכיב מהם תת-מרחבים, והם חייבים להיות ממוקמים בתוך תת-מרחב.
משתמשים בSubspaceModifier כדי להתאים אישית את הפריסה.
לפריסות עם כמה חלוניות בשורה, מומלץ להגדיר רדיוס של 825dp באמצעות SubspaceModifier כדי שהחלוניות יקיפו את המשתמש. פרטים נוספים זמינים בהנחיות העיצוב.

שימוש ב-SceneCoreEntity כדי למקם ישויות בפריסה

כדי למקם אובייקט תלת-ממדי בפריסה, צריך להשתמש ב-subspace composable שנקרא SceneCoreEntity. דוגמה לאופן שבו עושים זאת.

Subspace {
    SceneCoreEntity(
        modifier = SubspaceModifier.offset(x = 50.dp),
        factory = {
            SurfaceEntity.create(
                session = session,
                pose = Pose.Identity,
                stereoMode = SurfaceEntity.StereoMode.MONO
            )
        },
        update = { entity ->
            // compose state changes may be applied to the
            // SceneCore entity here.
            entity.stereoMode = SurfaceEntity.StereoMode.SIDE_BY_SIDE
        },
        sizeAdapter =
            SceneCoreEntitySizeAdapter({
                IntSize2d(it.width, it.height)
            }),
    ) {
        // Content here will be children of the SceneCoreEntity
        // in the scene graph.
    }
}SceneCoreEntity.kt

מידע נוסף

במאמר הוספת מודלים תלת-ממדיים לאפליקציה מוסבר איך לטעון תוכן תלת-ממדי בתוך SceneCoreEntity.

הוספת משטח לתוכן של תמונות או סרטונים

‫SpatialExternalSurface הוא רכיב ניתן להרכבה של מרחב משנה שיוצר ומנהל את Surface שאליו האפליקציה יכולה לצייר תוכן, כמו תמונה או סרטון. ‫SpatialExternalSurface תומך בתוכן סטריאוסקופי או מונוסקופי.

בדוגמה הזו אפשר לראות איך טוענים סרטון סטריאוסקופי זה לצד זה באמצעות Media3 Exoplayer ו-SpatialExternalSurface:

לסרטונים ב-180 או ב-360 מעלות משתמשים בתגים SpatialExternalSurface180Hemisphere ו-SpatialExternalSurface360Sphere.

@OptIn(ExperimentalComposeApi::class)
@Composable
fun SpatialExternalSurfaceContent() {
    val context = LocalContext.current
    Subspace {
        SpatialExternalSurface(
            modifier = SubspaceModifier
                .width(1200.dp) // Default width is 400.dp if no width modifier is specified
                .height(676.dp), // Default height is 400.dp if no height modifier is specified
            // Use StereoMode.Mono, StereoMode.SideBySide, or StereoMode.TopBottom, depending
            // upon which type of content you are rendering: monoscopic content, side-by-side stereo
            // content, or top-bottom stereo content
            stereoMode = StereoMode.SideBySide,
        ) {
            val exoPlayer = remember { ExoPlayer.Builder(context).build() }
            val videoUri = Uri.Builder()
                .scheme(ContentResolver.SCHEME_ANDROID_RESOURCE)
                // Represents a side-by-side stereo video, where each frame contains a pair of
                // video frames arranged side-by-side. The frame on the left represents the left
                // eye view, and the frame on the right represents the right eye view.
                .path("sbs_video.mp4")
                .build()
            val mediaItem = MediaItem.fromUri(videoUri)

            // onSurfaceCreated is invoked only one time, when the Surface is created
            onSurfaceCreated { surface ->
                exoPlayer.setVideoSurface(surface)
                exoPlayer.setMediaItem(mediaItem)
                exoPlayer.prepare()
                exoPlayer.play()
            }
            // onSurfaceDestroyed is invoked when the SpatialExternalSurface composable and its
            // associated Surface are destroyed
            onSurfaceDestroyed { exoPlayer.release() }
        }
    }
}SpatialExternalSurface.kt

מידע חשוב על הקוד

מגדירים את StereoMode לערך Mono, SideBySide או TopBottom בהתאם לסוג התוכן שמוצג:
- ‫Mono: התמונה או פריים הווידאו מורכבים מתמונה אחת זהה שמוצגת לשתי העיניים.
- ‫SideBySide: התמונה או פריים הסרטון מכילים זוג תמונות או פריים סרטון שמוצגים זה לצד זה, כאשר התמונה או הפריים בצד ימין מייצגים את מה שרואים בעין ימין, והתמונה או הפריים בצד שמאל מייצגים את מה שרואים בעין שמאל.
- ‫TopBottom: התמונה או פריים הווידאו מכילים זוג תמונות או פריים של וידאו שמוערמים אנכית, כאשר התמונה או הפריים העליון מייצגים את התצוגה של העין השמאלית, והתמונה או הפריים התחתון מייצגים את התצוגה של העין הימנית.
SpatialExternalSurface תומך רק בפלטפורמות מלבניות.
Surface לא מתעד אירועי קלט.
אי אפשר לסנכרן שינויים ב-StereoMode עם עיבוד של אפליקציה או פענוח של סרטון.
אי אפשר להציג את רכיב ה-Composable הזה מעל חלוניות אחרות, ולכן לא מומלץ להשתמש ב-MovePolicy אם יש חלוניות אחרות בפריסה.

הוספת פלטפורמה לתוכן וידאו שמוגן על ידי DRM

‫SpatialExternalSurface תומך גם בהפעלה של סטרימינג של סרטונים שמוגנים באמצעות DRM. כדי להפעיל את התכונה הזו, צריך ליצור משטח מאובטח שמעבד את הנתונים למאגרי גרפיקה מוגנים. כך התוכן לא יוקלט במסך ולא תהיה גישה אליו לרכיבי מערכת לא מאובטחים.

כדי ליצור משטח מאובטח, מגדירים את הפרמטר surfaceProtection לערך SurfaceProtection.Protected ברכיב SpatialExternalSurface. בנוסף, צריך להגדיר את Media3 Exoplayer עם פרטי ה-DRM המתאימים כדי לטפל בהשגת הרישיון משרת הרישיונות.

בדוגמה הבאה מוסבר איך להגדיר את SpatialExternalSurface ואת ExoPlayer להפעלת סטרימינג של וידאו שמוגן באמצעות DRM:

@OptIn(ExperimentalComposeApi::class)
@Composable
fun DrmSpatialVideoPlayer() {
    val context = LocalContext.current
    Subspace {
        SpatialExternalSurface(
            modifier = SubspaceModifier
                .width(1200.dp)
                .height(676.dp),
            stereoMode = StereoMode.SideBySide,
            surfaceProtection = SurfaceProtection.Protected
        ) {
            val exoPlayer = remember { ExoPlayer.Builder(context).build() }

            // Define the URI for your DRM-protected content and license server.
            val videoUri = "https://your-content-provider.com/video.mpd"
            val drmLicenseUrl = "https://your-license-server.com/license"

            // Build a MediaItem with the necessary DRM configuration.
            val mediaItem = MediaItem.Builder()
                .setUri(videoUri)
                .setDrmConfiguration(
                    MediaItem.DrmConfiguration.Builder(C.WIDEVINE_UUID)
                        .setLicenseUri(drmLicenseUrl)
                        .build()
                )
                .build()

            onSurfaceCreated { surface ->
                // The created surface is secure and can be used by the player.
                exoPlayer.setVideoSurface(surface)
                exoPlayer.setMediaItem(mediaItem)
                exoPlayer.prepare()
                exoPlayer.play()
            }

            onSurfaceDestroyed { exoPlayer.release() }
        }
    }
}SpatialExternalSurface.kt

מידע חשוב על הקוד

הגדרת surfaceProtection = SurfaceProtection.Protected on SpatialExternalSurface היא חיונית כדי ש-Surface הבסיסי יגובה על ידי מאגרי נתונים מאובטחים שמתאימים לתוכן DRM.
הגדרת DRM: צריך להגדיר את MediaItem עם סכמת ה-DRM (לדוגמה, C.WIDEVINE_UUID) ואת ה-URI של שרת הרישיונות. ‫ExoPlayer משתמש במידע הזה כדי לנהל את סשן ה-DRM.
תוכן מאובטח: כשמעבדים תוכן להצגה במשטח מוגן, תוכן הווידאו מפוענח ומוצג בנתיב מאובטח, וכך מתקיימות הדרישות של רישוי התוכן. בנוסף, התוכן לא יופיע בצילומי מסך.

הוספת רכיבים אחרים של ממשק משתמש מרחבי

אפשר למקם רכיבים של ממשק משתמש מרחבי בכל מקום בהיררכיית ממשק המשתמש של האפליקציה. אפשר לעשות שימוש חוזר ברכיבים האלה בממשק המשתמש הדו-ממדי, והמאפיינים המרחביים שלהם יהיו גלויים רק כשהיכולות המרחביות מופעלות. כך אפשר להוסיף הגבהה לתפריטים, לתיבות דו-שיח ולרכיבים אחרים בלי לכתוב את הקוד פעמיים. כדי להבין טוב יותר איך להשתמש ברכיבים האלה, כדאי לעיין בדוגמאות הבאות של ממשקי משתמש מרחביים.

רכיב בממשק המשתמש	כשמפעילים את האפקט של מיקום הצליל במרחב	בסביבת דו-ממד
`SpatialDialog`	החלונית תזוז מעט אחורה בעומק כדי להציג תיבת דו-שיח מוגבהת	המערכת חוזרת לתצוגה דו-ממדית `Dialog`.
`SpatialPopup`	החלונית תזוז מעט אחורה בעומק כדי להציג חלון קופץ מוגבה	התצוגה חוזרת לדו-ממד `Popup`.
`SpatialElevation`	אפשר להגדיר את `SpatialElevationLevel` להוספת גובה.	תוכניות ללא גובה מרחבי.

SpatialDialog

זו דוגמה לתיבת דו-שיח שנפתחת אחרי השהיה קצרה. כשמשתמשים ב-SpatialDialog, תיבת הדו-שיח מופיעה באותו עומק z כמו החלונית המרחבית, והחלונית נדחקת אחורה ב-125dp כשהמרחביות מופעלת. אפשר להשתמש ב-SpatialDialog גם אם לא מפעילים את האפשרות ליצירת תחושת מרחב, ובמקרה כזה SpatialDialog חוזרת לגרסת ה-2D שלה, Dialog.

@Composable
fun DelayedDialog() {
    var showDialog by remember { mutableStateOf(false) }
    LaunchedEffect(Unit) {
        delay(3000)
        showDialog = true
    }
    if (showDialog) {
        SpatialDialog(
            onDismissRequest = { showDialog = false },
            SpatialDialogProperties(
                dismissOnBackPress = true
            )
        ) {
            Box(
                Modifier
                    .height(150.dp)
                    .width(150.dp)
            ) {
                Button(onClick = { showDialog = false }) {
                    Text("OK")
                }
            }
        }
    }
}SpatialDialog.kt

מידע חשוב על הקוד

זו דוגמה ל-SpatialDialog. השימוש ב-SpatialPopup וב-SpatialElevation דומה מאוד. פרטים נוספים זמינים בהפניית ה-API.

יצירה של לוחות ופריסות בהתאמה אישית

כדי ליצור לוחות מותאמים אישית שלא נתמכים על ידי Compose for XR, אפשר לעבוד ישירות עם מופעים של PanelEntity ועם גרף הסצנה באמצעות ממשקי ה-API של SceneCore.

הצמדת אורביטרים לפריסות מרחביות ולרכיבים אחרים

אפשר לעגן את האורביטר לכל ישות שמוצהרת ב-Compose. הפעולה הזו כוללת הצהרה על רכיב orbiter בפריסה מרחבית של רכיבי ממשק משתמש כמו SpatialRow,‏ SpatialColumn או SpatialBox. הלוויין מעוגן לישות האב הקרובה ביותר למקום שבו הוא הוגדר.

ההתנהגות של הלוויין נקבעת לפי המיקום שבו הוא מוצהר:

בפריסה דו-ממדית שמוקפת בתג SpatialPanel (כמו שמוצג בקטע הקוד הקודם), האורביטר מעוגן לתג SpatialPanel.
ב-Subspace, האורביטר מעוגן לישות ההורה הקרובה ביותר, שהיא הפריסה המרחבית שבה האורביטר מוצהר.

בדוגמה הבאה אפשר לראות איך מעגנים את המצלמה המסתובבת לשורה מרחבית:

Subspace {
    SpatialRow {
        Orbiter(
            position = ContentEdge.Top,
            offset = 8.dp,
            offsetType = OrbiterOffsetType.InnerEdge,
            shape = SpatialRoundedCornerShape(size = CornerSize(50))
        ) {
            Text(
                "Hello World!",
                style = MaterialTheme.typography.titleMedium,
                modifier = Modifier
                    .background(Color.White)
                    .padding(16.dp)
            )
        }
        SpatialPanel(
            SubspaceModifier
                .height(824.dp)
                .width(1400.dp)
        ) {
            Box(
                modifier = Modifier
                    .background(Color.Red)
            )
        }
        SpatialPanel(
            SubspaceModifier
                .height(824.dp)
                .width(1400.dp)
        ) {
            Box(
                modifier = Modifier
                    .background(Color.Blue)
            )
        }
    }
}Orbiter.kt

מידע חשוב על הקוד

כשמגדירים אובייקט מסתובב מחוץ לפריסה דו-ממדית, הוא מעוגן לישות ההורה הקרובה ביותר שלו. במקרה הזה, ה-orbiter מעוגן לחלק העליון של SpatialRow שבו הוא מוצהר.
פריסות מרחביות כמו SpatialRow, SpatialColumn ו-SpatialBox כוללות ישויות ללא תוכן שמשויכות אליהן. לכן, רכיב orbiter שמוצהר בפריסה מרחבית מעוגן לפריסה הזו.

פיתוח ממשק משתמש באמצעות Jetpack Compose ל-XR קל לארגן דפים בעזרת אוספים אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.

מידע על תתי-מרחבים ורכיבים מרחביים

מידע על תת-מרחב

מידע על רכיבים מרחביים

יצירת לוח מרחבי

מידע חשוב על הקוד

איך MovePolicy עובד

יצירת לוויין

מידע חשוב על הקוד

הוספת כמה חלוניות מרחביות לפריסה מרחבית

מידע חשוב על הקוד

שימוש ב-SceneCoreEntity כדי למקם ישויות בפריסה

מידע נוסף

הוספת משטח לתוכן של תמונות או סרטונים

מידע חשוב על הקוד

הוספת פלטפורמה לתוכן וידאו שמוגן על ידי DRM

מידע חשוב על הקוד

הוספת רכיבים אחרים של ממשק משתמש מרחבי

SpatialDialog

מידע חשוב על הקוד

יצירה של לוחות ופריסות בהתאמה אישית

הצמדת אורביטרים לפריסות מרחביות ולרכיבים אחרים

מידע חשוב על הקוד

למידע נוסף

פיתוח ממשק משתמש באמצעות Jetpack Compose ל-XR

איך `MovePolicy` עובד