Cmake not found cesium-unity for visionOS

Analog · June 3, 2024, 3:30pm

Hello Kevin,
We are facing some issues with building cesium for unity as per the developer-setup.md of cesium-unity.

I have followed all the steps but when I build the project, it builds but I get error too regarding cmake command line.
I am seeing Runtime Error on vision OS [The native implementation is missing so Update cannot be invoked. This may be caused by a missing call to CreateImplementation in one of your constructors, or it may be that the entire native implementation shared library is missing or out of date.].

Which I can see a fix here → Check for successful Reinterop init before calling into C++ static methods by kring · Pull Request #231 · CesiumGS/cesium-unity · GitHub,
I’ve tried to Reinterop.initailize() on all if,else still it shows me the above error.

When I build and run, I cannot build and see Win32 exception of file not found as shown in the images attached.

It would be great if you could share some direction to fix and I can make a build for vision OS possible. Thank you for the support

Kevin_Ring · June 4, 2024, 2:14am

Please post to the forum instead of sending me a private message. I don’t see anything sensitive in here that can’t be posted publicly.

At a glance, it sounds like your problem might be that cmake is either not installed or it can’t be found. The Cesium for Unity build process requires it to either be in the path (and I understand that the Unity application’s path will generally not match the path you have on the command-line on macOS, unlike other platforms), or it will look for it in /Applications/CMake.app/Contents/bin/cmake. You can change this by editing this file:

github.com

CesiumGS/cesium-unity/blob/main/Build~/Cmake.cs

using System;
using System.Collections.Generic;
using System.IO;

namespace Build
{
    public class Cmake
    {
        public readonly string ExecutablePath;

