WinRT az Unrealben

A HoloLens-fejlesztés során előfordulhat, hogy a WinRT használatával kell írnia egy funkciót. Ha például egy HoloLens-alkalmazásban nyit meg egy fájlpárbeszédet, akkor a FileSavePicker fájlra van szükség a winrt/Windows.Storage.Pickers.h fejlécfájlban. A WinRT az Unreal buildrendszerében már a 4.26-os verziótól támogatott.

4.26

A standard WinRT API-k

A WinRT használatának leggyakoribb és legegyszerűbb módja a WinSDK metódusainak meghívása. Ehhez nyissa meg a YourModule.Build.cs fájlt, és adja hozzá a következő sorokat:

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

Ezután a következő WinRT-fejléceket kell hozzáadnia:

#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

A WinRT-kód csak a Win64- és HoloLens-platformokon fordítható le, így az if utasítás megakadályozza, hogy a WinRT-kódtárak más platformokra is bekerülhessenek. Az unknwn.h hozzá lett adva az IUnknown felülethez.

WinRT NuGet-csomagból

Ez egy kicsit bonyolultabb, ha WinRT-támogatással rendelkező NuGet-csomagot kell hozzáadnia. Ebben az esetben a Visual Studio gyakorlatilag minden feladatot el tud végezni, de az Unreal buildelési rendszere nem. Szerencsére nem túl nehéz. Az alábbi példa bemutatja, hogyan töltheti le a Microsoft.MixedReality.QR csomagot. Lecserélheti egy másikra, csak győződjön meg arról, hogy nem veszíti el a winmd fájlt, és másolja a megfelelő dll-t.

Az előző szakaszban szereplő Windows SDK dll-eket az operációs rendszer kezeli. A NuGet dll-eit a modul kódjának kell kezelnie. Javasoljuk, hogy a modul indításakor adjon hozzá kódot a letöltésükhöz, a bináris fájlok mappába való másoláshoz és a folyamatmemória betöltéséhez.

Az első lépésben hozzá kell adnia egy packages.config (/nuget/reference/packages-config) a modul gyökérmappájához. Itt fel kell vennie az összes letölteni kívánt csomagot, beleértve az összes függőségüket is. Itt hozzáadtam a Microsoft.MixedReality.QR-t elsődleges hasznos adatként, két másikat pedig függőségként. A fájl formátuma megegyezik a Visual Studióval:

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

Most letöltheti a NuGetet, a szükséges csomagokat, vagy megtekintheti a NuGet dokumentációját.

Nyissa meg a YourModule.Build.cs fájlt, és adja hozzá a következő kódot:

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

A SafeCopy metódust a következőképpen kell definiálnia:

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

A NuGet DLL-eket manuálisan kell betölteni a Win32-folyamat memóriájába; javasoljuk, hogy adja hozzá a manuális betöltést a modul indítási módszeréhez:

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
}

Végül a WinRT-fejléceket is belefoglalhatja a kódba az előző szakaszban leírtak szerint.

4.25

Az Unreal natív módon nem fordítja le a WinRT-kódot a 4.25-ös verzióban, ezért önnek kell létrehoznia egy különálló bináris fájlt, amelyet az Unreal buildrendszere felhasználhat.

Célkitűzések

• Univerzális Windows DLL létrehozása, amely megnyitja a FileSaveDialogue fájlt
• A DLL csatolása egy Unreal-játékprojekthez
• Fájl mentése a HoloLensre egy Unreal-tervből az új DLL használatával

Első lépések

1. Ellenőrizze, hogy telepítve van-e az összes szükséges eszköz
2. Hozzon létre egy új Unreal-projektet, és nevezze el Consumewinrt néven
3. A HoloLens-fejlesztéshez szükséges beépülő modulok engedélyezése
4. Eszközre vagy emulátorra történő üzembe helyezés beállítása

WinRT DLL létrehozása

1. Nyisson meg egy új Visual Studio-projektet, és hozzon létre egy DLL-projektet (Universal Windows) ugyanabban a könyvtárban, mint az Unreal játék uproject fájlja.

2. Nevezze el a projektet HoloLensWinrtDLL néven, és állítsa a helyet ThirdParty alkönyvtárként az Unreal játék uproject fájljára.
   • Válassza a Megoldás és projekt elhelyezése ugyanabban a könyvtárban lehetőséget, hogy később egyszerűbb legyen az elérési utak keresése.

Fontos

Az új projekt fordítása után különös figyelmet kell fordítani a HoloLensWinrtDLL.cpp és HoloLensWinrtDLL.h nevű üres cpp- és fejlécfájlokra. A fejléc a DLL-t az Unrealben használó belefoglalási fájl, míg a cpp az exportált függvények törzsét tárolja, és tartalmaz minden olyan WinRT-kódot, amelyet az Unreal egyébként nem tud lefordítani.

3. Mielőtt kódot ad hozzá, frissítenie kell a projekttulajdonságokat, hogy biztosítsa a lefordítható WinRT-kódot:
   • Kattintson a jobb gombbal a HoloLensWinrtDLL projektre, és válassza a tulajdonságokat
   • Módosítsa a Configuration (Konfiguráció ) legördülő listát minden konfigurációra , a Platform legördülő menüt pedig a Minden platformra
   • A Konfiguráció tulajdonságai> C/C++> Minden beállítás csoportban:
     • Várakozás hozzáadása a További beállításokhoz, hogy meg tudjuk várni az aszinkron feladatokat
     • Módosítsa a C++ Language StandardotISO C++17 Standard (/std:c+++17) szabványra, hogy minden WinRT-kódot tartalmazzon

