Rendering in DirectX

Notitie

Dit artikel heeft betrekking op de verouderde, native WinRT-API's. Voor nieuwe native app-projecten raden we u aan de OpenXR-API te gebruiken.

Windows Mixed Reality is gebouwd op DirectX om rijke, 3D grafische ervaringen voor gebruikers te produceren. De renderingabstratie bevindt zich net boven DirectX, waarmee apps kunnen redeneren over de positie en oriëntatie van holografische scènewaarnemers die door het systeem worden voorspeld. De ontwikkelaar kan vervolgens zijn hologrammen vinden op basis van elke camera, zodat de app deze hologrammen kan renderen in verschillende ruimtelijke coördinatensystemen terwijl de gebruiker zich verplaatst.

Opmerking: in dit scenario wordt holografische rendering in Direct3D 11 beschreven. Er wordt ook een Direct3D 12 Windows Mixed Reality-app-sjabloon geleverd met de extensie Mixed Reality app-sjablonen.

Bijwerken voor het huidige frame

Als u de toepassingstoestand voor hologrammen wilt bijwerken, gaat de app eenmaal per frame als volgende te werk:

  • Haal een HolographicFrame op uit het weergavebeheersysteem.
  • Werk de scène bij met de huidige voorspelling van waar de cameraweergave is wanneer het renderen is voltooid. Houd er rekening mee dat er meer dan één camera voor de holografische scène kan zijn.

Als u weergaven van holografische camera's wilt renderen, gaat de app eenmaal per frame als volgende te werk:

  • Geef voor elke camera de scène voor het huidige frame weer met behulp van de cameraweergave en projectie-matrices van het systeem.

Een nieuw holografische frame maken en de voorspelling ervan op halen

Het HolographicFrame heeft informatie die de app nodig heeft om het huidige frame bij te werken en weer te geven. De app begint elk nieuw frame door de methode CreateNextFrame aan te roepen. Wanneer deze methode wordt aangeroepen, worden voorspellingen gedaan met behulp van de meest recente beschikbare sensorgegevens en ingekapseld in het CurrentPrediction-object .

Er moet een nieuw frameobject worden gebruikt voor elk gerenderd frame, omdat dit slechts een ogenblik geldig is. De eigenschap CurrentPrediction bevat informatie zoals de camerapositie. De informatie wordt ge extrapoleerd naar het exacte moment in de tijd waarop het frame naar verwachting zichtbaar is voor de gebruiker.

De volgende code is afkomstig uit AppMain::Update:

// The HolographicFrame has information that the app needs in order
// to update and render the current frame. The app begins each new
// frame by calling CreateNextFrame.
HolographicFrame holographicFrame = m_holographicSpace.CreateNextFrame();

// Get a prediction of where holographic cameras will be when this frame
// is presented.
HolographicFramePrediction prediction = holographicFrame.CurrentPrediction();

Camera-updates verwerken

Back-buffers kunnen van frame naar frame worden gewijzigd. Uw app moet de back-buffer voor elke camera valideren en zo nodig resourceweergaven en dieptebuffers vrijgeven en opnieuw maken. U ziet dat de set met houdingen in de voorspelling de gezaghebbende lijst is met camera's die in het huidige frame worden gebruikt. Normaal gesproken gebruikt u deze lijst om de set camera's te itereren.

Vanuit AppMain::Update:

m_deviceResources->EnsureCameraResources(holographicFrame, prediction);

Van DeviceResources::EnsureCameraResources:

for (HolographicCameraPose const& cameraPose : prediction.CameraPoses())
{
    HolographicCameraRenderingParameters renderingParameters = frame.GetRenderingParameters(cameraPose);
    CameraResources* pCameraResources = cameraResourceMap[cameraPose.HolographicCamera().Id()].get();
    pCameraResources->CreateResourcesForBackBuffer(this, renderingParameters);
}

Het coördinaatsysteem gebruiken als basis voor rendering

Windows Mixed Reality app verschillende coördinatensystemen kan maken, zoals gekoppelde en stationaire referentieframes voor het bijhouden van locaties in de fysieke wereld. Uw app kan deze coördinatensystemen vervolgens gebruiken om te redeneren waar hologrammen elk frame moeten worden weergegeven. Wanneer u coördinaten van een API aanvraagt, moet u altijd het SpatialCoordinateSystem doorgeven waarin u wilt dat deze coördinaten worden uitgedrukt.

Vanuit AppMain::Update:

pose = SpatialPointerPose::TryGetAtTimestamp(
    m_stationaryReferenceFrame.CoordinateSystem(), prediction.Timestamp());

Deze coördinatensystemen kunnen vervolgens worden gebruikt voor het genereren van stereoweergave-matrices bij het weergeven van de inhoud in uw scène.

Vanuit CameraResources::UpdateViewProjectionBuffer:

// Get a container object with the view and projection matrices for the given
// pose in the given coordinate system.
auto viewTransformContainer = cameraPose.TryGetViewTransform(coordinateSystem);

Procesbewegingen en bewegingsinvoer

Starenen handinvoer zijn niet gebaseerd op tijd en hoeven niet te worden bijgewerkt in de steptimer-functie . Deze invoer is echter iets dat de app nodig heeft om elk frame te bekijken.

Updates op basis van tijd verwerken

Elke app voor realtime rendering moet op tijd gebaseerde updates verwerken. De Windows Holographic-appsjabloon maakt gebruik van een StepTimer-implementatie, vergelijkbaar met de StepTimer in de DirectX 11 UWP-app-sjabloon. Deze StepTimer-voorbeeldhulpklasse kan updates voor vaste tijdstappen en updates voor variabele tijdstappen bieden en de standaardmodus bestaat uit stappen voor variabele tijd.

Voor holografische rendering hebben we ervoor gekozen om niet te veel in de timerfunctie te zetten, omdat u deze kunt configureren als een stap voor een vaste tijd. Het kan meer dan één keer per frame worden aangeroepen , of helemaal niet, voor sommige frames, en onze holografische gegevensupdates moeten één keer per frame plaatsvinden.

Vanuit AppMain::Update:

m_timer.Tick([this]()
{
    m_spinningCubeRenderer->Update(m_timer);
});

Hologrammen in uw coördinatensysteem positioneren en draaien

Als u in één coördinaatsysteem werkt, zoals de sjabloon doet met het SpatialStationaryReferenceFrame, verschilt dit proces niet van wat u anders gewend bent in 3D-afbeeldingen. Hier draaien we de kubus en stellen we de modelmatrix in op basis van de positie in het stationaire coördinaatsysteem.

Van SpinningCubeRenderer::Update:

// Rotate the cube.
// Convert degrees to radians, then convert seconds to rotation angle.
const float    radiansPerSecond = XMConvertToRadians(m_degreesPerSecond);
const double   totalRotation = timer.GetTotalSeconds() * radiansPerSecond;
const float    radians = static_cast<float>(fmod(totalRotation, XM_2PI));
const XMMATRIX modelRotation = XMMatrixRotationY(-radians);

// Position the cube.
const XMMATRIX modelTranslation = XMMatrixTranslationFromVector(XMLoadFloat3(&m_position));

// Multiply to get the transform matrix.
// Note that this transform does not enforce a particular coordinate system. The calling
// class is responsible for rendering this content in a consistent manner.
const XMMATRIX modelTransform = XMMatrixMultiply(modelRotation, modelTranslation);

// The view and projection matrices are provided by the system; they are associated
// with holographic cameras, and updated on a per-camera basis.
// Here, we provide the model transform for the sample hologram. The model transform
// matrix is transposed to prepare it for the shader.
XMStoreFloat4x4(&m_modelConstantBufferData.model, XMMatrixTranspose(modelTransform));

Opmerking over geavanceerde scenario's: De draaiende kubus is een eenvoudig voorbeeld van het plaatsen van een hologram binnen één referentieframe. Het is ook mogelijk om tegelijkertijd meerdere SpatialCoordinateSystems in hetzelfde gerenderde frame te gebruiken.

Constante buffergegevens bijwerken

Modeltransformen voor inhoud worden op de gebruikelijke manier bijgewerkt. U hebt nu geldige transformaties berekend voor het coördinaatsysteem waarin u wilt weergeven.

Van SpinningCubeRenderer::Update:

// Update the model transform buffer for the hologram.
context->UpdateSubresource(
    m_modelConstantBuffer.Get(),
    0,
    nullptr,
    &m_modelConstantBufferData,
    0,
    0
);

Hoe zit het met weergave- en projectietransformen? Voor de beste resultaten willen we wachten tot we bijna klaar zijn voor onze draw-aanroepen voordat we deze krijgen.

Het huidige frame renderen

Rendering op Windows Mixed Reality verschilt niet veel van rendering op een 2D mono-weergave, maar er zijn enkele verschillen:

  • Holographic frame-voorspellingen zijn belangrijk. Hoe dichter de voorspelling bij het weergegeven frame ligt, hoe beter uw hologrammen eruit komen te zien.
  • Windows Mixed Reality de cameraweergaven. Geef elk frame weer omdat het holografische frame ze later voor u zal presenteren.
  • We raden u aan om stereo rendering uit te geven met behulp van een exemplaartekening naar een renderdoel array. De sjabloon voor een holografische app maakt gebruik van de aanbevolen methode voor het tekenen van exemplaren naar een doel matrix voor renderen, die gebruikmaakt van een weergavedoelweergave op een Texture2DArray.
  • Als u wilt renderen zonder stereo-instancing te gebruiken, moet u twee niet-matrix RenderTargetViews maken, één voor elk oog. Elke RenderTargetViews verwijst naar een van de twee segmenten in de Texture2DArray die vanuit het systeem aan de app zijn verstrekt. Dit wordt niet aanbevolen, omdat het meestal langzamer is dan het gebruik van instancing.