        public Cmake(string? executablePath = null)
        {
            if (executablePath != null)
                this.ExecutablePath = executablePath;
            else if (OperatingSystem.IsMacOS() && File.Exists("/Applications/CMake.app/Contents/bin/cmake"))
                this.ExecutablePath = "/Applications/CMake.app/Contents/bin/cmake";
            else
                // Expect it to be in the path
                this.ExecutablePath = "cmake";
        }

This file has been truncated. show original

Analog · June 4, 2024, 7:27am

Sure I will post this on the forum instead of here.

Thank you for the advice, we are now not getting file not found issue, but we are getting

An error occurred while building CesiumForUnityNative. See /Users/karanmistry/Documents/GitHub/Sentinel/Packages/com.cesium.unity/native~/build-VisionOS/build.log for details. The command-line was:
/Applications/CMake.app/Contents/bin/cmake --build “/Users/karanmistry/Documents/GitHub/Sentinel/Packages/com.cesium.unity/native~/build-VisionOS” --config RelWithDebInfo --parallel 17 --target install

I am uploading the build.log here
fatal error: ‘DotNet/CesiumForUnity/Cesium3DTileset.h’ file not found
#include <DotNet/CesiumForUnity/Cesium3DTileset.h>
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

I have run the command dotnet publish Reinterop~ -o . while unity is running, updated runtime script to refresh compiling and also restarted unity as you have suggested in some other forum post.

but still getting fatal error.

Kevin_Ring · June 4, 2024, 7:31am

If that file is missing, it means that Reinterop has not run inside the C# compiler in Unity the way it’s supposed to. The most common cause of this is opening the project in Unity before you run dotnet publish Reinterop~ -o .. If you do that, Unity (rather obnoxiously) deletes the .meta file that tells Unity how it’s supposed to use Reinterop. So then even once you build it, Unity won’t use it properly.

The solution is to make sure that you have this file and that its content is correct:

github.com

CesiumGS/cesium-unity/blob/main/Reinterop.dll.meta

fileFormatVersion: 2
guid: b659ef8ccee66ac42a5ca1aacb2694ca
labels:
- RoslynAnalyzer
PluginImporter:
  externalObjects: {}
  serializedVersion: 2
  iconMap: {}
  executionOrder: {}
  defineConstraints: []
  isPreloaded: 0
  isOverridable: 0
  isExplicitlyReferenced: 0
  validateReferences: 1
  platformData:
  - first:
      : Any
    second:
      enabled: 0
      settings:

This file has been truncated. show original

Then let Unity compile the plugin code again, and it should generate the C++ files.

Kevin_Ring · June 4, 2024, 7:34am

The other possibility is that Reinterop is running and generating the files, but not putting them where the C++ build expects to find them. Vision Pro isn’t a supported platform, so that wouldn’t be too surprising. You’ll need to change the paths at the top of ConfigureReinterop.cs (there are two files with this name) and/or the paths in CMakeLists.txt.

Analog · June 4, 2024, 7:53am

I changed it in ConfigureReinterop.cs

Now I no longer get the compile error. everything got built without any issues.

But (Drumroll)…

In the xcode logs I am getting these continously:

NotImplementedException: The native implementation is missing so Update cannot be invoked. This may be caused by a missing call to CreateImplementation in one of your constructors, or it may be that the entire native implementation shared library is missing or out of date.
at CesiumForUnity.Cesium3DTileset.Update () [0x00000] in <00000000000000000000000000000000>:0

Kevin_Ring · June 4, 2024, 7:58am

Have I mentioned it’s not a supported platform?

That indicates the native code couldn’t be loaded. Why? Hard to say. It could be missing entirely. It could have the wrong flags set so it’s not copied to the device. It could be failing to load on the device for some reason.

Kevin_Ring · June 4, 2024, 7:59am

Can I make this thread public?

Analog · June 4, 2024, 8:07am

I know it’s not a supported platform, but I am trying to do something here and contribute back to the community.

Anyway, if you are interested we can continue this and have it working for visionOS.
Let me know your thoughts.

Sure, you can make it public

Kevin_Ring · June 4, 2024, 8:38am

Thanks, it’s public now.

I appreciate you working on this and being willing to contribute it back. But it may not be entirely straightforward, and if you run into difficulties I may not be able to help you work through them remotely like this. But let’s try!

I think my comment about “flags” is the most likely thing to check first. This source file manages compilation of the native code and also sets the properties of the produced binaries so that Unity knows what to do with them:

github.com

CesiumGS/cesium-unity/blob/main/Editor/CompileCesiumForUnityNative.cs

using UnityEditor;
using UnityEngine;
using UnityEditor.Build;
using UnityEditor.Build.Reporting;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.IO;
using System.Text;
using System;
using System.Collections.Generic;
#if UNITY_ANDROID
using UnityEditor.Android;
#endif

namespace CesiumForUnity
{
    internal struct PlatformToBuild
    {
        public BuildTargetGroup platformGroup;
        public BuildTarget platform;

This file has been truncated. show original

There’s nothing in there to handle Vision Pro yet, so that has to change. Copying the iOS bits should be a good start, but I’m not sure what else might be needed.

The flags I’m referring to are this bit:

importer.SetCompatibleWithAnyPlatform(false);
importer.SetCompatibleWithEditor(false);
importer.SetCompatibleWithPlatform(library.Platform, true);

Those lines flag the imported asset (the built binary) as being compatible with a particular platform. Looking at it now, it’s already pretty generic, so I don’t think that part will need changes specifically. It’s just a matter of making sure it gets called for the Vision Pro build. And doing that might be as simple as adding handling for VisionPro here:

github.com

CesiumGS/cesium-unity/blob/af825c6f44dbfb8c62d02ed626b450400c8d7c69/Editor/CompileCesiumForUnityNative.cs#L334


      
          {
              library.Toolchain = $"extern/android-toolchain.cmake";
              if (cpu == null)
                  cpu = LibraryCpuArchitecture.ARM64;
              if (cpu == LibraryCpuArchitecture.x86_64)
                  library.ExtraConfigureArgs.Add("-DCMAKE_ANDROID_ARCH_ABI=x86_64");
              else
                  library.ExtraConfigureArgs.Add("-DCMAKE_ANDROID_ARCH_ABI=arm64-v8a");
          }
          