A projekt készen áll a DLL forrásának frissítésére WinRT-kóddal, amely megnyit egy fájlpárbeszédet, és ment egy fájlt a HoloLens-lemezre.

A DLL-kód hozzáadása

1. Nyissa meg a HoloLensWinrtDLL.h fájlt , és adjon hozzá egy dll exportált függvényt az Unreal használatához:

#pragma once

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

2. Nyissa meg a HoloLensWinrtDLL.cpp fájlt, és adja hozzá az osztály által használt összes fejlécet:

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

Megjegyzés

Az összes WinRT-kód a HoloLensWinrtDLL.cpp fájlban van tárolva, így az Unreal nem próbál WinRT-kódot felvenni a fejlécre való hivatkozáskor.

3. Még mindig a HoloLensWinrtDLL.cpp fájlban adjon hozzá egy függvénytörzset az OpenFileDialogue() elemhez, valamint az összes támogatott kódot:

// 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. Adjon hozzá egy SaveGameManager osztályt a HoloLensWinrtDLL.cpp fájlhoz a fájl párbeszédének kezeléséhez és a fájl mentéséhez:

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. Hozza létre az ARM64 kiadás > megoldását, hogy a DLL-t a DLL-megoldásból az ARM64/Release/HoloLensWinrtDLL gyermekkönyvtárba hozza létre.

A WinRT bináris hozzáadása az Unrealhez

A DLL-nek az Unrealben való összekapcsolásához és használatához C++ projektre van szükség. Ha tervprojektet használ, az egyszerűen átalakítható C++ projektté egy C++ osztály hozzáadásával:

1. Az Unreal szerkesztőben nyissa meg a Fájl > új C++ osztályát... és hozzon létre egy új, WinrtActor nevű aktort a kód DLL-ben való futtatásához:

Megjegyzés

A megoldás most már ugyanabban a könyvtárban lett létrehozva, mint az uproject fájl, valamint egy source/ConsumeWinRT/ConsumeWinRT.Build.cs nevű új buildszkript.

2. Nyissa meg a megoldást, keresse meg a Games/ConsumeWinRT/Source/ConsumeWinRT mappát, és nyissa meg a ConsumeWinRT.build.cs fájlt:

A DLL csatolása

1. A ConsumeWinRT.build.cs fájlban adjon hozzá egy tulajdonságot a DLL (a HoloLensWinrtDLL.h könyvtár) belefoglalási útvonalának megkereséséhez. A DLL egy gyermekkönyvtárban található a belefoglalási elérési úthoz, így ez a tulajdonság lesz bináris gyökérkönyvtárként használva:

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. Az osztálykonstruktorban adja hozzá a következő kódot a belefoglalási útvonal frissítéséhez, az új lib csatolásához és a késleltetési betöltéshez, majd másolja a DLL-t a csomagolt appx helyre:

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. Nyissa meg a WinrtActor.h fájlt, és adjon hozzá egy függvénydefiníciót, amelyet egy terv meghív:

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

4. Nyissa meg a WinrtActor.cpp fájlt, és frissítse a BeginPlay fájlt a DLL betöltéséhez:

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
}

Figyelemfelhívás

A DLL-t be kell tölteni, mielőtt meghívja bármelyik függvényét.

A játék felépítése

1. Készítse el a játékmegoldást, hogy elindítsa a játékprojekthez megnyitott Unreal-szerkesztőt:
   • A Szereplők elhelyezése lapon keresse meg az új WinrtActort , és húzza a jelenetbe
   • Nyissa meg a szinttervet a WinrtActorban a terv hívható függvényének végrehajtásához

2. A World Outlinerben keresse meg a korábban a jelenetbe vetett WindrtActort , és húzza a szinttervbe:

3. A szinttervben húzza a kimeneti csomópontot a WinrtActorból, keresse meg a Fájl párbeszéd megnyitása lehetőséget, majd iránytassa a csomópontot bármely felhasználói bemenetről. Ebben az esetben a rendszer beszédeseményből hívja meg a Fájlmegnyitási párbeszédet:

4. Csomagolja be ezt a játékot a HoloLens-hez, telepítse és futtassa.

Amikor az Unreal meghívja az OpenFileDialogue fájlt, a HoloLensben megnyílik egy fájlpárbeszéd, amely egy .txt fájlnevet kér. A fájl mentése után lépjen az eszközportál Fájlkezelő lapjára a "Hello WinRT" tartalom megtekintéséhez.

Összefoglalás

Javasoljuk, hogy használja ezt az oktatóanyagot kiindulási pontként a WinRT-kód Unrealben való használatához, ha fájlokat kell mentenie a HoloLens-lemezre a Windows fájlpárbeszédével. Ugyanez a folyamat vonatkozik a További függvények a HoloLensWinrtDLL fejlécből való exportálására, és az Unrealben használatos. Ügyeljen arra a DLL-kódra, amely aszinkron WinRT-kódra várakozik egy háttérbeli MTA-szálban, így elkerülhető az Unreal-játékszál holtpontra helyezése.

Következő fejlesztési ellenőrzőpont

Ha az Általunk meghatározott Unreal fejlesztési folyamatot követi, akkor a Mixed Reality platform képességeinek és API-jainak felfedezése közben jár. Innen folytathatja bármelyik témakört , vagy közvetlenül az alkalmazás eszközre vagy emulátorra való üzembe helyezésére ugorhat.

Üzembe helyezés az eszközön

Lásd még

• C++/WinRT API-k
• FileSavePicker osztály
• Irreális külső kódtárak