Een bijgewerkte HolographicFrame-voorspelling krijgen

Het bijwerken van de framevoorspelling verbetert de effectiviteit van de afbeeldingstabilisatie. U krijgt een nauwkeurigere positie van hologrammen vanwege de kortere tijd tussen de voorspelling en wanneer het frame zichtbaar is voor de gebruiker. Werk uw framevoorspelling idealiter bij vlak voordat deze wordt weergeven.

holographicFrame.UpdateCurrentPrediction();
HolographicFramePrediction prediction = holographicFrame.CurrentPrediction();

Renderen naar elke camera

Loop de set camera's in de voorspelling en worden weergegeven voor elke camera in deze set.

Uw rendering-pass instellen

Windows Mixed Reality maakt gebruik van stereoscopische rendering om de diepe weergave te verbeteren en stereoscopisch weer te geven, zodat zowel de linker- als de rechterweergave actief zijn. Met stereoscopische rendering is er een verschuiving tussen de twee weergaven, die het brein kan afstemmen als werkelijke diepte. Deze sectie gaat over stereoscopische rendering met behulp van instancing, met behulp van code uit de Windows Holographic-app-sjabloon.

Elke camera heeft een eigen renderdoel (backbuffer) en weergave- en projectie-matrices, in de holografische ruimte. Uw app moet alle andere op camera's gebaseerde resources, zoals de dieptebuffer, per camera maken. In de Windows Holographic-app-sjabloon bieden we een helperklasse om deze resources samen te bundelen in DX::CameraResources. Begin met het instellen van de weergavedoelweergaven:

Vanuit AppMain::Render:

// This represents the device-based resources for a HolographicCamera.
DX::CameraResources* pCameraResources = cameraResourceMap[cameraPose.HolographicCamera().Id()].get();

// Get the device context.
const auto context = m_deviceResources->GetD3DDeviceContext();
const auto depthStencilView = pCameraResources->GetDepthStencilView();

// Set render targets to the current holographic camera.
ID3D11RenderTargetView *const targets[1] =
    { pCameraResources->GetBackBufferRenderTargetView() };
context->OMSetRenderTargets(1, targets, depthStencilView);

// Clear the back buffer and depth stencil view.
if (m_canGetHolographicDisplayForCamera &&
    cameraPose.HolographicCamera().Display().IsOpaque())
{
    context->ClearRenderTargetView(targets[0], DirectX::Colors::CornflowerBlue);
}
else
{
    context->ClearRenderTargetView(targets[0], DirectX::Colors::Transparent);
}
context->ClearDepthStencilView(
    depthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0);

Gebruik de voorspelling om de weergave- en projectie-matrices voor de camera op te halen

De weergave- en projectie-matrices voor elke holografische camera veranderen met elk frame. Vernieuw de gegevens in de constante buffer voor elke holografische camera. Doe dit nadat u de voorspelling hebt bijgewerkt en voordat u tekenoproepen voor die camera maakt.

Vanuit AppMain::Render:

// The view and projection matrices for each holographic camera will change
// every frame. This function refreshes the data in the constant buffer for
// the holographic camera indicated by cameraPose.
if (m_stationaryReferenceFrame)
{
    pCameraResources->UpdateViewProjectionBuffer(
        m_deviceResources, cameraPose, m_stationaryReferenceFrame.CoordinateSystem());
}

// Attach the view/projection constant buffer for this camera to the graphics pipeline.
bool cameraActive = pCameraResources->AttachViewProjectionBuffer(m_deviceResources);

Hier laten we zien hoe de matrices worden verkregen uit de camerahouding. Tijdens dit proces verkrijgen we ook de huidige viewport voor de camera. Let op hoe we een coördinaatsysteem bieden: dit is hetzelfde coördinaatsysteem dat we hebben gebruikt om staren te begrijpen, en het is hetzelfde coördinaatsysteem dat we hebben gebruikt om de draaiende kubus te positioneren.

Vanuit CameraResources::UpdateViewProjectionBuffer:

// The system changes the viewport on a per-frame basis for system optimizations.
auto viewport = cameraPose.Viewport();
m_d3dViewport = CD3D11_VIEWPORT(
    viewport.X,
    viewport.Y,
    viewport.Width,
    viewport.Height
);

// The projection transform for each frame is provided by the HolographicCameraPose.
HolographicStereoTransform cameraProjectionTransform = cameraPose.ProjectionTransform();

// Get a container object with the view and projection matrices for the given
// pose in the given coordinate system.
auto viewTransformContainer = cameraPose.TryGetViewTransform(coordinateSystem);

