Unreal'da WinRT

HoloLens geliştirme sürecinde WinRT kullanarak bir özellik yazmanız gerekebilir. Örneğin, HoloLens uygulamasında dosya iletişim kutusu açmak için winrt/Windows.Storage.Pickers.h üst bilgi dosyasında FileSavePicker gerekir. WinRT, Unreal'ın derleme sisteminde sürüm 4.26'dan itibaren desteklenir.

4.26

Standart WinRT API'leri

WinRT kullanmanın en yaygın ve en kolay yolu WinSDK'den yöntemleri çağırmaktır. Bunu yapmak için YourModule.Build.cs dosyasını açın ve aşağıdaki satırları ekleyin:

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

Ardından, aşağıdaki WinRT üst bilgilerini eklemeniz gerekir:

#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 kodu yalnızca Win64 ve HoloLens platformlarında derlenebilir, bu nedenle if deyimi WinRT kitaplıklarının diğer platformlara eklenmesini engeller. unknwn.h, IUnknown arabirimine sahip olduğu için eklendi.

NuGet paketinden WinRT

WinRT desteğine sahip bir NuGet paketi eklemeniz gerekiyorsa bu biraz daha karmaşıktır. Bu durumda Visual Studio neredeyse tüm işleri sizin yernize yapabilir, ancak Unreal derleme sistemi bunu yapamaz. Neyse ki çok zor değil. Aşağıda Microsoft.MixedReality.QR paketini indirme işlemine ilişkin bir örnek verilmiştir. Bunu başka bir dosyayla değiştirebilirsiniz, winmd dosyasını kaybetmediğinizden emin olun ve doğru dll dosyasını kopyalayın.

Önceki bölümdeki Windows SDK dll'leri işletim sistemi tarafından işlenir. NuGet'in dll'leri modülünüzdeki kod tarafından yönetilmelidir. Bunları indirmek, ikili dosyalar klasörüne kopyalamak ve modül başlangıcında işlem belleğine yüklemek için kod eklemenizi öneririz.

İlk adımda, modülünüzün kök klasörüne bir packages.config (/nuget/reference/packages-config) eklemeniz gerekir. Burada, tüm bağımlılıkları dahil olmak üzere indirmek istediğiniz tüm paketleri eklemeniz gerekir. Burada Microsoft.MixedReality.QR dosyasını birincil yük olarak ve iki diğerini de bağımlılık olarak ekledim. Bu dosyanın biçimi Visual Studio'dakiyle aynıdır:

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

Artık NuGet'i, gerekli paketleri indirebilir veya NuGet belgelerine bakabilirsiniz.

YourModule.Build.cs dosyasını açın ve aşağıdaki kodu ekleyin:

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

SafeCopy yöntemini aşağıdaki gibi tanımlamanız gerekir:

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 DLL'lerinin Win32 işlem belleğinize el ile yüklenmesi gerekir; modülünüzün başlangıç yöntemine el ile yükleme eklemenizi öneririz:

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
}

Son olarak, önceki bölümde açıklandığı gibi kodunuza WinRT üst bilgileri ekleyebilirsiniz.

4.25

Unreal, Sürüm 4.25'te WinRT kodunu yerel olarak derlemez, bu nedenle Unreal'ın derleme sisteminin kullanabileceği ayrı bir ikili dosya oluşturmak sizin görevinizdir.

Hedefler

• FileSaveDialogue'u açan bir Evrensel Windows DLL'i oluşturma
• Bu DLL'yi Bir Unreal oyun projesine bağlama
• Yeni DLL'yi kullanarak Bir Unreal şemasından HoloLens'e dosya kaydetme

Başlarken

1. Gerekli tüm araçların yüklü olup olmadığını denetleyin
2. Yeni bir Unreal projesi oluşturun ve buna Consumewinrt adını verin
3. HoloLens geliştirmesi için gerekli eklentileri etkinleştirme
4. Cihaza veya öykünücüye dağıtım için kurulum

WinRT DLL Oluşturma

1. Yeni bir Visual Studio projesi açın ve Unreal oyununun uproject dosyasıyla aynı dizinde bir DLL (Evrensel Windows) projesi oluşturun.

2. Projeyi HoloLensWinrtDLL olarak adlandırın ve konumu Bir ThirdParty alt dizini olarak Unreal oyununun uproject dosyasına ayarlayın.
   • Daha sonra yol aramayı basitleştirmek için Çözümü ve projeyi aynı dizine yerleştir'i seçin.

Önemli

Yeni proje derlendiğinde, sırasıyla HoloLensWinrtDLL.cpp ve HoloLensWinrtDLL.h adlı boş cpp ve üst bilgi dosyalarına özellikle dikkat edin. Üst bilgi, Unreal'da DLL'yi kullanan ekleme dosyasıdır, cpp ise dışarı aktardığınız işlevlerin gövdesini tutar ve Unreal'ın başka türlü derleyemeyeceği winRT kodlarını içerir.

3. Kod eklemeden önce, derlemeniz gereken WinRT kodunu sağlamak için proje özelliklerini güncelleştirmeniz gerekir:
   • HoloLensWinrtDLL projesine sağ tıklayın ve özellikleri seçin
   • Yapılandırma açılan listesini Tüm Yapılandırmalar ve Platform açılan listesini Tüm Platformlar olarak değiştirin
   • Yapılandırma Özellikleri> C/C++> Tüm Seçenekler altında:
     • Zaman uyumsuz görevlerde bekleyebileceğimizden emin olmak için Ek Seçenekler'eawait ekleyin
     • Herhangi bir WinRT kodu eklemek için C++ Dil Standart'ıISO C++17 Standard (/std:c++17) olarak değiştirin

