Apple: Core visionOS Support

This PR builds on the [Core iOS support PR](PixarAnimationStudios#2949) to add support for building the USD core for visionOS.

Thanks to Valentin Roussellet for the basis of the TBB patch.

It includes the following changes:

* Use CMake 3.28 (which adds visionOS support)
* Patch TBB to support visionOS. Note that clang requires new platforms to be provided via the target triplet.
* Add visionOS to the accepted platforms.

Note that  visionOS's SDK is called xros, much like how the iOS SDK is iphoneos for historical reasons.

Author: dgovil

README.md

@@ -141,15 +141,15 @@ then build and install USD into `/path/to/my_usd_install_dir`.
 > python OpenUSD/build_scripts/build_usd.py /path/to/my_usd_install_dir
 ```
 
-###### iOS
+###### iOS and visionOS
 
 When building from a macOS system, you can cross compile for iOS based platforms.
 
 iOS builds currently do not support Imaging.
 Additionally, they will not support Python bindings or command line tools.
 
-To build for iOS, add the `--build-target iOS` parameter.
-
+* To build for iOS, add the `--build-target iOS` parameter.
+* To build for visionOS, add the `--build-target visionOS` parameter.
 
 ##### Windows:
 

build_scripts/apple_utils.py

@@ -43,15 +43,17 @@
 TARGET_ARM64 = "arm64"
 TARGET_UNIVERSAL = "universal"
 TARGET_IOS = "iOS"
+TARGET_VISIONOS = "visionOS"
 
-EMBEDDED_PLATFORMS = [TARGET_IOS]
+EMBEDDED_PLATFORMS = [TARGET_IOS, TARGET_VISIONOS]
 
 def GetBuildTargets():
     return [TARGET_NATIVE,
             TARGET_X86,
             TARGET_ARM64,
             TARGET_UNIVERSAL,
-            TARGET_IOS]
+            TARGET_IOS,
+            TARGET_VISIONOS]
 
 def GetBuildTargetDefault():
     return TARGET_NATIVE
@@ -135,6 +137,8 @@ def GetSDKRoot(context) -> Optional[str]:
     sdk = "macosx"
     if context.buildTarget == TARGET_IOS:
         sdk = "iphoneos"
+    elif context.buildTarget == TARGET_VISIONOS:
+        sdk = "xros"
 
     for arg in (context.cmakeBuildArgs or '').split():
         if "CMAKE_OSX_SYSROOT" in arg:
@@ -150,6 +154,7 @@ def SetTarget(context, targetName):
     context.targetARM64 = (targetName == GetTargetArmArch())
     context.targetUniversal = (targetName == TARGET_UNIVERSAL)
     context.targetIos = (targetName == TARGET_IOS)
+    context.targetVisionos = (targetName == TARGET_VISIONOS)
     if context.targetUniversal and not SupportsMacOSUniversalBinaries():
         context.targetUniversal = False
         raise ValueError(
@@ -279,8 +284,8 @@ def CreateUniversalBinaries(context, libNames, x86Dir, armDir):
 
 def ConfigureCMakeExtraArgs(context, args:List[str]) -> List[str]:
     system_name = None
-    if context.buildTarget == TARGET_IOS:
-        system_name = "iOS"
+    if context.buildTarget in EMBEDDED_PLATFORMS:
+        system_name = context.buildTarget
 
     if system_name:
         args.append(f"-DCMAKE_SYSTEM_NAME={system_name}")

build_scripts/build_usd.py

@@ -1009,6 +1009,31 @@ def InstallTBB_MacOS(context, force, buildArgs):
                   "ifeq ($(arch),$(filter $(arch),armv7 armv7s {0}))"
                         .format(apple_utils.GetTargetArmArch()))])
 
+        if context.buildTarget == apple_utils.TARGET_VISIONOS:
+            # Create visionOS config from iOS config
+            shutil.copy(
+                src="build/ios.macos.inc",
+                dst="build/visionos.macos.inc")
+
+            PatchFile("build/visionos.macos.inc",
+                      [("ios","visionos"),
+                       ("iOS", "visionOS"),
+                       ("iPhone", "XR"),
+                       ("IPHONEOS","XROS"),
+                       ("?= 8.0", "?= 1.0")])
+
+            # iOS clang just reuses the macOS one, so it's easier to copy it directly
+            shutil.copy(src="build/macos.clang.inc",
+                        dst="build/visionos.clang.inc")
+
+
+            PatchFile("build/visionos.clang.inc",
+                      [("ios","visionos"),
+                       ("-miphoneos-version-min=", "-target arm64-apple-xros"),
+                       ("iOS", "visionOS"),
+                       ("iPhone", "XR"),
+                       ("IPHONEOS","XROS")])
+
         (primaryArch, secondaryArch) = apple_utils.GetTargetArchPair(context)
 
         # tbb uses different arch names
@@ -2399,6 +2424,10 @@ def ForceBuildDependency(self, dep):
     elif MacOS():
         # Apple Silicon is not supported prior to 3.19
         cmake_required_version = (3, 19)
+
+        # visionOS support was added in CMake 3.28
+        if context.buildTarget == apple_utils.TARGET_VISIONOS:
+            cmake_required_version = (3, 28)
     else:
         # Linux, and vfx platform CY2020, are verified to work correctly with 3.14
         cmake_required_version = (3, 14)