WinRT w Unreal

Artykuł
07/12/2023

W trakcie opracowywania urządzenia HoloLens może być konieczne napisanie funkcji przy użyciu narzędzia WinRT. Na przykład otwarcie okna dialogowego pliku w aplikacji HoloLens wymaga pliku FileSavePicker w pliku nagłówkowym winrt/Windows.Storage.Pickers.h. WinRT jest obsługiwany w systemie kompilacji Unreal od wersji 4.26.

4.26
4.25

Standardowe interfejsy API WinRT

Najczęstszym i najprostszym sposobem użycia winRT jest wywołanie metod z zestawu WinSDK. W tym celu otwórz plik YourModule.Build.cs i dodaj następujące wiersze:

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"));
}

Następnie należy dodać następujące nagłówki WinRT:

#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

Kod WinRT można skompilować tylko na platformach Win64 i HoloLens, więc instrukcja if uniemożliwia dołączanie bibliotek WinRT na innych platformach. Dodano element unknwn.h do obsługi interfejsu IUnknown.

WinRT z pakietu NuGet

Jest to nieco bardziej skomplikowane, jeśli musisz dodać pakiet NuGet z obsługą winRT. W takim przypadku program Visual Studio może wykonać praktycznie wszystkie zadania, ale system kompilacji Unreal nie może. Na szczęście nie jest to zbyt trudne. Poniżej przedstawiono przykład pobierania pakietu Microsoft.MixedReality.QR. Możesz zastąpić go innym, po prostu upewnij się, że nie stracisz pliku winmd i skopiuj poprawną bibliotekę DLL.

Biblioteki DLL zestawu Windows SDK z poprzedniej sekcji są obsługiwane przez system operacyjny. Biblioteki DLL narzędzia NuGet muszą być zarządzane przez kod w module. Zalecamy dodanie kodu do ich pobrania, skopiowanie do folderu binaries i załadowanie do pamięci procesu podczas uruchamiania modułu.

W pierwszym kroku należy dodać packages.config (/nuget/reference/packages-config) do folderu głównego modułu. Należy dodać wszystkie pakiety, które chcesz pobrać, w tym wszystkie ich zależności. Tutaj dodałem microsoft.MixedReality.QR jako ładunek podstawowy i dwa inne jako zależności do niego. Format tego pliku jest taki sam jak w programie Visual Studio:

<?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>

Teraz możesz pobrać pakiet NuGet, wymagane pakiety lub zapoznać się z dokumentacją narzędzia NuGet.

Otwórz plik YourModule.Build.cs i dodaj następujący kod:

// 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"));
	}
}

Należy zdefiniować metodę SafeCopy w następujący sposób:

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);
	}
}

Biblioteki DLL nuGet muszą być ładowane do pamięci procesu Win32 ręcznie; Zalecamy dodanie ręcznego ładowania do metody uruchamiania modułu:

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
}

Na koniec możesz dołączyć nagłówki WinRT do kodu zgodnie z opisem w poprzedniej sekcji.

Unreal nie kompiluje natywnie kodu WinRT w wersji 4.25, dlatego twoim zadaniem jest skompilowanie oddzielnego pliku binarnego, z którego może korzystać system kompilacji Unreal.

Cele

Tworzenie uniwersalnej biblioteki DLL systemu Windows, która otwiera bibliotekę FileSaveDialogue
Łączenie tej biblioteki DLL z projektem gry Unreal
Zapisywanie pliku na urządzeniu HoloLens z strategii Unreal przy użyciu nowej biblioteki DLL

Wprowadzenie

Sprawdź, czy masz zainstalowane wszystkie wymagane narzędzia
Tworzenie nowego projektu Unreal i nadaj mu nazwę Consumewinrt
Włączanie wymaganych wtyczek na potrzeby programowania urządzenia HoloLens
Konfigurowanie wdrożenia na urządzeniu lub emulatorze

Tworzenie biblioteki DLL WinRT

Otwórz nowy projekt programu Visual Studio i utwórz projekt DLL (uniwersalny system Windows) w tym samym katalogu co plik uproject gry Unreal.

Tworzenie biblioteki DLL

Nadaj projektowi nazwę HoloLensWinrtDLL i ustaw lokalizację jako podkatalog ThirdParty na plik uproject gry Unreal.
- Wybierz pozycję Umieść rozwiązanie i projekt w tym samym katalogu, aby uprościć wyszukiwanie ścieżek później.

Konfigurowanie biblioteki DLL

Ważne

Po skompilowaniu nowego projektu zwróć szczególną uwagę na puste pliki cpp i nagłówków o nazwach HoloLensWinrtDLL.cpp i HoloLensWinrtDLL.h . Nagłówek jest plikiem dołączania, który używa biblioteki DLL w unreal, podczas gdy cpp przechowuje treść wszystkich funkcji eksportowanych i zawiera dowolny kod WinRT, który w przeciwnym razie nie będzie w stanie skompilować.

Przed dodaniem dowolnego kodu należy zaktualizować właściwości projektu, aby upewnić się, że potrzebny kod WinRT może zostać skompilowany:
- Kliknij prawym przyciskiem myszy projekt HoloLensWinrtDLL i wybierz właściwości
- Zmień listę rozwijaną Konfiguracja na Wszystkie konfiguracje i listę rozwijaną Platforma na Wszystkie platformy
- W obszarze Właściwości> konfiguracji C/C++> wszystkie opcje:
  - Dodaj oczekiwanie na dodatkowe opcje , aby upewnić się, że możemy czekać na zadania asynchroniczne
  - Zmień standard języka C++ na STANDARD ISO C++17 (/std:c++17), aby uwzględnić dowolny kod WinRT