          if (platform.platformGroup == BuildTargetGroup.iOS)
          {
              library.Toolchain = "extern/ios-toolchain.cmake";
              library.ExtraConfigureArgs.Add("-GXcode");
              library.ExtraConfigureArgs.Add("-DCMAKE_SYSTEM_NAME=iOS");
              library.ExtraConfigureArgs.Add("-DCMAKE_SYSTEM_PROCESSOR=aarch64");
              library.ExtraConfigureArgs.Add("-DCMAKE_OSX_ARCHITECTURES=arm64");
          }
          
          if (platform.platform == BuildTarget.StandaloneOSX)
          {

Analog · June 4, 2024, 1:25pm

Copied iOS bits and added VisionOS.

Build was successfull without any errors.

In Xcode:

DllNotFoundException: Unable to load DLL 'CesiumForUnityNative-Runtime'. Tried the load the following dynamic libraries: Unable to load dynamic library '/CesiumForUnityNative-Runtime' because of 'Failed to open the requested dynamic library (0x06000000) dlerror() = dlopen(/CesiumForUnityNative-Runtime, 0x0005): tried: '/CesiumForUnityNative-Runtime' (no such file)
  at Reinterop.ReinteropInitializer..cctor () [0x00000] in <00000000000000000000000000000000>:0 
  at CesiumForUnity.CesiumGeoreference.CreateImplementation () [0x00000] in <00000000000000000000000000000000>:0 
Rethrow as TypeInitializationException: The type initializer for 'Reinterop.ReinteropInitializer' threw an exception.
  at CesiumForUnity.CesiumGeoreference.CreateImplementation () [0x00000] in <00000000000000000000000000000000>:0

NotImplementedException: The native implementation is missing so Update cannot be invoked. This may be caused by a missing call to CreateImplementation in one of your constructors, or it may be that the entire native implementation shared library is missing or out of date.
  at CesiumForUnity.Cesium3DTileset.Update () [0x00000] in <00000000000000000000000000000000>:0

Thoughts?

Kevin_Ring · June 6, 2024, 5:12am

Good progress! Sounds like this #if needs to be updated for visionOS:

github.com

CesiumGS/cesium-unity/blob/main/Runtime/ConfigureReinterop.cs#L48


      
          #else
                  public const string CppOutputPath = "../native~/Runtime/generated-Unknown";
          #endif
          
                  // The namespace with which to prefix all C# namespaces. For example, if this
                  // property is set to "DotNet", then anything in the "System" namespace in C#
                  // will be found in the "DotNet::System" namespace in C++.
                  public const string BaseNamespace = "DotNet";
          
                  // The name of the DLL or SO containing the C++ code.
          #if UNITY_IOS && !UNITY_EDITOR
                  public const string NativeLibraryName = "__Internal";
          #else
                  public const string NativeLibraryName = "CesiumForUnityNative-Runtime";
          #endif
                  // Comma-separated types to treat as non-blittable, even if their fields would
                  // otherwise cause Reinterop to treat them as blittable.
                  public const string NonBlittableTypes = "Unity.Collections.LowLevel.Unsafe.AtomicSafetyHandle,Unity.Collections.NativeArray,UnityEngine.MeshData,UnityEngine.MeshDataArray";
          
                  public void ExposeToCPP()
                  {

Analog · June 6, 2024, 11:41am

Changed
#if UNITY_IOS && !UNITY_EDITOR || UNITY_VISIONOS && !UNITY_EDITOR

Steps after editing

dotnet publish Reinterop~ -o .
cd cesium-unity-samples/Packages/com.cesium.unity/native~ cmake -B build -S . -DCMAKE_BUILD_TYPE=RelWithDebInfo cmake --build build -j14 --target install --config RelWithDebInfo
Build & Run

ERROR in Xcode:

Analog · June 6, 2024, 5:29pm

Update:

It is confirmed that after selecting __Internal as library name

#if UNITY_IOS || UNITY_VISIONOS && !UNITY_EDITOR
        public const string NativeLibraryName = "__Internal";

XCode throws undefined symbols error on building.

After following this thread - How to add native plugin code to a visionOS build? - #4 by korzen303 - Mixed Reality (Immersive) Apps - Unity Discussions - I included VisionOS target explicitly to all the library files .

Screenshot 2024-06-06 at 9.06.54 PM1396×1712 310 KB
All the DotNet_CesiumForUnity* are gone but some new ones have occured.

Screenshot 2024-06-06 at 9.01.32 PM1910×1820 345 KB

No more library files are left to mark visionOS target. Can’t find anything for these issues.
Also, I’ve modified some more code in Packages/com.cesium.unity/Build~/Package.cs,
let me know if this is required or should I revert it back?

Console.WriteLine("**** Compiling for iOS Player");
                    unity.Run(new[]
                    {
                        "-batchmode",
                        "-nographics",
                        "-projectPath",
                        Utility.ProjectRoot,
                        "-buildTarget",
                        "iOS",
                        "-executeMethod",
                        "CesiumForUnity.BuildCesiumForUnity.CompileForIOSAndExit"
                    });

                    Console.WriteLine("**** Adding generated files (for the iOS Player) to the package");
                    AddGeneratedFiles("!UNITY_EDITOR && UNITY_IOS", generatedRuntimePath, Path.Combine(outputPackagePath, "Runtime", "generated"));
                    
                    // Clean the generated code directory.
                    Directory.Delete(generatedRuntimePath, true);
                    Directory.CreateDirectory(generatedRuntimePath);

//Added this section ---------------------------------------

                    Console.WriteLine("**** Compiling for visionOS Player");
                    unity.Run(new[]
                    {
                        "-batchmode",
                        "-nographics",
                        "-projectPath",
                        Utility.ProjectRoot,
                        "-buildTarget",
                        "visionOS",  // Ensure this is the correct build target name for visionOS
                        "-executeMethod",
                        "CesiumForUnity.BuildCesiumForUnity.CompileForVisionOSAndExit"
                    });

                    Console.WriteLine("**** Adding generated files (for the visionOS Player) to the package");
                    AddGeneratedFiles("!UNITY_EDITOR && UNITY_VISIONOS", generatedRuntimePath, Path.Combine(outputPackagePath, "Runtime", "generated"));

//-----------------------------------------------------------------

Thank you for your support. Appreciate it a lot.
Let me know what you think might be the next steps.

Kevin_Ring · June 10, 2024, 11:33pm

Hi @Analog, I’m not sure where to tell you to go from here. The symbols that are undefined in your latest screenshots should be coming from libCesiumGltf.a and friends. Since you appear to have them, and they are set to target VisionOS, I’m not sure what’s going wrong.

I’d start by looking earlier in the log for a message about being unload to load a library file of some sort. For example, if the library were being compiled for the wrong platform or CPU, that could cause the sort of problem you’re seeing. You may be able to make some progress in understanding by looking closely at the xcode project. Are those libraries included in the link line?

Analog · June 22, 2024, 9:24am

Yes @Kevin_Ring , I think the Packages/com.cesium.unity/native~/build-visionOS-arm64/CesiumForUnityNative.xcodeproj is still getting build for iOS, it would help to know where to refactor to get this to build for visionOS. I have changed all the UNITY_IOS to UNITY_VISIONOS but still might have missed something. Let me know what to change to make native build for visionOS.

Here’s the build.log from
Packages/com.cesium.unity/native~/build-visionOS-arm64/Build.log
build.log.zip (97.0 KB)

Are those libraries included in the link line?

Where is the link line? Couldn’t find it. Here’s the screenshot of Build/CesiumForUnitySamples.xcodeproj, if it’s helpful.

Kevin_Ring · June 24, 2024, 10:15pm

Ok so you’ve copied this code and modified it for Vision OS, right?

github.com

CesiumGS/cesium-unity/blob/main/Editor/CompileCesiumForUnityNative.cs#L338


      
              if (cpu == LibraryCpuArchitecture.x86_64)
                  library.ExtraConfigureArgs.Add("-DCMAKE_ANDROID_ARCH_ABI=x86_64");
              else
                  library.ExtraConfigureArgs.Add("-DCMAKE_ANDROID_ARCH_ABI=arm64-v8a");
          }
          
          if (platform.platformGroup == BuildTargetGroup.iOS)
          {
              library.Toolchain = "extern/ios-toolchain.cmake";
              library.ExtraConfigureArgs.Add("-GXcode");
              library.ExtraConfigureArgs.Add("-DCMAKE_SYSTEM_NAME=iOS");
              library.ExtraConfigureArgs.Add("-DCMAKE_SYSTEM_PROCESSOR=aarch64");
              library.ExtraConfigureArgs.Add("-DCMAKE_OSX_ARCHITECTURES=arm64");
          }
          
          if (platform.platform == BuildTarget.StandaloneOSX)
          {
              if (cpu != null)
                  library.ExtraConfigureArgs.Add("-DCMAKE_OSX_ARCHITECTURES=" + cpu.ToString().ToLowerInvariant());
          
              library.ExtraConfigureArgs.Add("-DCMAKE_OSX_DEPLOYMENT_TARGET=10.13");

Changing that -DCMAKE_SYSTEM_NAME=iOS to … whatever the right thing is for Vision OS should do the trick. Well, CMake needs to know what this means, too. If you look at the docs for that variable, you can see visionOS listed. But that was presumably added in a very recent version of CMake. Looks like 3.28 to be specific:
https://cmake.org/cmake/help/latest/release/3.28.html

So as long as you have that -DCMAKE_SYSTEM_NAME=visionOS, and you have a new enough version of CMake, and the build is finishing without errors, I suspect you’re ok on that front.

Then the next thing is to confirm that the binaries produced in that build are correctly flagged for VisionOS within Unity. The easiest way to do that is to navigate to them in the Content folder in Unity and see what their properties look like. Share a screenshot if you’re not sure.

Analog · June 25, 2024, 11:38am

So as long as you have that -DCMAKE_SYSTEM_NAME=visionOS , and you have a new enough version of CMake, and the build is finishing without errors, I suspect you’re ok on that front.

I already have -DCMAKE_SYSTEM_NAME=visionOS,

and cmake version 3.29.3

The above errors are with these configs.

Then the next thing is to confirm that the binaries produced in that build are correctly flagged for VisionOS within Unity. The easiest way to do that is to navigate to them in the Content folder in Unity and see what their properties look like. Share a screenshot if you’re not sure.

Not sure what binaries you are talking about. Where in content folder?
You mean Assets/… or Packages/com.cesium.unity/…

Kevin_Ring · June 29, 2024, 11:20am

The end of the cmake build should have lines like this:

  -- Installing: <some file>

Those are the binaries. The iOS ones are found here:

Topic		Replies	Views
Error when build a unity Cesium for Unity	5	36	September 19, 2024
XCode Cesuim version 1.6 build errors w/ Unity 2021.3.11 Cesium for Unity	6	235	September 18, 2023
Cesium for Unity on Apple Vision Pro - Xcode Build Errors Cesium for Unity	1	296	May 14, 2024
Cmake compilation issue Cesium for Unity	13	383	May 7, 2024
Issues with compiling c++ code with CMake Cesium for Unity	16	713	March 5, 2024

Cmake not found cesium-unity for visionOS

Related topics