Projeniz, dll dosyasının kaynağını bir dosya iletişim kutusu açan ve HoloLens diskine kaydeden WinRT koduyla güncelleştirmeye hazır.

DLL kodunu ekleme

1. HoloLensWinrtDLL.h dosyasını açın ve Unreal'ın tüketmesi için dll dışarı aktarılan bir işlev ekleyin:

#pragma once

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

2. HoloLensWinrtDLL.cpp dosyasını açın ve sınıfın kullanacağı tüm üst bilgileri ekleyin:

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

Not

Tüm WinRT kodları HoloLensWinrtDLL.cpp'de depolanır, bu nedenle Unreal üst bilgisine başvururken herhangi bir WinRT kodu eklemeyi denemez.

3. Yine HoloLensWinrtDLL.cpp'de OpenFileDialogue() ve desteklenen tüm kodlar için bir işlev gövdesi ekleyin:

// 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. Dosya iletişimini işlemek ve dosyayı kaydetmek için HoloLensWinrtDLL.cpp dosyasına bir SaveGameManager sınıfı ekleyin:

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. DLL'yi DLL çözümünden ARM64/Release>/HoloLensWinrtDLL alt dizinine derlemek için Release ARM64 çözümünü derleyin.

WinRT ikili dosyasını Unreal'a ekleme

Unreal'da DLL'yi bağlamak ve kullanmak için bir C++ projesi gerekir. Blueprint projesi kullanıyorsanız, C++ sınıfı ekleyerek kolayca C++ projesine dönüştürülebilir:

1. Unreal düzenleyicisinde Dosya > Yeni C++ Sınıfı... dosyasını açın ve kodu DLL'de çalıştırmak için WinrtActor adlı yeni bir Aktör oluşturun:

Not

Artık uproject dosyasıyla aynı dizinde Source/ConsumeWinRT/ConsumeWinRT.Build.cs adlı yeni bir derleme betiğiyle birlikte bir çözüm oluşturuldu.

2. Çözümü açın, Games/ConsumeWinRT/Source/ConsumeWinRT klasörüne göz atın ve ConsumeWinRT.build.cs dosyasını açın:

DLL'yi bağlama

1. ConsumeWinRT.build.cs içinde DLL'nin ekleme yolunu (HoloLensWinrtDLL.h içeren dizin) bulmak için bir özellik ekleyin. DLL, ekleme yolunun alt dizininde olduğundan, bu özellik ikili kök dir olarak kullanılır:

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. Sınıf oluşturucusunda, ekleme yolunu güncelleştirmek, yeni lib'i bağlamak ve gecikme yüklemesini yapmak ve DLL'yi paketlenmiş appx konumuna kopyalamak için aşağıdaki kodu ekleyin:

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. WinrtActor.h dosyasını açın ve şemanın çağıracağı bir işlev tanımı ekleyin:

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

4. WinrtActor.cpp dosyasını açın ve BEGINPlay'i güncelleştirerek DLL'yi yükleyin:

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
}

Dikkat

İŞLEVlerinden herhangi biri çağrılmadan önce DLL yüklenmelidir.

Oyunu oluşturma

1. Oyun projesine açılan Unreal düzenleyicisini başlatmak için oyun çözümünü oluşturun:
   • Aktörleri Yerleştir sekmesinde yeni WinrtActor'ı arayın ve sahnenin içine sürükleyin
   • WinrtActor'da şema çağrılabilen işlevini yürütmek için düzey şemasını açın

2. World Outliner'da, daha önce sahneye bırakılan WindrtActor'ı bulun ve seviye şemasına sürükleyin:

3. Düzey şemada çıkış düğümünü WinrtActor'dan sürükleyin, Dosya İletişim Kutusu Aç'ı arayın ve ardından düğümü herhangi bir kullanıcı girişinden yönlendirin. Bu durumda, Bir konuşma olayından Dosya Aç İletişim Kutusu çağrılır:

4. Bu oyunu HoloLens için paketleyip dağıtın ve çalıştırın.

Unreal OpenFileDialogue'u çağırdığında HoloLens'te .txt dosya adı isteyen bir Dosya İletişim Kutusu açılır. Dosya kaydedildikten sonra, "Hello WinRT" içeriğini görmek için cihaz portalında Dosya gezgini sekmesine gidin.

Özet

Dosyaları Windows ile aynı dosya iletişim kutusuyla HoloLens diskine kaydetmeniz gerektiğinde, Bu öğreticiyi Unreal'da WinRT kodunu kullanmak için bir başlangıç noktası olarak kullanmanızı öneririz. Aynı işlem HoloLensWinrtDLL üst bilgisinden ek işlevleri dışarı aktarmak ve Unreal'da kullanmak için de geçerlidir. Unreal oyun iş parçacığının kilitlenmesini önleyen arka plan MTA iş parçacığında zaman uyumsuz WinRT kodunda bekleyen DLL koduna özellikle dikkat edin.

Sonraki Geliştirme Denetim Noktası

Ortaya koyduğumuz Gerçek olmayan geliştirme yolculuğunu takip ediyorsanız, Karma Gerçeklik platformu özelliklerini ve API'lerini keşfetmenin tam ortasındasınız demektir. Buradan herhangi bir konuya devam edebilir veya doğrudan uygulamanızı bir cihaza veya öykünücüye dağıtmaya atlayabilirsiniz.

Cihaza dağıtma

Ayrıca bkz.

• C++/WinRT API'leri
• FileSavePicker sınıfı
• Unreal Üçüncü Taraf Kitaplıkları