Uaktualnianie właściwości projektu

Projekt jest gotowy do zaktualizowania źródła biblioteki DLL za pomocą kodu WinRT, który otwiera okno dialogowe pliku i zapisuje plik na dysku HoloLens.

Dodawanie kodu DLL

Otwórz plik HoloLensWinrtDLL.h i dodaj wyeksportowaną funkcję dll dla polecenia Unreal do użytku:

#pragma once

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

Otwórz plik HoloLensWinrtDLL.cpp i dodaj wszystkie nagłówki, których klasa będzie używać:

#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>

Uwaga

Cały kod WinRT jest przechowywany w pliku HoloLensWinrtDLL.cpp , więc Unreal nie próbuje dołączyć żadnego kodu WinRT podczas odwoływania się do nagłówka.

Nadal w pliku HoloLensWinrtDLL.cpp dodaj treść funkcji openFileDialogue() i cały obsługiwany kod:

// 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();
}

Dodaj klasę SaveGameManager do urządzenia HoloLensWinrtDLL.cpp , aby obsłużyć okno dialogowe pliku i zapisać plik:

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");
    }
};

Skompiluj rozwiązanie dla wydania > ARM64 , aby skompilować bibliotekę DLL do katalogu podrzędnego ARM64/Release/HoloLensWinrtDLL z rozwiązania DLL.

Dodawanie pliku binarnego WinRT do elementu Unreal

Łączenie i używanie biblioteki DLL w środowisku Unreal wymaga projektu języka C++. Jeśli używasz projektu strategii, można go łatwo przekonwertować na projekt C++, dodając klasę C++:

W edytorze Unreal otwórz plik > Nowa klasa C++ i utwórz nowy aktor o nazwie WinrtActor, aby uruchomić kod w dll:

Tworzenie nowego aktora

Uwaga

Rozwiązanie zostało utworzone w tym samym katalogu co plik uproject wraz z nowym skryptem kompilacji o nazwie Source/ConsumeWinRT/ConsumeWinRT.Build.cs.

Otwórz rozwiązanie, przejdź do folderu Games/ConsumeWinRT/Source/ConsumeWinRT i otwórz plik ConsumeWinRT.build.cs:

Otwieranie pliku ConsumeWinRT.build.cs

Łączenie biblioteki DLL

W pliku ConsumeWinRT.build.cs dodaj właściwość , aby znaleźć ścieżkę dołączania biblioteki DLL (katalog zawierający holoLensWinrtDLL.h). Biblioteka DLL znajduje się w katalogu podrzędnym ścieżki dołączania, więc ta właściwość będzie używana jako binarny katalog główny:

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"));
        }
    }
}

W konstruktorze klasy dodaj następujący kod, aby zaktualizować ścieżkę dołączania, połączyć nową bibliotekę i opóźnić ładowanie i skopiować bibliotekę DLL do spakowanej lokalizacji appx:

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:
}

Otwórz plik WinrtActor.h i dodaj jedną definicję funkcji, którą wywoła strategia:

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

Otwórz plik WinrtActor.cpp i zaktualizuj plik BeginPlay, aby załadować bibliotekę DLL:

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
}

Przestroga

Przed wywołaniem dowolnej z jego funkcji należy załadować bibliotekę DLL.

Tworzenie gry

Skompiluj rozwiązanie gry, aby uruchomić edytor Unreal otwarty w projekcie gry:
- Na karcie Umieść aktorów wyszukaj nowy element WinrtActor i przeciągnij go do sceny
- Otwórz strategię poziomu, aby wykonać funkcję wywoływaną strategii w narzędziu WinrtActor

Umieszczenie winrtActor w scenie

W programie World Outliner znajdź element WindrtActor wcześniej porzucony na scenę i przeciągnij go do strategii poziomu:

Przeciąganie winrtActor do strategii poziomu

W strategii poziomu przeciągnij węzeł wyjściowy z winrtActor, wyszukaj pozycję Otwórz okno dialogowe pliku, a następnie skierować węzeł z dowolnego danych wejściowych użytkownika. W takim przypadku dialog otwierania pliku jest wywoływany ze zdarzenia mowy:

Konfigurowanie węzłów w strategii poziomu

Spakuj tę grę dla urządzenia HoloLens, wdróż ją i uruchom.

Gdy Unreal wywołuje metodę OpenFileDialogue, zostanie otwarte okno dialogowe pliku na urządzeniu HoloLens monitujący o nazwę pliku .txt. Po zapisaniu pliku przejdź do karty Eksplorator plików w portalu urządzenia, aby wyświetlić zawartość "Hello WinRT".

Podsumowanie

Zachęcamy do korzystania z tego samouczka jako punktu wyjścia do korzystania z kodu WinRT w programie Unreal, gdy musisz zapisać pliki na dysku HoloLens przy użyciu tego samego okna dialogowego pliku co system Windows. Ten sam proces dotyczy eksportowania dodatkowych funkcji z nagłówka HoloLensWinrtDLL i używanych w rozwiązaniu Unreal. Zwróć szczególną uwagę na kod DLL, który czeka na asynchroniczny kod WinRT w wątku MTA w tle, co pozwala uniknąć zakleszczenia wątku gry Unreal.

Następny punkt kontrolny programowania

Jeśli śledzisz określoną przez nas podróż dewelopera Unreal, jesteś w trakcie eksplorowania możliwości platformy Mixed Reality i interfejsów API. W tym miejscu możesz przejść do dowolnego tematu lub przejść bezpośrednio do wdrażania aplikacji na urządzeniu lub emulatorze.

Wdrażanie na urządzeniu

Share via