// If TryGetViewTransform returns a null pointer, that means the pose and coordinate
// system cannot be understood relative to one another; content cannot be rendered
// in this coordinate system for the duration of the current frame.
// This usually means that positional tracking is not active for the current frame, in
// which case it is possible to use a SpatialLocatorAttachedFrameOfReference to render
// content that is not world-locked instead.
DX::ViewProjectionConstantBuffer viewProjectionConstantBufferData;
bool viewTransformAcquired = viewTransformContainer != nullptr;
if (viewTransformAcquired)
{
    // Otherwise, the set of view transforms can be retrieved.
    HolographicStereoTransform viewCoordinateSystemTransform = viewTransformContainer.Value();

    // Update the view matrices. Holographic cameras (such as Microsoft HoloLens) are
    // constantly moving relative to the world. The view matrices need to be updated
    // every frame.
    XMStoreFloat4x4(
        &viewProjectionConstantBufferData.viewProjection[0],
        XMMatrixTranspose(XMLoadFloat4x4(&viewCoordinateSystemTransform.Left) *
            XMLoadFloat4x4(&cameraProjectionTransform.Left))
    );
    XMStoreFloat4x4(
        &viewProjectionConstantBufferData.viewProjection[1],
        XMMatrixTranspose(XMLoadFloat4x4(&viewCoordinateSystemTransform.Right) *
            XMLoadFloat4x4(&cameraProjectionTransform.Right))
    );
}

De viewport moet elk frame worden ingesteld. Uw hoekpunt-shader (ten minste) heeft doorgaans toegang nodig tot de weergave-/projectiegegevens.

Vanuit CameraResources::AttachViewProjectionBuffer:

// Set the viewport for this camera.
context->RSSetViewports(1, &m_d3dViewport);

// Send the constant buffer to the vertex shader.
context->VSSetConstantBuffers(
    1,
    1,
    m_viewProjectionConstantBuffer.GetAddressOf()
);

Render naar de backbuffer van de camera en geef de dieptebuffer door:

Het is een goed idee om te controleren of TryGetViewTransform is geslaagd voordat u de weergave-/projectiegegevens probeert te gebruiken. Als het coördinatensysteem niet kan worden lokaliseren (bijvoorbeeld als tracering is onderbroken), kan uw app deze niet weergeven voor dat frame. De sjabloon roept Alleen Render aan op de draaiende kubus als de klasse CameraResources aangeeft dat de update is geslaagd.

Windows Mixed Reality functies voor afbeeldingstabilisatie om hologrammen te houden die zijn geplaatst op de plek waar een ontwikkelaar of gebruiker ze in de wereld plaatst. Met afbeeldingstabilisatie verbergt u de latentie die inherent is aan een renderingpijplijn om de beste holografische ervaringen voor gebruikers te garanderen. Er kan een focuspunt worden opgegeven om de beeldstabilisatie nog verder te verbeteren, of er kan een dieptebuffer worden opgegeven om geoptimaliseerde afbeeldingstabilisatie in realtime te berekenen.

Voor de beste resultaten moet uw app een dieptebuffer bieden met behulp van de CommitDirect3D11DepthBuffer-API . Windows Mixed Reality kunt vervolgens geometriegegevens uit de dieptebuffer gebruiken om de beeldstabilisatie in realtime te optimaliseren. De Windows Holographic-app-sjabloon legt standaard de dieptebuffer van de app vast, waardoor de stabiliteit van hologrammen wordt geoptimaliseerd.

Vanuit AppMain::Render:

// Only render world-locked content when positional tracking is active.
if (cameraActive)
{
    // Draw the sample hologram.
    m_spinningCubeRenderer->Render();
    if (m_canCommitDirect3D11DepthBuffer)
    {
        // On versions of the platform that support the CommitDirect3D11DepthBuffer API, we can 
        // provide the depth buffer to the system, and it will use depth information to stabilize 
        // the image at a per-pixel level.
        HolographicCameraRenderingParameters renderingParameters =
            holographicFrame.GetRenderingParameters(cameraPose);
        
        IDirect3DSurface interopSurface =
            DX::CreateDepthTextureInteropObject(pCameraResources->GetDepthStencilTexture2D());

        // Calling CommitDirect3D11DepthBuffer causes the system to queue Direct3D commands to 
        // read the depth buffer. It will then use that information to stabilize the image as
        // the HolographicFrame is presented.
        renderingParameters.CommitDirect3D11DepthBuffer(interopSurface);
    }
}

Notitie

Windows uw diepte-patroon op de GPU verwerkt, moet het dus mogelijk zijn om uw dieptebuffer te gebruiken als een shader-resource. De ID3D11Texture2D die u maakt, moet een typeloze indeling hebben en moet worden gebonden als een shader-resourceweergave. Hier ziet u een voorbeeld van het maken van een dieptestructuur die kan worden vastgelegd voor afbeeldingstabilisatie.

Code voor het maken van dieptebufferresources voor CommitDirect3D11DepthBuffer:

// Create a depth stencil view for use with 3D rendering if needed.
CD3D11_TEXTURE2D_DESC depthStencilDesc(
    DXGI_FORMAT_R16_TYPELESS,
    static_cast<UINT>(m_d3dRenderTargetSize.Width),
    static_cast<UINT>(m_d3dRenderTargetSize.Height),
    m_isStereo ? 2 : 1, // Create two textures when rendering in stereo.
    1, // Use a single mipmap level.
    D3D11_BIND_DEPTH_STENCIL | D3D11_BIND_SHADER_RESOURCE
);

winrt::check_hresult(
    device->CreateTexture2D(
        &depthStencilDesc,
        nullptr,
        &m_d3dDepthStencil
    ));

CD3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc(
    m_isStereo ? D3D11_DSV_DIMENSION_TEXTURE2DARRAY : D3D11_DSV_DIMENSION_TEXTURE2D,
    DXGI_FORMAT_D16_UNORM
);
winrt::check_hresult(
    device->CreateDepthStencilView(
        m_d3dDepthStencil.Get(),
        &depthStencilViewDesc,
        &m_d3dDepthStencilView
    ));

Holografische inhoud tekenen

Met Windows Holographic-app-sjabloon wordt inhoud in stereo weergegeven met behulp van de aanbevolen techniek voor het tekenen van instantiegeometrie naar een Texture2DArray van grootte 2. Laten we eens kijken naar het instancing-gedeelte van dit onderdeel en hoe het werkt op Windows Mixed Reality.

Vanuit SpinningCubeRenderer::Render:

// Draw the objects.
context->DrawIndexedInstanced(
    m_indexCount,   // Index count per instance.
    2,              // Instance count.
    0,              // Start index location.
    0,              // Base vertex location.
    0               // Start instance location.
);

Elk exemplaar heeft toegang tot een andere weergave-/projectiematrix vanuit de constante buffer. Hier is de constante bufferstructuur, die slechts een matrix van twee matrices is.

Van VertexShaderShared.hlsl, opgenomen door VPRTVertexShader.hlsl:

// A constant buffer that stores each set of view and projection matrices in column-major format.
cbuffer ViewProjectionConstantBuffer : register(b1)
{
    float4x4 viewProjection[2];
};

De index van de matrix met het renderdoel moet worden ingesteld voor elke pixel. In het volgende codefragment wordt output.viewId aan de semantische SV_RenderTargetArrayIndex waarde. Hiervoor is ondersteuning vereist voor een optionele Direct3D 11.3-functie, waarmee de semantiek van de renderdoelmantrix kan worden ingesteld vanuit elke shaderfase.

Vanuit VPRTVertexShader.hlsl:

// Per-vertex data passed to the geometry shader.
struct VertexShaderOutput
{
    min16float4 pos     : SV_POSITION;
    min16float3 color   : COLOR0;

    // The render target array index is set here in the vertex shader.
    uint        viewId  : SV_RenderTargetArrayIndex;
};

Van VertexShaderShared.hlsl, opgenomen door VPRTVertexShader.hlsl:

// Per-vertex data used as input to the vertex shader.
struct VertexShaderInput
{
    min16float3 pos     : POSITION;
    min16float3 color   : COLOR0;
    uint        instId  : SV_InstanceID;
};

// Simple shader to do vertex processing on the GPU.
VertexShaderOutput main(VertexShaderInput input)
{
    VertexShaderOutput output;
    float4 pos = float4(input.pos, 1.0f);

    // Note which view this vertex has been sent to. Used for matrix lookup.
    // Taking the modulo of the instance ID allows geometry instancing to be used
    // along with stereo instanced drawing; in that case, two copies of each 
    // instance would be drawn, one for left and one for right.
    int idx = input.instId % 2;

    // Transform the vertex position into world space.
    pos = mul(pos, model);

    // Correct for perspective and project the vertex position onto the screen.
    pos = mul(pos, viewProjection[idx]);
    output.pos = (min16float4)pos;

    // Pass the color through without modification.
    output.color = input.color;

    // Set the render target array index.
    output.viewId = idx;

    return output;
}

Als u uw bestaande exemplaartekeningtechnieken wilt gebruiken met deze methode van tekenen naar een stereo render-doel matrix, tekent u twee keer zoveel instanties als normaal gesproken. Deel in de shader input.instId door 2 om de oorspronkelijke exemplaar-id op te halen, die kan worden geïndexeerd in (bijvoorbeeld) een buffer van gegevens per object: int actualIdx = input.instId / 2;

Belangrijke opmerking over het weergeven van stereoinhoud op HoloLens

