Method Frame

Dependencies/xr/Source/OpenXR/XR.cpp:564–735

    };

    System::Session::Frame::Frame(Session::Impl& sessionImpl)
        : Views{ sessionImpl.RenderResources.ActiveFrameViews }
        , InputSources{ sessionImpl.ActionResources.ActiveInputSources }
        , m_impl{ std::make_unique<System::Session::Frame::Impl>(sessionImpl) }
    {
        auto session = m_impl->sessionImpl.Session;

        XrFrameWaitInfo frameWaitInfo{ XR_TYPE_FRAME_WAIT_INFO };
        XrFrameState frameState{ XR_TYPE_FRAME_STATE };
        XrCheck(xrWaitFrame(session, &frameWaitInfo, &frameState));
        m_impl->shouldRender = frameState.shouldRender;
        m_impl->displayTime = frameState.predictedDisplayTime;

        XrFrameBeginInfo frameBeginInfo{ XR_TYPE_FRAME_BEGIN_INFO };
        XrCheck(xrBeginFrame(session, &frameBeginInfo));

        auto& renderResources = m_impl->sessionImpl.RenderResources;

        // Only render when session is visible. otherwise submit zero layers
        if (m_impl->shouldRender)
        {
            uint32_t viewCapacityInput = static_cast<uint32_t>(renderResources.Views.size());
            uint32_t viewCountOutput;
        
            XrViewState viewState{ XR_TYPE_VIEW_STATE };
            XrViewLocateInfo viewLocateInfo{ XR_TYPE_VIEW_LOCATE_INFO };
            viewLocateInfo.viewConfigurationType = System::Impl::VIEW_CONFIGURATION_TYPE;
            viewLocateInfo.displayTime = m_impl->displayTime;
            viewLocateInfo.space = m_impl->sessionImpl.SceneSpace;
            XrCheck(xrLocateViews(session, &viewLocateInfo, &viewState, viewCapacityInput, &viewCountOutput, renderResources.Views.data()));
            assert(viewCountOutput == viewCapacityInput);
            assert(viewCountOutput == renderResources.ConfigViews.size());
            assert(viewCountOutput == renderResources.ColorSwapchains.size());
            assert(viewCountOutput == renderResources.DepthSwapchains.size());
        
            renderResources.ProjectionLayerViews.resize(viewCountOutput);
            if (m_impl->sessionImpl.HmdImpl.Extensions->DepthExtensionSupported)
            {
                renderResources.DepthInfoViews.resize(viewCountOutput);
            }

            Views.resize(viewCountOutput);
        
            // Prepare rendering parameters of each view for swapchain texture arrays
            for (uint32_t idx = 0; idx < viewCountOutput; ++idx)
            {
                const auto& colorSwapchain = renderResources.ColorSwapchains[idx];
                const auto& depthSwapchain = renderResources.DepthSwapchains[idx];

                // Use the full range of recommended image size to achieve optimum resolution
                const XrRect2Di imageRect = { {0, 0}, { colorSwapchain.Width, colorSwapchain.Height } };
                assert(colorSwapchain.Width == depthSwapchain.Width);
                assert(colorSwapchain.Height == depthSwapchain.Height);

                const uint32_t colorSwapchainImageIndex = AquireAndWaitForSwapchainImage(colorSwapchain.Handle);
                const uint32_t depthSwapchainImageIndex = AquireAndWaitForSwapchainImage(depthSwapchain.Handle);

                // Populate the struct that consuming code will use for rendering.