WinRT in Unreal

Im Laufe Ihrer HoloLens-Entwicklung müssen Sie möglicherweise ein Feature mithilfe von WinRT schreiben. Zum Öffnen eines Dateidialogfelds in einer HoloLens-Anwendung wäre beispielsweise der FileSavePicker in der Headerdatei winrt/Windows.Storage.Pickers.h erforderlich. WinRT wird im Buildsystem von Unreal ab Version 4.26 unterstützt.

4.26

Die WinRT-Standard-APIs

Die häufigste und einfachste Möglichkeit, WinRT zu verwenden, ist das Aufrufen von Methoden aus WinSDK. Öffnen Sie hierzu die Datei YourModule.Build.cs, und fügen Sie die folgenden Zeilen hinzu:

if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.HoloLens)
{
	// These parameters are mandatory for winrt support
	bEnableExceptions = true;
	bUseUnity = false;
	CppStandard = CppStandardVersion.Cpp17;
	PublicSystemLibraries.AddRange(new string[] { "shlwapi.lib", "runtimeobject.lib" });
	PrivateIncludePaths.Add(Path.Combine(Target.WindowsPlatform.WindowsSdkDir,        
                                        "Include", 
                                        Target.WindowsPlatform.WindowsSdkVersion, 
                                        "cppwinrt"));
}

Als Nächstes müssen Sie die folgenden WinRT-Header hinzufügen:

#if (PLATFORM_WINDOWS || PLATFORM_HOLOLENS) 
//Before writing any code, you need to disable common warnings in WinRT headers
#pragma warning(disable : 5205 4265 4268 4946)

#include "Windows/AllowWindowsPlatformTypes.h"
#include "Windows/AllowWindowsPlatformAtomics.h"
#include "Windows/PreWindowsApi.h"

#include <unknwn.h>
#include <winrt/Windows.Foundation.h>
#include <winrt/Windows.Perception.Spatial.h>
#include <winrt/Windows.Foundation.Collections.h>

#include "Windows/PostWindowsApi.h"
#include "Windows/HideWindowsPlatformAtomics.h"
#include "Windows/HideWindowsPlatformTypes.h"
#endif

WinRT-Code kann nur auf den Win64- und HoloLens-Plattformen kompiliert werden, sodass die if-Anweisung verhindert, dass WinRT-Bibliotheken auf anderen Plattformen eingeschlossen werden. unknwn.h wurde für die IUnknown-Schnittstelle hinzugefügt.

WinRT aus einem NuGet-Paket

Es ist etwas komplizierter, wenn Sie ein NuGet-Paket mit WinRT-Unterstützung hinzufügen müssen. In diesem Fall kann Visual Studio praktisch alle Aufgaben für Sie erledigen, aber das Unreal-Buildsystem nicht. Glücklicherweise ist es nicht allzu schwierig. Im Folgenden finden Sie ein Beispiel für das Herunterladen des Pakets Microsoft.MixedReality.QR. Sie können es durch eine andere ersetzen, stellen Sie einfach sicher, dass Sie die winmd-Datei nicht verlieren, und kopieren Sie die richtige DLL.

Windows SDK-DLLs aus dem vorherigen Abschnitt werden vom Betriebssystem behandelt. Die DLL-Dateien von NuGet müssen vom Code in Ihrem Modul verwaltet werden. Es wird empfohlen, Code hinzuzufügen, um sie herunterzuladen, in den Ordner "Binärdateien" zu kopieren und beim Start des Moduls in den Prozessspeicher zu laden.

Im ersten Schritt sollten Sie dem Stammordner Ihres Moduls eine packages.config (/nuget/reference/packages-config) hinzufügen. Dort sollten Sie alle Pakete hinzufügen, die Sie herunterladen möchten, einschließlich aller zugehörigen Abhängigkeiten. Hier habe ich Microsoft.MixedReality.QR als primäre Nutzlast und zwei weitere als Abhängigkeiten hinzugefügt. Das Format dieser Datei ist mit dem format in Visual Studio identisch:

<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Microsoft.MixedReality.QR" version="0.5.2102" targetFramework="native" />
  <package id="Microsoft.VCRTForwarders.140" version="1.0.6" targetFramework="native" />
  <package id="Microsoft.Windows.CppWinRT" version="2.0.200729.8" targetFramework="native" />
</packages>

Jetzt können Sie das NuGet und die erforderlichen Pakete herunterladen oder in der NuGet-Dokumentation nachlesen.