Windows Mixed Reality ondersteunt de mogelijkheid om de index van de matrix met het renderdoel in te stellen vanuit een shaderfase. Normaal gesproken is dit een taak die alleen kan worden uitgevoerd in de shaderfase van de geometrie vanwege de manier waarop de semantiek is gedefinieerd voor Direct3D 11. Hier laten we een volledig voorbeeld zien van het instellen van een renderingpijplijn met alleen de fasen hoekpunt en pixel-shader ingesteld. De shader-code is zoals hierboven beschreven.

Vanuit SpinningCubeRenderer::Render:

const auto context = m_deviceResources->GetD3DDeviceContext();

// Each vertex is one instance of the VertexPositionColor struct.
const UINT stride = sizeof(VertexPositionColor);
const UINT offset = 0;
context->IASetVertexBuffers(
    0,
    1,
    m_vertexBuffer.GetAddressOf(),
    &stride,
    &offset
);
context->IASetIndexBuffer(
    m_indexBuffer.Get(),
    DXGI_FORMAT_R16_UINT, // Each index is one 16-bit unsigned integer (short).
    0
);
context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
context->IASetInputLayout(m_inputLayout.Get());

// Attach the vertex shader.
context->VSSetShader(
    m_vertexShader.Get(),
    nullptr,
    0
);
// Apply the model constant buffer to the vertex shader.
context->VSSetConstantBuffers(
    0,
    1,
    m_modelConstantBuffer.GetAddressOf()
);

// Attach the pixel shader.
context->PSSetShader(
    m_pixelShader.Get(),
    nullptr,
    0
);

// Draw the objects.
context->DrawIndexedInstanced(
    m_indexCount,   // Index count per instance.
    2,              // Instance count.
    0,              // Start index location.
    0,              // Base vertex location.
    0               // Start instance location.
);

Belangrijke opmerking over rendering op niet-HoloLens apparaten

Als u de index van de matrix met het renderdoel in de hoekpunt-shader instelt, moet het grafische stuurprogramma een optionele Direct3D 11.3-functie ondersteunen, die HoloLens ondersteunt. Uw app kan alleen die techniek voor rendering veilig implementeren en aan alle vereisten wordt voldaan voor uitvoering op de Microsoft HoloLens.

Het kan ook zijn dat u de HoloLens-emulator wilt gebruiken. Dit kan een krachtig ontwikkelprogramma zijn voor uw holografische app en ondersteuning bieden voor Windows Mixed Reality immersive headset-apparaten die zijn gekoppeld aan Windows 10-pc's. Ondersteuning voor het niet-HoloLens renderingpad ( voor alle Windows Mixed Reality) is ook ingebouwd in Windows Holographic-app-sjabloon. In de sjablooncode vindt u code om ervoor te zorgen dat uw holografische app kan worden uitgevoerd op de GPU op uw ontwikkel-pc. Zo controleert de klasse DeviceResources op deze optionele functieondersteuning.

Vanuit DeviceResources::CreateDeviceResources:

// Check for device support for the optional feature that allows setting the render target array index from the vertex shader stage.
D3D11_FEATURE_DATA_D3D11_OPTIONS3 options;
m_d3dDevice->CheckFeatureSupport(D3D11_FEATURE_D3D11_OPTIONS3, &options, sizeof(options));
if (options.VPAndRTArrayIndexFromAnyShaderFeedingRasterizer)
{
    m_supportsVprt = true;
}

Als u rendering wilt ondersteunen zonder deze optionele functie, moet uw app een geometrie-shader gebruiken om de matrixindex voor het renderdoel in te stellen. Dit fragment wordt toegevoegd naVSSetConstantBuffers en beforePSSetShader in het codevoorbeeld in de vorige sectie waarin wordt uitgelegd hoe stereo op uw HoloLens.

Vanuit SpinningCubeRenderer::Render:

if (!m_usingVprtShaders)
{
    // On devices that do not support the D3D11_FEATURE_D3D11_OPTIONS3::
    // VPAndRTArrayIndexFromAnyShaderFeedingRasterizer optional feature,
    // a pass-through geometry shader is used to set the render target 
    // array index.
    context->GSSetShader(
        m_geometryShader.Get(),
        nullptr,
        0
    );
}

HLSL OPMERKING: In dit geval moet u ook een enigszins gewijzigde hoekpunt-shader laden die de index van de doel matrix render door geeft aan de geometrie-shader met behulp van een altijd toegestane shader-semantiek, zoals TEXCOORD0. De geometrie-shader hoeft geen werk te doen; De shader voor de sjabloongeometrie doorstaat alle gegevens, met uitzondering van de index van de doelmantrix voor renderen, die wordt gebruikt om de semantische SV_RenderTargetArrayIndex instellen.

App-sjablooncode voor GeometryShader.hlsl:

// Per-vertex data from the vertex shader.
struct GeometryShaderInput
{
    min16float4 pos     : SV_POSITION;
    min16float3 color   : COLOR0;
    uint instId         : TEXCOORD0;
};

