HoloLens Foto/Videokamera i Unreal
HoloLens har en foto-/videokamera (PV) på visorn som kan användas både för Mixed Reality Capture (MRC) och för att hitta objekt i Unreal World Space från pixelkoordinater i kameraramen.
Viktigt
PV-kameran stöds inte med Holographic Remoting, men det är möjligt att använda en webbkamera som är ansluten till datorn för att simulera HoloLens PV-kamerafunktionen.
Installation av PV-kameraflöde
Viktigt
PV-kameran implementeras i både Windows Mixed Reality- och OpenXR-plugin-program. OpenXR måste dock ha Microsoft OpenXR-plugin-programmet installerat. OpenXR för Unreal 4.26 har också en begränsning: kameran kan arbeta med DirectX11 RHI. Den här begränsningen har åtgärdats i Unreal 4.27.1 eller senare.
- I Projektinställningar > HoloLens aktiverar du webbkamerafunktionen :
- Skapa en ny skådespelare med namnet "CamCapture" och lägg till ett plan för att återge kameraflödet:
- Lägg till aktören i din scen, skapa ett nytt material med namnet CamTextureMaterial med en texturobjektparameter och ett texturexempel. Skicka texturens rgb-data till utdatans tillåtande färg:
Återge PV-kameraflödet
- I CamCapture-skissen aktiverar du PV-kameran:
- Skapa en dynamisk materialinstans från CamTextureMaterial och tilldela det här materialet till aktörens plan:
- Hämta texturen från kameramatningen och tilldela den till det dynamiska materialet om det är giltigt. Om strukturen inte är giltig startar du en timer och försöker igen efter tidsgränsen:
- Skala slutligen planet efter kamerabildens bredd–höjd-förhållande:
Hitta kamerapositioner i världsrymden
Kameran på HoloLens 2 förskjuts vertikalt från enhetens huvudspårning. Det finns några funktioner för att hitta kameran i världsrymden för att kompensera för förskjutningen.
GetPVCameraToWorldTransform får omvandlingen i världsrymden för PV-kameran och kommer att placeras på kameralinsen:
GetWorldSpaceRayFromCameraPoint kastar en stråle från kameralinsen till scenen i Unreal world space för att hitta en pixels innehåll i kameraramen:
GetPVCameraIntrinsics returnerar kamerans inbyggda värden, som kan användas vid bearbetning av visuellt innehåll på en kameraram:
Om du vill hitta det som finns i världsrymden vid en viss pixelkoordinat använder du en linjespårning med världsrymdsstrålen:
Här kastar vi en 2-meters stråle från kameralinsen till kamerautrymmets position 1/4 från det övre vänstra hörnet av ramen. Använd sedan träffresultatet för att återge något där objektet finns i världsrymden:
När du använder rumslig mappning matchar träffpositionen den yta som kameran ser.
Återge PV-kameraflödet i C++
- Skapa en ny C++-aktör med namnet CamCapture
- I projektets build.cs lägger du till "AugmentedReality" i listan PublicDependencyModuleNames:
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"AugmentedReality"
});
- I CamCapture.h inkluderar du ARBlueprintLibrary.h
#include "ARBlueprintLibrary.h"
- Du måste också lägga till lokala variabler för nät och material:
private:
UStaticMesh* StaticMesh;
UStaticMeshComponent* StaticMeshComponent;
UMaterialInstanceDynamic* DynamicMaterial;
bool IsTextureParamSet = false;
- I CamCapture.cpp uppdaterar du konstruktorn för att lägga till ett statiskt nät i scenen:
ACamCapture::ACamCapture()
{
PrimaryActorTick.bCanEverTick = true;
// Load a mesh from the engine to render the camera feed to.
StaticMesh = LoadObject<UStaticMesh>(nullptr, TEXT("/Engine/EngineMeshes/Cube.Cube"), nullptr, LOAD_None, nullptr);
// Create a static mesh component to render the static mesh
StaticMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("CameraPlane"));
StaticMeshComponent->SetStaticMesh(StaticMesh);
// Scale and add to the scene
StaticMeshComponent->SetWorldScale3D(FVector(0.1f, 1, 1));
this->SetRootComponent(StaticMeshComponent);
}
I BeginPlay skapar du en dynamisk materialinstans från projektets kameramaterial, tillämpar den på komponenten för statiskt nät och startar HoloLens-kameran.
I redigeraren högerklickar du på CamTextureMaterial i innehållswebbläsaren och väljer "Kopiera referens" för att hämta strängen för CameraMatPath.
void ACamCapture::BeginPlay()
{
Super::BeginPlay();
// Create a dynamic material instance from the game's camera material.
// Right-click on a material in the project and select "Copy Reference" to get this string.
FString CameraMatPath("Material'/Game/Materials/CamTextureMaterial.CamTextureMaterial'");
UMaterial* BaseMaterial = (UMaterial*)StaticLoadObject(UMaterial::StaticClass(), nullptr, *CameraMatPath, nullptr, LOAD_None, nullptr);
DynamicMaterial = UMaterialInstanceDynamic::Create(BaseMaterial, this);
// Use the dynamic material instance when rendering the camera mesh.
StaticMeshComponent->SetMaterial(0, DynamicMaterial);
// Start the webcam.
UARBlueprintLibrary::ToggleARCapture(true, EARCaptureType::Camera);
}
I Tick hämtar du strukturen från kameran, ställer in den på texturparametern i CamTextureMaterial-materialet och skalar den statiska nätkomponenten efter kameraramens proportioner:
void ACamCapture::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
// Dynamic material instance only needs to be set once.
if(IsTextureParamSet)
{
return;
}
// Get the texture from the camera.
UARTexture* ARTexture = UARBlueprintLibrary::GetARTexture(EARTextureType::CameraImage);
if(ARTexture != nullptr)
{
// Set the shader's texture parameter (named "Param") to the camera image.
DynamicMaterial->SetTextureParameterValue("Param", ARTexture);
IsTextureParamSet = true;
// Get the camera instrincs
FARCameraIntrinsics Intrinsics;
UARBlueprintLibrary::GetCameraIntrinsics(Intrinsics);
// Scale the camera mesh by the aspect ratio.
float R = (float)Intrinsics.ImageResolution.X / (float)Intrinsics.ImageResolution.Y;
StaticMeshComponent->SetWorldScale3D(FVector(0.1f, R, 1));
}
}
Nästa kontrollpunkt för utveckling
Om du följer unreal-utvecklingsresan som vi har lagt fram är du mitt uppe i att utforska Mixed Reality plattformsfunktioner och API:er. Härifrån kan du fortsätta till nästa avsnitt:
Eller gå direkt till distributionen av appen på en enhet eller emulator:
Du kan alltid gå tillbaka till kontrollpunkterna för Unreal-utveckling när som helst.