DWORD __stdcall RetrieveImageEvent( VOID* Parameter ) { OVERLAPPED ov = { 0 }; //BOOLEAN bReturnCode = FALSE; UINT32 iBytesReturned; IMAGE_CALLBACK_INFO imageInfo; // Create an event handle for async notification from the driver NtCreateEvent(&ov.hEvent, EVENT_ALL_ACCESS, NULL, NotificationEvent, FALSE); // Get the process info PushGetImageInfo(&imageInfo); Log(L"%i loaded D3D module", imageInfo.processID); // // Wait here for the event handle to be set, indicating // that the IOCTL processing is completed. // GetOverlappedResult( R0DriverHandle, &ov, &iBytesReturned, TRUE ); CreateOverlay(imageInfo.processID); NtClose(ov.hEvent); return 0; }
VOID ProcessEnum( SYSTEM_PROCESS_INFORMATION* ProcessInformation ) { GAME_LIST gameList; PUSH_GAME* game; UINT8 i; i = 0; gameList = Game_GetGames(); while (gameList != NULL) { game = gameList->Game; if (ProcessInformation->ImageName.Length && String_CompareN( game->ExecutableName, ProcessInformation->ImageName.Buffer, ProcessInformation->ImageName.Length) == 0) { CreateOverlay((DWORD)ProcessInformation->UniqueProcessId); } gameList = gameList->NextEntry; i++; } }
const Entity EntityBuilder::CreateProgressBar(const XMFLOAT3 & position, const std::string & text, float fontSize, float textSize, const XMFLOAT4 & colorTex, const float min, const float max, const float start, float width, float height) { ProgressBar* b = nullptr; try { b = new ProgressBar(start, min, max, width, height); } catch (std::exception& e) { e; throw ErrorMsg(0, L"Failed to create progress bar."); } Entity ent = CreateLabel(position, text, fontSize, colorTex, textSize, height, ""); float l = width*((b->value - b->minV) / (b->maxV - b->minV)); Entity bar = CreateOverlay(XMFLOAT3(textSize, 0.0f, 0.0f), l, height, "Assets/Textures/default_color.png"); _transform->BindChild(ent, bar); _transform->SetPosition(ent, position); _animation->CreateAnimation(ent, "scale", 0.15f, [bar,b,this](float delta, float amount, float offset) { _overlay->SetExtents(bar, offset + amount, b->height); }); _controller->AddProgressBar(ent, b); return ent; }
void showMinSpecWarning() { auto vrSystem = acquireOpenVrSystem(); auto vrOverlay = vr::VROverlay(); if (!vrOverlay) { qFatal("Unable to initialize SteamVR overlay manager"); } vr::VROverlayHandle_t minSpecFailedOverlay = 0; if (vr::VROverlayError_None != vrOverlay->CreateOverlay(FAILED_MIN_SPEC_OVERLAY_NAME, FAILED_MIN_SPEC_OVERLAY_FRIENDLY_NAME, &minSpecFailedOverlay)) { qFatal("Unable to create overlay"); } // Needed here for PathUtils QCoreApplication miniApp(__argc, __argv); vrSystem->ResetSeatedZeroPose(); QString imagePath = PathUtils::resourcesPath() + "/images/steam-min-spec-failed.png"; vrOverlay->SetOverlayFromFile(minSpecFailedOverlay, imagePath.toLocal8Bit().toStdString().c_str()); vrOverlay->SetHighQualityOverlay(minSpecFailedOverlay); vrOverlay->SetOverlayWidthInMeters(minSpecFailedOverlay, 1.4f); vrOverlay->SetOverlayInputMethod(minSpecFailedOverlay, vr::VROverlayInputMethod_Mouse); vrOverlay->ShowOverlay(minSpecFailedOverlay); QTimer* timer = new QTimer(&miniApp); timer->setInterval(FAILED_MIN_SPEC_UPDATE_INTERVAL_MS); // Qt::CoarseTimer acceptable, we don't need this to be frame rate accurate QObject::connect(timer, &QTimer::timeout, [&] { vr::TrackedDevicePose_t vrPoses[vr::k_unMaxTrackedDeviceCount]; vrSystem->GetDeviceToAbsoluteTrackingPose(vr::TrackingUniverseSeated, 0, vrPoses, vr::k_unMaxTrackedDeviceCount); auto headPose = toGlm(vrPoses[vr::k_unTrackedDeviceIndex_Hmd].mDeviceToAbsoluteTracking); auto overlayPose = toOpenVr(headPose * glm::translate(glm::mat4(), vec3(0, 0, -1))); vrOverlay->SetOverlayTransformAbsolute(minSpecFailedOverlay, vr::TrackingUniverseSeated, &overlayPose); vr::VREvent_t event; while (vrSystem->PollNextEvent(&event, sizeof(event))) { switch (event.eventType) { case vr::VREvent_Quit: vrSystem->AcknowledgeQuit_Exiting(); QCoreApplication::quit(); break; case vr::VREvent_ButtonPress: // Quit on any button press except for 'putting on the headset' if (event.data.controller.button != vr::k_EButton_ProximitySensor) { QCoreApplication::quit(); } break; default: break; } } }); timer->start(); QTimer::singleShot(FAILED_MIN_SPEC_AUTO_QUIT_INTERVAL_MS, &miniApp, &QCoreApplication::quit); miniApp.exec(); }
/* ==================== idRenderModelOverlay::CreateDeferredOverlays ==================== */ void idRenderModelOverlay::CreateDeferredOverlays( const idRenderModel* model ) { for( unsigned int i = firstDeferredOverlay; i < nextDeferredOverlay; i++ ) { const overlayProjectionParms_t& parms = deferredOverlays[i & ( MAX_DEFERRED_OVERLAYS - 1 )]; if( parms.startTime > tr.viewDef->renderView.time[0] - DEFFERED_OVERLAY_TIMEOUT ) { CreateOverlay( model, parms.localTextureAxis, parms.material ); } } firstDeferredOverlay = 0; nextDeferredOverlay = 0; }
vr::EVRCompositorError CompositorBase::SubmitFrame(ovrLayerHeader const * const * layerPtrList, unsigned int layerCount) { MICROPROFILE_SCOPE(SubmitFrame); // Other layers are interpreted as overlays. std::vector<vr::VROverlayHandle_t> activeOverlays; for (uint32_t i = 0; i < layerCount; i++) { if (layerPtrList[i] == nullptr) continue; if (layerPtrList[i]->Type == ovrLayerType_Quad) { ovrLayerQuad* layer = (ovrLayerQuad*)layerPtrList[i]; ovrTextureSwapChain chain = layer->ColorTexture; // Every overlay is associated with a swapchain. // This is necessary because the position of the layer may change in the array, // which would otherwise cause flickering between overlays. // TODO: Support multiple overlays using the same texture. vr::VROverlayHandle_t overlay = layer->ColorTexture->Overlay; if (overlay == vr::k_ulOverlayHandleInvalid) { overlay = CreateOverlay(); layer->ColorTexture->Overlay = overlay; } activeOverlays.push_back(overlay); // Set the layer rendering order. vr::VROverlay()->SetOverlaySortOrder(overlay, i); // Transform the overlay. vr::HmdMatrix34_t transform = REV::Matrix4f(layer->QuadPoseCenter); vr::VROverlay()->SetOverlayWidthInMeters(overlay, layer->QuadSize.x); if (layer->Header.Flags & ovrLayerFlag_HeadLocked) vr::VROverlay()->SetOverlayTransformTrackedDeviceRelative(overlay, vr::k_unTrackedDeviceIndex_Hmd, &transform); else vr::VROverlay()->SetOverlayTransformAbsolute(overlay, vr::VRCompositor()->GetTrackingSpace(), &transform); // Set the texture and show the overlay. vr::VRTextureBounds_t bounds = ViewportToTextureBounds(layer->Viewport, layer->ColorTexture, layer->Header.Flags); vr::Texture_t texture = chain->Textures[chain->SubmitIndex]->ToVRTexture(); vr::VROverlay()->SetOverlayTextureBounds(overlay, &bounds); vr::VROverlay()->SetOverlayTexture(overlay, &texture); chain->Submit(); // Show the overlay, unfortunately we have no control over the order in which // overlays are drawn. // TODO: Support ovrLayerFlag_HighQuality for overlays with anisotropic sampling. // TODO: Handle overlay errors. vr::VROverlay()->ShowOverlay(overlay); } else if (layerPtrList[i]->Type == ovrLayerType_EyeFov) { ovrLayerEyeFov* sceneLayer = (ovrLayerEyeFov*)layerPtrList[i]; if (!m_SceneLayer) m_SceneLayer = layerPtrList[i]; else SubmitFovLayer(sceneLayer->Viewport, sceneLayer->Fov, sceneLayer->ColorTexture, sceneLayer->Header.Flags); } else if (layerPtrList[i]->Type == ovrLayerType_EyeMatrix) { ovrLayerEyeMatrix* sceneLayer = (ovrLayerEyeMatrix*)layerPtrList[i]; ovrFovPort fov[ovrEye_Count] = { MatrixToFovPort(sceneLayer->Matrix[ovrEye_Left]), MatrixToFovPort(sceneLayer->Matrix[ovrEye_Right]) }; if (!m_SceneLayer) m_SceneLayer = layerPtrList[i]; else SubmitFovLayer(sceneLayer->Viewport, fov, sceneLayer->ColorTexture, sceneLayer->Header.Flags); } } // Hide previous overlays that are not part of the current layers. for (vr::VROverlayHandle_t overlay : m_ActiveOverlays) { // Find the overlay in the current active overlays, if it was not found then hide it. // TODO: Handle overlay errors. if (std::find(activeOverlays.begin(), activeOverlays.end(), overlay) == activeOverlays.end()) vr::VROverlay()->HideOverlay(overlay); } m_ActiveOverlays = activeOverlays; vr::EVRCompositorError error = vr::VRCompositorError_None; if (m_SceneLayer && m_SceneLayer->Type == ovrLayerType_EyeFov) { ovrLayerEyeFov* sceneLayer = (ovrLayerEyeFov*)m_SceneLayer; error = SubmitSceneLayer(sceneLayer->Viewport, sceneLayer->Fov, sceneLayer->ColorTexture, sceneLayer->Header.Flags); if (m_MirrorTexture && error == vr::VRCompositorError_None) RenderMirrorTexture(m_MirrorTexture, sceneLayer->ColorTexture); } else if (m_SceneLayer && m_SceneLayer->Type == ovrLayerType_EyeMatrix) { ovrLayerEyeMatrix* sceneLayer = (ovrLayerEyeMatrix*)m_SceneLayer; ovrFovPort fov[ovrEye_Count] = { MatrixToFovPort(sceneLayer->Matrix[ovrEye_Left]), MatrixToFovPort(sceneLayer->Matrix[ovrEye_Right]) }; error = SubmitSceneLayer(sceneLayer->Viewport, fov, sceneLayer->ColorTexture, sceneLayer->Header.Flags); if (m_MirrorTexture && error == vr::VRCompositorError_None) RenderMirrorTexture(m_MirrorTexture, sceneLayer->ColorTexture); } m_SceneLayer = nullptr; return error; }