// Per-vertex data passed to the rasterizer.
struct GeometryShaderOutput
{
    min16float4 pos     : SV_POSITION;
    min16float3 color   : COLOR0;
    uint rtvId          : SV_RenderTargetArrayIndex;
};

// This geometry shader is a pass-through that leaves the geometry unmodified 
// and sets the render target array index.
[maxvertexcount(3)]
void main(triangle GeometryShaderInput input[3], inout TriangleStream<GeometryShaderOutput> outStream)
{
    GeometryShaderOutput output;
    [unroll(3)]
    for (int i = 0; i < 3; ++i)
    {
        output.pos   = input[i].pos;
        output.color = input[i].color;
        output.rtvId = input[i].instId;
        outStream.Append(output);
    }
}

Aanwezig

Schakel het holografische frame in om de wisselingsketen weer te geven

Met Windows Mixed Reality bepaalt het systeem de wisselingsketen. Het systeem beheert vervolgens het presenteren van frames aan elke holografische camera om een gebruikerservaring van hoge kwaliteit te garanderen. Het biedt ook een viewport-update voor elk frame, voor elke camera, om aspecten van het systeem te optimaliseren, zoals afbeeldingstabilisatie of Mixed Reality Capture. Een holografische app die DirectX gebruikt, roept present dus niet aan in een DXGI-wisselingsketen. In plaats daarvan gebruikt u de HolographicFrame-klasse om alle swapchains voor een frame weer te geven wanneer u klaar bent met het tekenen ervan.

Vanuit DeviceResources::P resent:

HolographicFramePresentResult presentResult = frame.PresentUsingCurrentPrediction();

Deze API wacht standaard tot het frame is gemaakt voordat het wordt weergegeven. Holographic-apps moeten wachten tot het vorige frame is afgelopen voordat er aan een nieuw frame wordt gewerkt, omdat dit de latentie vermindert en betere resultaten van voorspellingen van holografische frames mogelijk maakt. Dit is geen harde regel. Als u frames hebt die langer duren dan één schermvernieuwing om weer te geven, kunt u dit wachten uitschakelen door de parameter HolographicFramePresentWaitBehavior door te geven aan PresentUsingCurrentPrediction. In dit geval gebruikt u waarschijnlijk een asynchrone renderingthread om een continue belasting van de GPU te onderhouden. De vernieuwingssnelheid van HoloLens apparaat is 60 hz, waarbij één frame een duur heeft van ongeveer 16 ms. In immersieve headsetapparaten kunnen variëren van 60 hz tot 90 hz; bij het vernieuwen van de weergave op 90 hz heeft elk frame een duur van ongeveer 11 ms.

DeviceLost-scenario's verwerken in samenwerking met het HolographicFrame

DirectX 11-apps willen doorgaans de HRESULT controleren die wordt geretourneerd door de functie Present van de DXGI-swapketen om erachter te komen of er een DeviceLost-fout is opgetreden. De HolographicFrame-klasse verwerkt dit voor u. Inspecteer het geretourneerde HolographicFramePresentResult om erachter te komen of u de Direct3D-apparaat- en apparaatbronnen moet vrijgeven en opnieuw moet maken.

// The PresentUsingCurrentPrediction API will detect when the graphics device
// changes or becomes invalid. When this happens, it is considered a Direct3D
// device lost scenario.
if (presentResult == HolographicFramePresentResult::DeviceRemoved)
{
    // The Direct3D device, context, and resources should be recreated.
    HandleDeviceLost();
}

Als het Direct3D-apparaat verloren is gegaan en u het opnieuw hebt gemaakt, moet u de HolographicSpace vertellen dat het nieuwe apparaat moet worden gebruikt. De wisselketen wordt opnieuw gemaakt voor dit apparaat.

Van DeviceResources::InitializeUsingHydrographicSpace:

m_holographicSpace.SetDirect3D11Device(m_d3dInteropDevice);

Zodra uw frame wordt weergegeven, kunt u terugkeren naar de hoofdprogrammalus en doorgaan naar het volgende frame.

Hybride grafische pc's en mixed reality toepassingen

Windows 10-makersupdate pc's kunnen worden geconfigureerd met zowel discrete als geïntegreerde GPU's. Met deze typen computers kiest Windows de adapter waarop de headset is aangesloten. Toepassingen moeten ervoor zorgen dat het DirectX-apparaat dat wordt gemaakt, dezelfde adapter gebruikt.

De meeste algemene Direct3D-voorbeeldcode laat zien hoe u een DirectX-apparaat maakt met behulp van de standaardhardwareadapter, wat op een hybride systeem mogelijk niet hetzelfde is als het apparaat dat voor de headset wordt gebruikt.

Als u eventuele problemen wilt oplossen, gebruikt u de HolographicAdapterID van een van beide HolographicSpaces. PrimaryAdapterId() of HolographicDisplay. AdapterId(). Deze adapterId kan vervolgens worden gebruikt om de juiste DXGIAdapter te selecteren met behulp van IDXGIFactory4.EnumAdapterByLuid.

