HoloLens foto/videokamera i Unreal

Installation av PV-kameraflöde

• I Project Inställningar HoloLensaktiverar du funktionen Webbkamera:

• Skapa en ny skådespelare med namnet "CamCapture" och lägg till ett plan för att rendera kameraflödet:

• Lägg till skådespelaren i din scen, skapa ett nytt material som heter CamTextureMaterial med en Parameter för strukturobjekt och ett exempel på en struktur. Skicka rgb-data för strukturen till den tillåtande utdatafärgen:

Rendering av 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 strukturen från kameraflödet 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:

• Slutligen skalar du planet efter kamerabildens bredd–höjd-förhållande:

Hitta kamerapositioner i world space

Kameran på HoloLens 2 förskjuts lodrätt från enhetens huvudspårning. Det finns några funktioner för att hitta kameran i rymden för att ta hänsyn till förskjutningen.

GetPVCameraToWorldTransform hämtar transformeringen i rymden av PV-kameran och placeras på kameralinsen:

GetWorldSpaceRayFromCameraPoint kastar en tavla från kameralinsen till scenen i Unreal World-utrymmet för att hitta en pixels innehåll i kameraramen:

GetPVCameraIntrinsics returnerar kamerans inbyggda värden, som kan användas vid bearbetning av datorseende på en kameraram:

Om du vill hitta det som finns i rymden på en viss pixelkoordinat använder du en linjespårning med rymdbilden i världen:

Här kastar vi en 2-meter ray från kameralinsen till kamerautrymmets position 1/4 upptill till vänster på ramen. Använd sedan träffresultatet för att rendera något där objektet finns i världrymden:

När du använder rumslig mappning matchar träffpositionen den yta som kameran ser.

Rendering av PV-kameraflödet i C++

• Skapa en ny C++-skådespelare 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å parametern för struktur i CamTextureMaterial-materialet och skalar den statiska nätkomponenten med kameraramens bredd–höjd-förhållande:

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

Rendera från PV-kameran för MRC

Systemet och anpassade MRC-inspelare skapar mixade verklighetsbilder genom att kombinera PV-kameran med hologram som återges av appen.

Som standard använder mixed reality capture det högra ögats holografiska utdata. Om en integrerande app väljer att rendera från PV-kamerananvänds detta i stället. Återgivning från PV-kameran förbättrar mappningen mellan den verkliga världen och hologrammen i MRC-videon.

Så här väljer du att återge från PV-kameran:

1. Anropa SetEnabledMixedRealityCamera ochResizeMixedRealityCamera
   • Använd värdena Storlek X och Storlek Y för att ange videodimensionerna.

Unreal hanterar sedan begäranden från MRC som ska renderas från PV-kamerans perspektiv.

Använda PV-kameran

Webbkamerans struktur kan hämtas i spelet vid körning, men den måste vara aktiverad i redigeringsredigerarens Redigera Project Inställningar:

1. Gå till Plattformar HoloLens funktioner > och markera >
   • Använd funktionen StartCameraCapture för att använda webbkameran vid körning och funktionen StopCameraCapture för att stoppa inspelningen.

Återgivning av en bild

Så här renderar du kamerabilden:

1. Skapa en dynamisk materialinstans baserat på ett material i projektet, med namnet PVCamMat i skärmbilden nedan.
2. Ange den dynamiska materialinstansen till en variabel för dynamisk objektreferens för materialinstans.
3. Ange material för objektet i scenen som återger kameraflödet till den här nya dynamiska materialinstansen.
   • Starta en timer som ska användas för att binda kamerabilden till materialet.

4. Skapa en ny funktion för den här timern, i det här fallet MaterialTimer,och anropa GetARCameraImage för att hämta strukturen från webbkameran.
5. Om strukturen är giltig anger du en parameter för en struktur i skuggaren till bilden. Annars startar du materialtimern igen.

5. Kontrollera att materialet har en parameter som matchar namnet i SetTextureParameterValue som är bundet till en färgpost. Utan parametern kan kamerabilden inte visas korrekt.