Öffnen Sie YourModule.Build.cs, und fügen Sie den folgenden Code hinzu:

// WinRT with Nuget support
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.HoloLens)
{
	// these parameters mandatory for winrt support
	bEnableExceptions = true;
	bUseUnity = false;
	CppStandard = CppStandardVersion.Cpp17;
	PublicSystemLibraries.AddRange(new string [] { "shlwapi.lib", "runtimeobject.lib" });

	// prepare everything for nuget
	string MyModuleName = GetType().Name;
	string NugetFolder = Path.Combine(PluginDirectory, "Intermediate", "Nuget", MyModuleName);
	Directory.CreateDirectory(NugetFolder);

	string BinariesSubFolder = Path.Combine("Binaries", "ThirdParty", Target.Type.ToString(), Target.Platform.ToString(), Target.Architecture);

	PrivateDefinitions.Add(string.Format("THIRDPARTY_BINARY_SUBFOLDER=\"{0}\"", BinariesSubFolder.Replace(@"\", @"\\")));

	string BinariesFolder = Path.Combine(PluginDirectory, BinariesSubFolder);
	Directory.CreateDirectory(BinariesFolder);

	ExternalDependencies.Add("packages.config");

	// download nuget
	string NugetExe = Path.Combine(NugetFolder, "nuget.exe");
	if (!File.Exists(NugetExe))
	{
		using (System.Net.WebClient myWebClient = new System.Net.WebClient())
		{
			// we aren't focusing on a specific nuget version, we can use any of them but the latest one is preferable
			myWebClient.DownloadFile(@"https://dist.nuget.org/win-x86-commandline/latest/nuget.exe", NugetExe);
		}
	}

	// run nuget to update the packages
	{
		var StartInfo = new System.Diagnostics.ProcessStartInfo(NugetExe, string.Format("install \"{0}\" -OutputDirectory \"{1}\"", Path.Combine(ModuleDirectory, "packages.config"), NugetFolder));
		StartInfo.UseShellExecute = false;
		StartInfo.CreateNoWindow = true;
		var ExitCode = Utils.RunLocalProcessAndPrintfOutput(StartInfo);
		if (ExitCode < 0)
		{
			throw new BuildException("Failed to get nuget packages.  See log for details.");
		}
	}

	// get list of the installed packages, that's needed because the code should get particular versions of the installed packages
	string[] InstalledPackages = Utils.RunLocalProcessAndReturnStdOut(NugetExe, string.Format("list -Source \"{0}\"", NugetFolder)).Split(new char[] { '\r', '\n' });

	// winmd files of the packages
	List<string> WinMDFiles = new List<string>();

	// WinRT lib for some job
	string QRPackage = InstalledPackages.FirstOrDefault(x => x.StartsWith("Microsoft.MixedReality.QR"));
	if (!string.IsNullOrEmpty(QRPackage))
	{
		string QRFolderName = QRPackage.Replace(" ", ".");

		// copying dll and winmd binaries to our local binaries folder
		// !!!!! please make sure that you use the path of file! Unreal can't do it for you !!!!!
		string WinMDFile = Path.Combine(NugetFolder, QRFolderName, @"lib\uap10.0.18362\Microsoft.MixedReality.QR.winmd");
		SafeCopy(WinMDFile, Path.Combine(BinariesFolder, "Microsoft.MixedReality.QR.winmd"));

		SafeCopy(Path.Combine(NugetFolder, QRFolderName, string.Format(@"runtimes\win10-{0}\native\Microsoft.MixedReality.QR.dll", Target.WindowsPlatform.Architecture.ToString())),
			Path.Combine(BinariesFolder, "Microsoft.MixedReality.QR.dll"));

		// also both both binaries must be in RuntimeDependencies, unless you get failures in Hololens platform
		RuntimeDependencies.Add(Path.Combine(BinariesFolder, "Microsoft.MixedReality.QR.dll"));
		RuntimeDependencies.Add(Path.Combine(BinariesFolder, "Microsoft.MixedReality.QR.winmd"));

		//add winmd file to the list for further processing using cppwinrt.exe
		WinMDFiles.Add(WinMDFile);
	}

	if (Target.Platform == UnrealTargetPlatform.Win64)
	{
		// Microsoft.VCRTForwarders.140 is needed to run WinRT dlls in Win64 platforms
		string VCRTForwardersPackage = InstalledPackages.FirstOrDefault(x => x.StartsWith("Microsoft.VCRTForwarders.140"));
		if (!string.IsNullOrEmpty(VCRTForwardersPackage))
		{
			string VCRTForwardersName = VCRTForwardersPackage.Replace(" ", ".");
			foreach (var Dll in Directory.EnumerateFiles(Path.Combine(NugetFolder, VCRTForwardersName, "runtimes/win10-x64/native/release"), "*_app.dll"))
			{
				string newDll = Path.Combine(BinariesFolder, Path.GetFileName(Dll));
				SafeCopy(Dll, newDll);
				RuntimeDependencies.Add(newDll);
			}
		}
	}

	// get WinRT package 
	string CppWinRTPackage = InstalledPackages.FirstOrDefault(x => x.StartsWith("Microsoft.Windows.CppWinRT"));
	if (!string.IsNullOrEmpty(CppWinRTPackage))
	{
		string CppWinRTName = CppWinRTPackage.Replace(" ", ".");
		string CppWinRTExe = Path.Combine(NugetFolder, CppWinRTName, "bin", "cppwinrt.exe");
		string CppWinRTFolder = Path.Combine(PluginDirectory, "Intermediate", CppWinRTName, MyModuleName);
		Directory.CreateDirectory(CppWinRTFolder);

		// all downloaded winmd file with WinSDK to be processed by cppwinrt.exe
		var WinMDFilesStringbuilder = new System.Text.StringBuilder();
		foreach (var winmd in WinMDFiles)
		{
			WinMDFilesStringbuilder.Append(" -input \"");
			WinMDFilesStringbuilder.Append(winmd);
			WinMDFilesStringbuilder.Append("\"");
		}

		// generate winrt headers and add them into include paths
		var StartInfo = new System.Diagnostics.ProcessStartInfo(CppWinRTExe, string.Format("{0} -input \"{1}\" -output \"{2}\"", WinMDFilesStringbuilder, Target.WindowsPlatform.WindowsSdkVersion, CppWinRTFolder));
		StartInfo.UseShellExecute = false;
		StartInfo.CreateNoWindow = true;
		var ExitCode = Utils.RunLocalProcessAndPrintfOutput(StartInfo);
		if (ExitCode < 0)
		{
			throw new BuildException("Failed to get generate WinRT headers.  See log for details.");
		}

		PrivateIncludePaths.Add(CppWinRTFolder);
	}
	else
	{
		// fall back to default WinSDK headers if no winrt package in our list
		PrivateIncludePaths.Add(Path.Combine(Target.WindowsPlatform.WindowsSdkDir, "Include", Target.WindowsPlatform.WindowsSdkVersion, "cppwinrt"));
	}
}

Sie müssen die SafeCopy-Methode wie folgt definieren:

private void SafeCopy(string source, string destination)
{
	if(!File.Exists(source))
	{
		Log.TraceError("Class {0} can't find {1} file for copying", this.GetType().Name, source);
		return;
	}

	try
	{
		File.Copy(source, destination, true);
	}
	catch(IOException ex)
	{
		Log.TraceWarning("Failed to copy {0} to {1} with exception: {2}", source, destination, ex.Message);
		if (!File.Exists(destination))
		{
			Log.TraceError("Destination file {0} does not exist", destination);
			return;
		}

		Log.TraceWarning("Destination file {0} already existed and is probably in use.  The old file will be used for the runtime dependency.  This may happen when packaging a Win64 exe from the editor.", destination);
	}
}

NuGet-DLLs müssen manuell in Ihren Win32-Prozessspeicher geladen werden. Es wird empfohlen, der Startmethode Ihres Moduls das manuelle Laden hinzuzufügen:

void StartupModule() override
{
#if PLATFORM_WINDOWS
	const FString LibrariesDir = FPaths::ProjectPluginsDir() / "MyModule" / THIRDPARTY_BINARY_SUBFOLDER;
	FPlatformProcess::PushDllDirectory(*LibrariesDir);

	const FString DllName = "Microsoft.MixedReality.QR.dll";
	if (!FPlatformProcess::GetDllHandle(*DllName))
	{
		UE_LOG(LogHMD, Warning, TEXT("Dll \'%s\' can't be loaded from \'%s\'"), *DllName, *LibrariesDir);
	}

	FPlatformProcess::PopDllDirectory(*LibrariesDir);
#endif
}

Schließlich können Sie WinRT-Header in Ihren Code einschließen, wie im vorherigen Abschnitt beschrieben.

4.25

Unreal kompiliert WinRT-Code in Version 4.25 nicht nativ. Daher ist es Ihr Auftrag, eine separate Binärdatei zu erstellen, die das Buildsystem von Unreal nutzen kann.

Ziele

• Erstellen einer universellen Windows-DLL, die ein FileSaveDialogue öffnet
• Verknüpfen dieser DLL mit einem Unreal-Spielprojekt
• Speichern einer Datei auf der HoloLens aus einer Unreal-Blaupause mithilfe der neuen DLL

Erste Schritte

1. Überprüfen Sie, ob Sie alle erforderlichen Tools installiert haben.
2. Erstellen Sie ein neues Unreal-Projekt, und nennen Sie es Consumewinrt.
3. Aktivieren der erforderlichen Plug-Ins für die HoloLens-Entwicklung
4. Setup für die Bereitstellung auf einem Gerät oder Emulator

Erstellen einer WinRT-DLL

1. Öffnen Sie ein neues Visual Studio-Projekt, und erstellen Sie ein DLL-Projekt (Universelles Windows) -Projekt im selben Verzeichnis wie die uproject-Datei des Unreal-Spiels .

2. Nennen Sie das Projekt HoloLensWinrtDLL , und legen Sie den Speicherort als ThirdParty-Unterverzeichnis auf die uproject-Datei des Unreal-Spiels fest.
   • Wählen Sie Projektmappe und Projekt im selben Verzeichnis platzieren aus, um die Spätere Suche nach Pfaden zu vereinfachen.

Wichtig

Achten Sie nach der Kompilierung des neuen Projekts besonders auf die leeren cpp- und Headerdateien namens HoloLensWinrtDLL.cpp bzw . HoloLensWinrtDLL.h . Der Header ist die Include-Datei, die die DLL in Unreal verwendet, während der cpp den Text aller von Ihnen exportierten Funktionen enthält und winRT-Code enthält, den Unreal andernfalls nicht kompilieren könnte.

3. Bevor Sie Code hinzufügen, müssen Sie die Projekteigenschaften aktualisieren, um sicherzustellen, dass der von Ihnen benötigte WinRT-Code kompiliert werden kann:
   • Klicken Sie mit der rechten Maustaste auf das HoloLensWinrtDLL-Projekt, und wählen Sie Eigenschaften aus.
   • Ändern Sie die Dropdownliste Konfiguration in Alle Konfigurationen und die Dropdownliste Plattform in Alle Plattformen.
   • Unter Konfigurationseigenschaften> C/C++> Alle Optionen:
     • Hinzufügen von Await zu zusätzlichen Optionen , um sicherzustellen, dass wir auf asynchrone Aufgaben warten können
     • Ändern Sie den C++-Sprachstandard in ISO C++17 Standard (/std:c++17), um beliebigen WinRT-Code einzuschließen.

Ihr Projekt ist bereit, die DLL-Quelle mit WinRT-Code zu aktualisieren, der ein Dateidialogfeld öffnet und eine Datei auf dem HoloLens-Datenträger speichert.

Hinzufügen des DLL-Codes

1. Öffnen Sie HoloLensWinrtDLL.h, und fügen Sie eine dll exportierte Funktion hinzu, damit Unreal folgendes nutzt:

#pragma once

class HoloLensWinrtDLL
{
public:
    _declspec(dllexport) static void OpenFileDialogue();
};

2. Öffnen Sie HoloLensWinrtDLL.cpp, und fügen Sie alle Header hinzu, die die Klasse verwendet:

#include "pch.h"
#include "HoloLensWinrtDLL.h"

#include <winrt/Windows.Storage.h>
#include <winrt/Windows.Storage.Streams.h>
#include <winrt/Windows.Storage.Pickers.h>
#include <winrt/Windows.Foundation.h>
#include <winrt/Windows.Foundation.Collections.h>

#include <string>
#include <vector>
#include <thread>

Hinweis

Der gesamte WinRT-Code wird in HoloLensWinrtDLL.cpp gespeichert, sodass Unreal beim Verweisen auf den Header keinen WinRT-Code einschließt.

3. Fügen Sie weiterhin in HoloLensWinrtDLL.cpp einen Funktionstext für OpenFileDialogue() und den gesamten unterstützten Code hinzu:

// sgm is declared outside of OpenFileDialogue so it doesn't
// get destroyed when OpenFileDialogue goes out of scope.
SaveGameManager sgm;

void HoloLensWinrtDLL::OpenFileDialogue()
{
    sgm.SaveGame();
}

4. Fügen Sie holoLensWinrtDLL.cpp eine SaveGameManager-Klasse hinzu, um den Dateidialog zu verarbeiten und die Datei zu speichern:

class SaveGameManager
{
public:
    SaveGameManager()
    {
    }

    ~SaveGameManager()
    {
        // Wait for currently running thread to complete before terminating.
        if(m_thread.joinable())
        {
            m_thread.join();
        }
    }

    void SaveGame()
    {
        OpenFileDialogueAction();
    }

private:
    winrt::Windows::Storage::StorageFile m_file = winrt::Windows::Storage::StorageFile(nullptr);
    std::thread m_thread;

    winrt::Windows::Foundation::IAsyncAction OpenFileDialogueAction()
    {
        std::vector<winrt::hstring> extensions;
        extensions.push_back(L".txt");

        auto picker = winrt::Windows::Storage::Pickers::FileSavePicker();

        // FileSavePicker needs a file type to open without errors.
        picker.FileTypeChoices().Insert(L"Plain Text",
                                        winrt::single_threaded_vector<winrt::hstring>(
                                        std::move(extensions)));

        // Opening the FilePicker must be done on the Game UI thread.
        // Any other IAsyncOperations should be done on a background thread.
        m_file = co_await picker.PickSaveFileAsync();

        if(m_file)
        {
            // Unreal's game thread is an STA, async tasks need to run on
            // a background MTA thread, or waiting on them will deadlock.    
            std::thread thread([this]() { RunThread(); });
            m_thread = std::move(thread);
        }
    }

    void RunThread()
    {
        // Ensure this thread is an MTA
        winrt::init_apartment();
        Run().get();
    }

    winrt::Windows::Foundation::IAsyncAction Run()
    {
        co_await winrt::Windows::Storage::FileIO::WriteTextAsync(
                m_file, L"Hello WinRT");
    }
};

5. Erstellen Sie die Lösung für Release > ARM64 , um die DLL aus der DLL-Lösung in das untergeordnete Verzeichnis ARM64/Release/HoloLensWinrtDLL zu erstellen.

Hinzufügen der WinRT-Binärdatei zu Unreal

Das Verknüpfen und Verwenden einer DLL in Unreal erfordert ein C++-Projekt. Wenn Sie ein Blueprint-Projekt verwenden, kann es einfach in ein C++-Projekt konvertiert werden, indem Sie eine C++-Klasse hinzufügen:

1. Öffnen Sie im Unreal-Editor File > New C++-Klasse... und erstellen Sie einen neuen Actor mit dem Namen WinrtActor , um den Code in der DLL auszuführen:

Hinweis

Eine Lösung wurde nun im selben Verzeichnis wie die uproject-Datei erstellt, zusammen mit einem neuen Buildskript namens Source/ConsumeWinRT/ConsumeWinRT.Build.cs.

2. Öffnen Sie die Projektmappe, suchen Sie nach dem Ordner Games/ConsumeWinRT/Source/ConsumeWinRT , und öffnen Sie ConsumeWinRT.build.cs:

Verknüpfen der DLL

1. Fügen Sie in ConsumeWinRT.build.cs eine Eigenschaft hinzu, um den include-Pfad für die DLL (das Verzeichnis mit HoloLensWinrtDLL.h) zu suchen. Die DLL befindet sich in einem untergeordneten Verzeichnis zum Includepfad, sodass diese Eigenschaft als binäres Stammverzeichnis verwendet wird:

using System.IO;

public class ConsumeWinRT : ModuleRules
{
    private string WinrtIncPath
    {
        get 
        {
            string ModulePath = Path.GetDirectoryName(
                   RulesCompiler.GetFileNameFromType(this.GetType()));

            // Third party directory is at the project root,
            // which is two directories up from the game .exe (Binaries/HoloLens)
            return Path.GetFullPath(
                   Path.Combine(ModulePath,
                   "../../ThirdParty/HoloLensWinrtDLL"));
        }
    }
}

2. Fügen Sie im Klassenkonstruktor den folgenden Code hinzu, um den Includepfad zu aktualisieren, die neue lib zu verknüpfen und das Laden zu verzögern, und kopieren Sie die DLL an den gepackten Appx-Speicherort:

public ConsumeWinRT(ReadOnlyTargetRules target) : base(Target)
{
    // This is the directory the DLL's include header is in.
    PublicIncludePaths.Add(WinrtIncPath);

    // The code in HoloLensWinrtDLL will only work in a Windows Store app.
    // Only link these binaries for HoloLens.
    // Similar code can be written for desktop and similarly linked 
    // to use the same features when using Holographic Remoting.
    if(Target.Platform == UnrealTargetPlatform.HoloLens)
    {
        // Link the lib
        PublicAdditionalLibraries.Add(Path.Combine(
              WinrtIncPath, "ARM64", "Release",
              "HoloLensWinrtDLL","HoloLensWinrtDLL.lib"));

        string winrtDLL = "HoloLensWinrtDLL.dll";
        // Mark the dll to be DelayLoaded
        PublicDelayLoadDLLs.Add(winrtDLL);
        // RuntimeDependencies are included in packaged builds.
        RuntimeDependencies.Add(Path.Combine(WinrtIncPath,
                "ARM64", "Release", "HoloLensWinrtDLL", winrtDLL));
    }

    // Preserve the original code in build.cs below:
}

3. Öffnen Sie WinrtActor.h , und fügen Sie eine Funktionsdefinition hinzu, die von einer Blaupause aufgerufen wird:

public:
    UFUNCTION(BlueprintCallable)
    static void OpenFileDialogue();

4. Öffnen Sie WinrtActor.cpp , und aktualisieren Sie BeginPlay, um die DLL zu laden:

void AWinrtActor::BeginPlay()
{
	Super::BeginPlay();

    // Gets path to DLL location
	const FString BinDir = FPaths::ProjectDir() / 
		"ThirdParty" / "HoloLensWinrtDLL" / 
		"arm64" / "Release" / "HoloLensWinrtDLL";

    // Loads DLL into application
	void * dllHandle = FPlatformProcess::GetDllHandle(
		*(BinDir / "HoloLensWinrtDLL.dll"));
}

void AWinrtActor::OpenFileDialogue()
{
#if PLATFORM_HOLOLENS
	HoloLensWinrtDLL::OpenFileDialogue();
#endif
}

Achtung

Die DLL muss geladen werden, bevor eine ihrer Funktionen aufgerufen wird.

Erstellen des Spiels

1. Erstellen Sie die Spiellösung, um den Unreal-Editor zu starten, der für das Spielprojekt geöffnet ist:
   • Suchen Sie auf der Registerkarte Akteure platzieren nach dem neuen WinrtActor , und ziehen Sie ihn in die Szene.
   • Öffnen Sie die Level-Blaupause, um die blaupausenaufrufbare Funktion im WinrtActor auszuführen.

2. Suchen Sie im World Outliner den WindrtActor , der zuvor in die Szene abgelegt wurde, und ziehen Sie ihn in die Blaupause der Ebene:

3. Ziehen Sie in der Blaupause der Ebene den Ausgabeknoten aus WinrtActor, suchen Sie nach Dateidialogfeld öffnen, und leiten Sie den Knoten dann von jeder Benutzereingabe weiter. In diesem Fall wird open file dialogue von einem Sprachereignis aufgerufen:

4. Packen Sie dieses Spiel für HoloLens, stellen Sie es bereit, und führen Sie es aus.

Wenn Unreal OpenFileDialogue aufruft, wird ein Dateidialogfeld auf der HoloLens geöffnet, der zur Eingabe eines .txt Dateinamens auffordert. Nachdem die Datei gespeichert wurde, wechseln Sie im Geräteportal zur Registerkarte Datei-Explorer , um den Inhalt "Hello WinRT" anzuzeigen.

Zusammenfassung

Wir empfehlen Ihnen, dieses Tutorial als Ausgangspunkt für die Verwendung von WinRT-Code in Unreal zu verwenden, wenn Sie Dateien mit demselben Dateidialog wie Windows auf dem HoloLens-Datenträger speichern müssen. Der gleiche Prozess gilt für den Export zusätzlicher Funktionen aus dem HoloLensWinrtDLL-Header, der in Unreal verwendet wird. Achten Sie besonders auf den DLL-Code, der auf asynchronen WinRT-Code in einem MTA-Hintergrundthread wartet, wodurch ein Deadlocking des Unreal-Spielthreads vermieden wird.

Nächster Entwicklungsprüfpunkt

Wenn Sie der Unity-Entwicklungs-Journey folgen, die wir entworfen haben, befinden Sie sich mitten im Kennenlernen der Mixed Reality-Plattformfunktionen und APIs. Von hier aus können Sie mit jedem Thema fortfahren oder direkt zur Bereitstellung Ihrer App auf einem Gerät oder Emulator springen.

Bereitstellung auf Gerät

Weitere Informationen

• C++/WinRT-APIs
• FileSavePicker-Klasse
• Unreal-Bibliotheken von Drittanbietern