Van DeviceResources::InitializeUsingHydrographicSpace:

// The holographic space might need to determine which adapter supports
// holograms, in which case it will specify a non-zero PrimaryAdapterId.
LUID id =
{
    m_holographicSpace.PrimaryAdapterId().LowPart,
    m_holographicSpace.PrimaryAdapterId().HighPart
};

// When a primary adapter ID is given to the app, the app should find
// the corresponding DXGI adapter and use it to create Direct3D devices
// and device contexts. Otherwise, there is no restriction on the DXGI
// adapter the app can use.
if ((id.HighPart != 0) || (id.LowPart != 0))
{
    UINT createFlags = 0;

    // Create the DXGI factory.
    ComPtr<IDXGIFactory1> dxgiFactory;
    winrt::check_hresult(
        CreateDXGIFactory2(
            createFlags,
            IID_PPV_ARGS(&dxgiFactory)
        ));
    ComPtr<IDXGIFactory4> dxgiFactory4;
    winrt::check_hresult(dxgiFactory.As(&dxgiFactory4));

    // Retrieve the adapter specified by the holographic space.
    winrt::check_hresult(
        dxgiFactory4->EnumAdapterByLuid(
            id,
            IID_PPV_ARGS(&m_dxgiAdapter)
        ));
}
else
{
    m_dxgiAdapter.Reset();
}

Code voor het bijwerken van DeviceResources::CreateDeviceResources om IDXGIAdapter te gebruiken

// Create the Direct3D 11 API device object and a corresponding context.
ComPtr<ID3D11Device> device;
ComPtr<ID3D11DeviceContext> context;

const D3D_DRIVER_TYPE driverType = m_dxgiAdapter == nullptr ? D3D_DRIVER_TYPE_HARDWARE : D3D_DRIVER_TYPE_UNKNOWN;
const HRESULT hr = D3D11CreateDevice(
    m_dxgiAdapter.Get(),        // Either nullptr, or the primary adapter determined by Windows Holographic.
    driverType,                 // Create a device using the hardware graphics driver.
    0,                          // Should be 0 unless the driver is D3D_DRIVER_TYPE_SOFTWARE.
    creationFlags,              // Set debug and Direct2D compatibility flags.
    featureLevels,              // List of feature levels this app can support.
    ARRAYSIZE(featureLevels),   // Size of the list above.
    D3D11_SDK_VERSION,          // Always set this to D3D11_SDK_VERSION for Windows Runtime apps.
    &device,                    // Returns the Direct3D device created.
    &m_d3dFeatureLevel,         // Returns feature level of device created.
    &context                    // Returns the device immediate context.
);

Hybride afbeeldingen en Media Foundation

Het Media Foundation hybride systemen kan problemen veroorzaken waarbij video's niet worden weergegeven of het patroon van video's beschadigd is omdat Media Foundation standaard een systeemgedrag heeft. In sommige scenario's is het maken van een afzonderlijke ID3D11Device vereist ter ondersteuning van meerdere threading en worden de juiste markeringen voor het maken ingesteld.

Bij het initialiseren van de ID3D11Device moet D3D11_CREATE_DEVICE_VIDEO_SUPPORT vlag worden gedefinieerd als onderdeel van de D3D11_CREATE_DEVICE_FLAG. Zodra het apparaat en de context zijn gemaakt, roept u SetMultithreadProtected aan om multithreading in teschakelen. Als u het apparaat wilt koppelen aan de DEVICEDXGIDeviceManager, gebruikt u de functie ZIJDXGIDeviceManager::ResetDevice .

Code voor het koppelen van een ID3D11Device aan DEVICDXGIDeviceManager:

// create dx device for media pipeline
winrt::com_ptr<ID3D11Device> spMediaDevice;

// See above. Also make sure to enable the following flags on the D3D11 device:
//   * D3D11_CREATE_DEVICE_VIDEO_SUPPORT
//   * D3D11_CREATE_DEVICE_BGRA_SUPPORT
if (FAILED(CreateMediaDevice(spAdapter.get(), &spMediaDevice)))
    return;                                                     

// Turn multithreading on 
winrt::com_ptr<ID3D10Multithread> spMultithread;
if (spContext.try_as(spMultithread))
{
    spMultithread->SetMultithreadProtected(TRUE);
}

// lock the shared dxgi device manager
// call MFUnlockDXGIDeviceManager when no longer needed
UINT uiResetToken;
winrt::com_ptr<IMFDXGIDeviceManager> spDeviceManager;
hr = MFLockDXGIDeviceManager(&uiResetToken, spDeviceManager.put());
if (FAILED(hr))
    return hr;
    
// associate the device with the manager
hr = spDeviceManager->ResetDevice(spMediaDevice.get(), uiResetToken);
if (FAILED(hr))
    return hr;

Zie ook