Merge pull request #22934 from hrydgard/vr-vulkan

VR: OpenXR on Vulkan, with single-pass stereo (Quest)
This commit is contained in:
Henrik Rydgård authored and GitHub committed 2026-11-05 12:22:43 +01:00
commit 546e00c697
47 files changed
+1300 -131

No files matched your search

+2
View File
@@ -60,6 +60,8 @@ set(CommonVR
VR/VRMath.h
VR/VRRenderer.cpp
VR/VRRenderer.h
VR/VRVulkan.cpp
VR/VRVulkan.h
)
add_library(Common STATIC
+2
View File
@@ -593,6 +593,7 @@
<ClInclude Include="VR\VRInput.h" />
<ClInclude Include="VR\VRMath.h" />
<ClInclude Include="VR\VRRenderer.h" />
<ClInclude Include="VR\VRVulkan.h" />
<ClInclude Include="x64Analyzer.h" />
<ClInclude Include="x64Emitter.h" />
</ItemGroup>
@@ -1147,6 +1148,7 @@
<ClCompile Include="VR\VRInput.cpp" />
<ClCompile Include="VR\VRMath.cpp" />
<ClCompile Include="VR\VRRenderer.cpp" />
<ClCompile Include="VR\VRVulkan.cpp" />
<ClCompile Include="x64Analyzer.cpp" />
<ClCompile Include="x64Emitter.cpp" />
</ItemGroup>
+6
View File
@@ -424,6 +424,9 @@
<ClInclude Include="VR\VRRenderer.h">
<Filter>VR</Filter>
</ClInclude>
<ClInclude Include="VR\VRVulkan.h">
<Filter>VR</Filter>
</ClInclude>
<ClInclude Include="VR\OpenXRLoader.h">
<Filter>VR</Filter>
</ClInclude>
@@ -1221,6 +1224,9 @@
<ClCompile Include="VR\VRRenderer.cpp">
<Filter>VR</Filter>
</ClCompile>
<ClCompile Include="VR\VRVulkan.cpp">
<Filter>VR</Filter>
</ClCompile>
<ClCompile Include="VR\OpenXRLoader.cpp">
<Filter>VR</Filter>
</ClCompile>
+14
View File
@@ -214,6 +214,20 @@ VkResult VulkanContext::CreateInstance(const CreateInfo &info) {
extensionsLookup_.EXT_swapchain_colorspace = true;
}
// createInfo_ owns the strings.
for (const std::string &ext : createInfo_.extraInstanceExtensions) {
bool found = false;
for (const char *enabled : instance_extensions_enabled_) {
if (ext == enabled) {
found = true;
break;
}
}
if (!found) {
instance_extensions_enabled_.push_back(ext.c_str());
}
}
// Validate that all the instance extensions we ask for are actually available.
for (auto ext : instance_extensions_enabled_) {
if (!IsInstanceExtensionAvailable(ext)) {
+4
View File
@@ -185,6 +185,8 @@ public:
int app_ver;
VulkanInitFlags flags;
std::string customDriver;
// Required on top of our own, by OpenXR for example.
std::vector<std::string> extraInstanceExtensions;
};
VkResult CreateInstance(const CreateInfo &info);
@@ -428,6 +430,8 @@ public:
int GetBackbufferWidth() { return (int)(presentation_ ? presentation_->GetExtent().width : swapChainExtent_.width); }
int GetBackbufferHeight() { return (int)(presentation_ ? presentation_->GetExtent().height : swapChainExtent_.height); }
// More than one means a multiview (stereo) backbuffer pass.
int GetBackbufferLayers() const { return presentation_ ? (int)presentation_->GetImageLayers() : 1; }
void SetProfilerEnabledPtr(bool *enabled) {
for (auto &frame : frame_) {
+2 -1
View File
@@ -299,7 +299,8 @@ VkRenderPass CreateRenderPass(VulkanContext *vulkan, const RPKey &key, RenderPas
_dbg_assert_(key.stencilLoadAction != VKRRenderPassLoadAction::KEEP);
}
bool hasDepth = RenderPassTypeHasDepth(rpType);
bool multiview = RenderPassTypeHasMultiView(rpType);
// A layered backbuffer (VR) is drawn to with multiview, so every pipeline compiled for it matches.
bool multiview = RenderPassTypeHasMultiView(rpType) || (isBackbuffer && vulkan->GetBackbufferLayers() > 1);
bool multisample = RenderPassTypeHasMultisample(rpType);
_dbg_assert_(!(isBackbuffer && multisample));
+30 -4
View File
@@ -56,6 +56,8 @@
#include "Common/GPU/Vulkan/VulkanLoader.h"
#include "Common/GPU/Vulkan/VulkanContext.h"
#include "Common/GPU/Vulkan/VulkanPresentation.h"
#include "Common/VR/PPSSPPVR.h"
#include "Common/VR/VRVulkan.h"
#include "Common/GPU/thin3d.h"
#include "Common/GPU/thin3d_create.h"
@@ -183,8 +185,13 @@ bool VulkanGraphicsContext::InitAPI(void *wnd, std::string *deviceName, std::str
vulkan_ = new VulkanContext();
vr_ = offscreenWidth_ == 0 && IsVREnabled() && VR_VulkanSupported();
VulkanContext::CreateInfo info{};
InitVulkanCreateInfoFromConfig(&info);
if (vr_) {
info.extraInstanceExtensions = VR_GetVulkanInstanceExtensions();
}
if (VK_SUCCESS != vulkan_->CreateInstance(info)) {
*errorMessage = vulkan_->InitError();
delete vulkan_;
@@ -192,6 +199,13 @@ bool VulkanGraphicsContext::InitAPI(void *wnd, std::string *deviceName, std::str
return false;
}
int deviceNum = vulkan_->GetPhysicalDeviceByName(*deviceName);
if (vr_) {
// The runtime decides, it has to be the GPU the headset is on.
int xrDevice = VR_GetVulkanPhysicalDevice(vulkan_);
if (xrDevice >= 0) {
deviceNum = xrDevice;
}
}
if (deviceNum < 0) {
deviceNum = vulkan_->GetBestPhysicalDevice();
if (!deviceName->empty()) {
@@ -199,14 +213,15 @@ bool VulkanGraphicsContext::InitAPI(void *wnd, std::string *deviceName, std::str
}
}
if (vulkan_->CreateDevice(deviceNum) != VK_SUCCESS) {
static const std::vector<const char *> noExtensions;
if (vulkan_->CreateDevice(deviceNum, vr_ ? VR_GetVulkanDeviceExtensions() : noExtensions) != VK_SUCCESS) {
*errorMessage = vulkan_->InitError();
delete vulkan_;
vulkan_ = nullptr;
return false;
}
// Normally the queue is picked along with the surface, which must be able to present from it.
if (offscreenWidth_ > 0 && !vulkan_->ChooseGraphicsQueueWithoutSurface()) {
if ((offscreenWidth_ > 0 || vr_) && !vulkan_->ChooseGraphicsQueueWithoutSurface()) {
*errorMessage = "No graphics queue";
return false;
}
@@ -222,6 +237,13 @@ bool VulkanGraphicsContext::InitSurface(WindowSystem winsys, void *data1, void *
return false;
}
vulkan_->SetPresentation(std::move(presentation));
} else if (vr_) {
// The headset is the display. The window's surface isn't used.
std::unique_ptr<VulkanPresentation> presentation = VR_CreateVulkanPresentation(vulkan_, errorMessage);
if (!presentation) {
return false;
}
vulkan_->SetPresentation(std::move(presentation));
} else {
// Don't proceed on failure - without a surface there's no present mode, no swapchain and no queue,
// so everything below would just fail in more confusing ways further down (it used to assert deep
@@ -243,7 +265,7 @@ bool VulkanGraphicsContext::InitSurface(WindowSystem winsys, void *data1, void *
draw_ = Draw::T3DCreateVulkanContext(vulkan_, useMultiThreading);
if (offscreenWidth_ == 0) {
if (!vulkan_->GetPresentation()) {
VkPresentModeKHR presentMode = ConfigPresentModeToVulkan(draw_);
#ifdef VK_EXT_full_screen_exclusive
@@ -297,6 +319,10 @@ void VulkanGraphicsContext::ShutdownSurface() {
}
void VulkanGraphicsContext::ShutdownAPI() {
if (vr_) {
// The session goes before the device it was created with.
VR_DestroyVulkanSession();
}
vulkan_->DestroyDevice();
vulkan_->DestroyInstance();
@@ -308,7 +334,7 @@ void VulkanGraphicsContext::ShutdownAPI() {
}
void VulkanGraphicsContext::Resize() {
if (offscreenWidth_ > 0) {
if (offscreenWidth_ > 0 || vr_) {
// The images have a fixed size.
return;
}
@@ -55,4 +55,6 @@ private:
bool windowRestored_ = false;
int offscreenWidth_ = 0;
int offscreenHeight_ = 0;
// Presenting to an OpenXR swapchain instead of the window.
bool vr_ = false;
};
+4 -2
View File
@@ -29,6 +29,7 @@
#include "Common/StringUtils.h"
#include "Common/System/System.h"
#include "Common/VR/PPSSPPVR.h"
#include "Common/VR/VRVulkan.h"
#include "Common/File/FileUtil.h"
#if !PPSSPP_PLATFORM(WINDOWS) && !PPSSPP_PLATFORM(SWITCH)
@@ -451,8 +452,9 @@ bool VulkanMayBeAvailable() {
g_vulkanMayBeAvailable = true;
return true;
#else
// Unsupported in VR at the moment
if (IsVREnabled()) {
// VR needs a runtime that takes a Vulkan session. Not cached: the config is checked before OpenXR is
// up, when only the driver can say no, and app-android checks again after.
if (IsVREnabled() && VR_VulkanUnsupported()) {
return false;
}
+2
View File
@@ -40,6 +40,8 @@ public:
virtual VkImage GetImage(uint32_t index) const = 0;
virtual VkExtent2D GetExtent() const = 0;
virtual VkFormat GetFormat() const = 0;
// Array layers per image. Two makes the backbuffer pass multiview, one view per layer (VR).
virtual uint32_t GetImageLayers() const { return 1; }
// The layout backbuffer images should be left in after rendering, since there's no real presentation
// engine to hand them to via a VK_IMAGE_LAYOUT_PRESENT_SRC_KHR transition.
+14 -5
View File
@@ -6,6 +6,7 @@
#include "Common/GPU/Vulkan/VulkanRenderManager.h"
#include "Common/Log.h"
#include "Common/TimeUtil.h"
#include "Common/VR/PPSSPPVR.h"
using namespace PPSSPP_VK;
@@ -114,10 +115,10 @@ bool VulkanQueueRunner::InitBackbufferFramebuffers(int width, int height, FrameD
bool VulkanQueueRunner::InitDepthStencilBuffer(VkCommandBuffer cmd, VulkanBarrierBatch *barriers) {
depth_.format = vulkan_->GetDeviceInfo().preferredDepthStencilFormat;
return CreateDepthStencilImage(vulkan_->GetBackbufferWidth(), vulkan_->GetBackbufferHeight(), &depth_.image, &depth_.alloc, &depth_.view, barriers, "BackbufferDepth");
return CreateDepthStencilImage(vulkan_->GetBackbufferWidth(), vulkan_->GetBackbufferHeight(), vulkan_->GetBackbufferLayers(), &depth_.image, &depth_.alloc, &depth_.view, barriers, "BackbufferDepth");
}
bool VulkanQueueRunner::CreateDepthStencilImage(int width, int height, VkImage *image, VmaAllocation *alloc, VkImageView *view, VulkanBarrierBatch *barriers, const char *tag) {
bool VulkanQueueRunner::CreateDepthStencilImage(int width, int height, int layers, VkImage *image, VmaAllocation *alloc, VkImageView *view, VulkanBarrierBatch *barriers, const char *tag) {
const VkFormat depth_format = vulkan_->GetDeviceInfo().preferredDepthStencilFormat;
int aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
VkImageCreateInfo image_info = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
@@ -127,7 +128,7 @@ bool VulkanQueueRunner::CreateDepthStencilImage(int width, int height, VkImage *
image_info.extent.height = height;
image_info.extent.depth = 1;
image_info.mipLevels = 1;
image_info.arrayLayers = 1;
image_info.arrayLayers = layers;
image_info.samples = VK_SAMPLE_COUNT_1_BIT;
image_info.queueFamilyIndexCount = 0;
image_info.pQueueFamilyIndices = nullptr;
@@ -151,6 +152,7 @@ bool VulkanQueueRunner::CreateDepthStencilImage(int width, int height, VkImage *
VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, 0);
barrier->subresourceRange.aspectMask = aspectMask;
barrier->subresourceRange.layerCount = layers;
barrier->oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
barrier->newLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
barrier->srcAccessMask = 0;
@@ -169,8 +171,8 @@ bool VulkanQueueRunner::CreateDepthStencilImage(int width, int height, VkImage *
depth_view_info.subresourceRange.baseMipLevel = 0;
depth_view_info.subresourceRange.levelCount = 1;
depth_view_info.subresourceRange.baseArrayLayer = 0;
depth_view_info.subresourceRange.layerCount = 1;
depth_view_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
depth_view_info.subresourceRange.layerCount = layers;
depth_view_info.viewType = layers > 1 ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D;
depth_view_info.flags = 0;
VkDevice device = vulkan_->GetDevice();
@@ -231,6 +233,13 @@ void VulkanQueueRunner::PreprocessSteps(std::vector<VKRStep *> &steps) {
// as early as possible in the frame (Wipeout billboards). This will require taking over more of descriptor management so we can
// substitute descriptors, alternatively using texture array layers creatively.
// Before passes get merged, so it sees them as the game drew them.
if (IsVREnabled()) {
for (VKRStep *step : steps) {
PreprocessVulkanStepVR(step);
}
}
for (int j = 0; j < (int)steps.size(); j++) {
decltype(steps[j]->render) &render = steps[j]->render;
if (steps[j]->stepType == VKRStepType::RENDER &&
+1 -1
View File
@@ -281,7 +281,7 @@ public:
bool InitDepthStencilBuffer(VkCommandBuffer cmd, VulkanBarrierBatch *barriers); // Used for non-buffered rendering.
// For additional swapchains too. The depth image is transitioned by the barriers.
VkFramebuffer CreateBackbufferFramebuffer(VkImageView colorView, VkImageView depthView, int width, int height);
bool CreateDepthStencilImage(int width, int height, VkImage *image, VmaAllocation *alloc, VkImageView *view, VulkanBarrierBatch *barriers, const char *tag);
bool CreateDepthStencilImage(int width, int height, int layers, VkImage *image, VmaAllocation *alloc, VkImageView *view, VulkanBarrierBatch *barriers, const char *tag);
private:
VKRRenderPass *PerformBindFramebufferAsRenderTarget(const VKRStep &pass, VkCommandBuffer cmd);
+4 -3
View File
@@ -380,8 +380,9 @@ static void InitSwapchainImageData(VulkanContext *vulkan, VkImage image, Swapcha
color_image_view.subresourceRange.baseMipLevel = 0;
color_image_view.subresourceRange.levelCount = 1;
color_image_view.subresourceRange.baseArrayLayer = 0;
color_image_view.subresourceRange.layerCount = 1; // TODO: Investigate hw-assisted stereo.
color_image_view.viewType = VK_IMAGE_VIEW_TYPE_2D;
const int layers = vulkan->GetBackbufferLayers();
color_image_view.subresourceRange.layerCount = layers;
color_image_view.viewType = layers > 1 ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D;
color_image_view.flags = 0;
color_image_view.image = image;
@@ -660,7 +661,7 @@ bool VulkanRenderManager::InitExtraSwapchain(VKRSwapchain *swapchain, std::strin
std::vector<VkImage> images(count);
vkGetSwapchainImagesKHR(vulkan_->GetDevice(), swapchain->swapchain, &count, images.data());
if (!queueRunner_.CreateDepthStencilImage(extent.width, extent.height, &swapchain->depthImage, &swapchain->depthAlloc, &swapchain->depthView, &postInitBarrier_, "ExtraSwapchainDepth")) {
if (!queueRunner_.CreateDepthStencilImage(extent.width, extent.height, 1, &swapchain->depthImage, &swapchain->depthAlloc, &swapchain->depthView, &postInitBarrier_, "ExtraSwapchainDepth")) {
*error = "Failed to create the depth buffer";
return false;
}
+6
View File
@@ -32,6 +32,12 @@
#define XR_NO_PROTOTYPES 1
#endif
#if defined(ANDROID) || (defined(_WIN32) && defined(XR_USE_PLATFORM_WIN32))
// Brings in the Vulkan types (no prototypes, we load Vulkan ourselves).
#include "Common/GPU/Vulkan/VulkanLoader.h"
#define XR_USE_GRAPHICS_API_VULKAN 1
#endif
#include <openxr/openxr.h>
#include <openxr/openxr_platform.h>
+91 -9
View File
@@ -1,10 +1,11 @@
#include <atomic>
#include <mutex>
#include "Common/VR/PPSSPPVR.h"
#ifdef __LIBRETRO__
#include <atomic>
#include "libretro/LibretroVR.h"
#endif
#include "Common/GPU/Vulkan/VulkanRenderManager.h"
#include "Common/VR/VRBase.h"
#if XR_USE_GRAPHICS_API_OPENGL || XR_USE_GRAPHICS_API_OPENGL_ES || defined(__LIBRETRO__)
@@ -55,12 +56,8 @@ static std::map<int, std::map<int, float> > pspAxis;
static std::map<int, bool> pspKeys; // key can be virtual, so not using the enum.
static int vr3DGeometryCount = 0;
#ifdef __LIBRETRO__
// Fog colour is recorded on the emulation thread and consumed during GL replay.
// Fog colour is recorded on the emulation thread and consumed during replay, on the render thread.
static std::atomic<long> vrCompat[VR_COMPAT_MAX]{};
#else
static long vrCompat[VR_COMPAT_MAX];
#endif
static bool vrFlatForced = false;
static bool vrFlatGame = false;
static float vrMatrix[VR_MATRIX_COUNT][16];
@@ -191,15 +188,27 @@ void InitVROnAndroid(void* vm, void* activity, const char* system, int version,
}
#endif
void EnterVR(bool firstStart) {
if (firstStart) {
engine_t* engine = VR_GetEngine();
void EnterVR() {
engine_t* engine = VR_GetEngine();
// The session outlives the render loop (it restarts when the surface comes back), not the native side.
if (engine->appState.Session == XR_NULL_HANDLE) {
VR_EnterVR(engine);
IN_VRInit(engine);
}
VR_SetConfig(VR_CONFIG_VIEWPORT_VALID, false);
}
void ShutdownVR() {
engine_t* engine = VR_GetEngine();
if (engine->appState.Instance == XR_NULL_HANDLE) {
return;
}
// GL's swapchains (Vulkan's go with its presentation).
VR_DestroyRenderer(engine);
VR_LeaveVR(engine);
VR_Destroy(engine);
}
void GetVRResolutionPerEye(int* width, int* height) {
if (VR_GetEngine()->appState.Instance) {
VR_GetResolution(VR_GetEngine(), width, height);
@@ -523,6 +532,45 @@ void PreprocessStepVR(void* step) {}
#endif
// PreprocessSkyplane on a Vulkan step. Depth test lives in the pipelines, and a framebuffer bound
// as a texture shows up as a dependency on a framebuffer other than the target.
static void PreprocessSkyplaneVulkan(VKRStep *step) {
if (step->stepType != VKRStepType::RENDER || IsFlatVRScene()) {
return;
}
for (size_t i = 0; i < step->dependencies.size(); i++) {
if (step->dependencies[i] != step->render.framebuffer) {
return;
}
}
// Clear sky with the fog color, unless the pass clears anyway (it would win over our clear on GL).
if (!vrCompat[VR_COMPAT_FBO_CLEAR]) {
if (step->render.colorLoad != VKRRenderPassLoadAction::CLEAR) {
step->render.colorLoad = VKRRenderPassLoadAction::CLEAR;
step->render.clearColor = (uint32_t)vrCompat[VR_COMPAT_FOG_COLOR];
}
vrCompat[VR_COMPAT_FBO_CLEAR] = true;
}
// Remove original sky plane.
bool depthEnabled = false;
for (VkRenderData &command : step->commands) {
if (command.cmd == VKRRenderCommand::BIND_GRAPHICS_PIPELINE) {
const VKRGraphicsPipelineDesc *desc = command.graphics_pipeline.pipeline->desc;
depthEnabled = desc && desc->dss.depthTestEnable;
} else if (command.cmd == VKRRenderCommand::DRAW_INDEXED && !depthEnabled) {
command.cmd = VKRRenderCommand::REMOVED;
}
}
}
void PreprocessVulkanStepVR(VKRStep *step) {
if (vrCompat[VR_COMPAT_SKYPLANE]) {
PreprocessSkyplaneVulkan(step);
}
}
void SetVRCompat(VRCompatFlag flag, long value) {
vrCompat[flag] = value;
}
@@ -542,6 +590,10 @@ void* BindVRFramebuffer() {
bool StartVRRender() {
#ifndef __LIBRETRO__
if (!VR_GetConfig(VR_CONFIG_VIEWPORT_VALID)) {
if (VR_GetPlatformFlag(VR_PLATFORM_RENDERER_VULKAN)) {
// The presentation creates the swapchain with the surface. There isn't one now.
return false;
}
VR_InitRenderer(VR_GetEngine());
VR_SetConfig(VR_CONFIG_VIEWPORT_VALID, true);
}
@@ -610,6 +662,10 @@ bool StartVRRender() {
// Set compatibility
vrCompat[VR_COMPAT_SKYPLANE] = PSP_CoreParameter().compat.vrCompat().Skyplane;
if (VR_GetPlatformFlag(VR_PLATFORM_RENDERER_VULKAN)) {
// The last frame is done on the render thread, so its steps are too. (On OpenGL, this is per eye in PreVRFrameRender.)
vrCompat[VR_COMPAT_FBO_CLEAR] = false;
}
// Set customizations
VR_SetConfigFloat(VR_CONFIG_CANVAS_DISTANCE, !IsBigScreenVRMode() && (appMode == VR_GAME_MODE) ? g_Config.fCanvas3DDistance : g_Config.fCanvasDistance);
@@ -620,6 +676,10 @@ bool StartVRRender() {
}
void FinishVRRender() {
if (VR_GetPlatformFlag(VR_PLATFORM_RENDERER_VULKAN)) {
// The render thread ends the frame once it's submitted.
return;
}
VR_FinishFrame(VR_GetEngine());
}
@@ -632,6 +692,28 @@ void PostVRFrameRender() {
VR_EndFrame(VR_GetEngine());
}
bool GetVRMouseCursorRect(int *x, int *y, int *w, int *h) {
#ifdef __LIBRETRO__
return false;
#else
if (!VR_GetPlatformFlag(VR_PLATFORM_RENDERER_VULKAN)) {
return false;
}
// The same rect VR_EndFrame clears on OpenGL, where y counts from the bottom.
const int vrMode = VR_GetConfig(VR_CONFIG_MODE);
const bool screenMode = (vrMode == VR_MODE_MONO_SCREEN) || (vrMode == VR_MODE_STEREO_SCREEN);
const int size = VR_GetConfig(VR_CONFIG_MOUSE_SIZE);
if (!screenMode || size <= 0) {
return false;
}
*w = size;
*h = (int)((float)size * VR_GetConfigFloat(VR_CONFIG_CANVAS_ASPECT));
*x = VR_GetConfig(VR_CONFIG_MOUSE_X);
*y = VR_GetConfig(VR_CONFIG_VIEWPORT_HEIGHT) - VR_GetConfig(VR_CONFIG_MOUSE_Y) - *h;
return true;
#endif
}
int GetVRFBOIndex() {
#ifdef __LIBRETRO__
return Libretro::VREye();
+9 -1
View File
@@ -30,7 +30,10 @@ enum VRAppMode {
// VR app flow integration
bool IsVREnabled();
void InitVROnAndroid(void* vm, void* activity, const char* system, int version, const char* name);
void EnterVR(bool firstStart);
// GL: creates the session (once per instance, on the GL thread).
void EnterVR();
// Tears down what InitVROnAndroid and EnterVR set up, so a new activity can start over in this process.
void ShutdownVR();
void GetVRResolutionPerEye(int* width, int* height);
void SetVRCallbacks(void(*axis)(const AxisInput *axis, size_t count), bool(*key)(const KeyInput &key), void(*touch)(const TouchInput &touch));
@@ -42,6 +45,8 @@ bool UpdateVRKeys(const KeyInput &key);
// VR games compatibility
void PreprocessStepVR(void* step);
struct VKRStep;
void PreprocessVulkanStepVR(VKRStep *step);
void SetVRCompat(VRCompatFlag flag, long value);
// VR rendering integration
@@ -50,6 +55,9 @@ bool StartVRRender();
void FinishVRRender();
void PreVRFrameRender(int fboIndex);
void PostVRFrameRender();
// The pointer for the menus, in backbuffer pixels from the top left, if the app has to draw it
// (Vulkan; OpenGL draws it into the eye buffers itself).
bool GetVRMouseCursorRect(int *x, int *y, int *w, int *h);
int GetVRFBOIndex();
int GetVRPassesCount();
bool IsPassthroughSupported();
+30
View File
@@ -1,4 +1,5 @@
#include "VRBase.h"
#include "VRInput.h"
#include <assert.h>
#include <stdio.h>
@@ -39,9 +40,30 @@ void VR_Init( void* system, const char* name, int version ) {
}
#endif
std::vector<XrExtensionProperties> available;
uint32_t availableCount = 0;
if (XR_SUCCEEDED(xrEnumerateInstanceExtensionProperties(nullptr, 0, &availableCount, nullptr)) && availableCount) {
available.resize(availableCount, { XR_TYPE_EXTENSION_PROPERTIES });
xrEnumerateInstanceExtensionProperties(nullptr, availableCount, &availableCount, available.data());
}
auto isAvailable = [&](const char *name) {
for (const XrExtensionProperties &ext : available) {
if (!strcmp(ext.extensionName, name)) {
return true;
}
}
return false;
};
std::vector<const char *> extensions;
#ifdef XR_USE_GRAPHICS_API_OPENGL_ES
extensions.push_back(XR_KHR_OPENGL_ES_ENABLE_EXTENSION_NAME);
#endif
#ifdef XR_USE_GRAPHICS_API_VULKAN
if (isAvailable(XR_KHR_VULKAN_ENABLE_EXTENSION_NAME)) {
extensions.push_back(XR_KHR_VULKAN_ENABLE_EXTENSION_NAME);
VR_SetPlatformFLag(VR_PLATFORM_EXTENSION_VULKAN, true);
}
#endif
extensions.push_back(XR_KHR_COMPOSITION_LAYER_CYLINDER_EXTENSION_NAME);
#ifdef ANDROID
@@ -144,6 +166,7 @@ void VR_Destroy( engine_t* engine ) {
if (engine == &vr_engine) {
xrDestroyInstance(engine->appState.Instance);
ovrApp_Destroy(&engine->appState);
vr_initialized = 0;
}
}
@@ -171,6 +194,12 @@ void VR_EnterVR( engine_t* engine ) {
sessionCreateInfo.next = &graphicsBindingGL;
#else
//TODO:PCVR definition
#endif
#ifdef XR_USE_GRAPHICS_API_VULKAN
if (engine->appState.VulkanBinding.type == XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR) {
sessionCreateInfo.next = &engine->appState.VulkanBinding;
VR_SetPlatformFLag(VR_PLATFORM_RENDERER_VULKAN, true);
}
#endif
sessionCreateInfo.type = XR_TYPE_SESSION_CREATE_INFO;
sessionCreateInfo.createFlags = 0;
@@ -193,6 +222,7 @@ void VR_EnterVR( engine_t* engine ) {
void VR_LeaveVR( engine_t* engine ) {
if (engine->appState.Session) {
IN_VRShutdown(engine);
OXR(xrDestroySpace(engine->appState.HeadSpace));
// StageSpace is optional.
if (engine->appState.StageSpace != XR_NULL_HANDLE) {
+12
View File
@@ -69,8 +69,13 @@ typedef struct {
void* ColorSwapChainImage;
unsigned int* GLDepthBuffers;
unsigned int* GLFrameBuffers;
// Vulkan: one swapchain whose images have a layer per eye.
int ArraySize;
int64_t SwapchainFormat; // As created (sRGB, on Vulkan we render through a UNORM view).
bool Acquired;
// At least one image has been released, so the swapchain can be put in a layer.
bool EverReleased;
} ovrFramebuffer;
typedef struct {
@@ -99,6 +104,11 @@ typedef struct {
int LayerCount;
ovrRenderer Renderer;
#ifdef XR_USE_GRAPHICS_API_VULKAN
// Set before VR_EnterVR to create the session for Vulkan instead of OpenGL.
XrGraphicsBindingVulkanKHR VulkanBinding;
#endif
} ovrApp;
#ifdef ANDROID
@@ -122,6 +132,8 @@ enum VRPlatformFlag {
VR_PLATFORM_EXTENSION_PASSTHROUGH,
VR_PLATFORM_EXTENSION_PERFORMANCE,
VR_PLATFORM_TRACKING_FLOOR,
VR_PLATFORM_EXTENSION_VULKAN, // The runtime has XR_KHR_vulkan_enable.
VR_PLATFORM_RENDERER_VULKAN, // The session is a Vulkan one.
VR_PLATFORM_MAX
};
+152 -8
View File
@@ -3,6 +3,29 @@
#if XR_USE_GRAPHICS_API_OPENGL || XR_USE_GRAPHICS_API_OPENGL_ES
#include "Common/GPU/OpenGL/GLCommon.h"
#include <cstring>
#ifndef GL_FRAMEBUFFER_SRGB_EXT
#define GL_FRAMEBUFFER_SRGB_EXT 0x8DB9
#endif
// GLFeatures.h clashes with the EGL macros the OpenXR headers bring in, so this asks GL itself.
static bool HasSRGBWriteControl() {
static int has = -1;
if (has < 0) {
GLint count = 0;
glGetIntegerv(GL_NUM_EXTENSIONS, &count);
has = 0;
for (GLint i = 0; i < count; i++) {
const char *ext = (const char *)glGetStringi(GL_EXTENSIONS, i);
if (ext && !strcmp(ext, "GL_EXT_sRGB_write_control")) {
has = 1;
break;
}
}
}
return has == 1;
}
#endif
@@ -20,6 +43,7 @@
#include <cmath>
#include <ctime>
#include <cassert>
#include <vector>
#if !defined(_WIN32)
#include <pthread.h>
@@ -50,7 +74,96 @@ void ovrFramebuffer_Clear(ovrFramebuffer* frameBuffer) {
frameBuffer->GLDepthBuffers = NULL;
frameBuffer->GLFrameBuffers = NULL;
frameBuffer->ArraySize = 0;
frameBuffer->SwapchainFormat = 0;
frameBuffer->Acquired = false;
frameBuffer->EverReleased = false;
}
// Both APIs can be compiled in (Android), so this is a runtime choice.
static bool UseGL() {
#if XR_USE_GRAPHICS_API_OPENGL_ES || XR_USE_GRAPHICS_API_OPENGL
return !VR_GetPlatformFlag(VR_PLATFORM_RENDERER_VULKAN);
#else
return false;
#endif
}
#ifdef XR_USE_GRAPHICS_API_VULKAN
static bool ovrFramebuffer_CreateVK(XrSession session, ovrFramebuffer* frameBuffer, int width, int height, int layers) {
frameBuffer->Width = width;
frameBuffer->Height = height;
frameBuffer->ArraySize = layers;
// We write sRGB-encoded values and want them shown as they are. The Quest shows UNORM images as
// they are. By the spec, an sRGB image drawn through a UNORM view (mutable) would be the way, but
// the Quest's compositor shows that with snow along edges, even with the view formats listed
// (XR_KHR_vulkan_swapchain_format_list). So sRGB only where there's no UNORM.
uint32_t formatCount = 0;
OXR(xrEnumerateSwapchainFormats(session, 0, &formatCount, nullptr));
std::vector<int64_t> formats(formatCount);
OXR(xrEnumerateSwapchainFormats(session, formatCount, &formatCount, formats.data()));
const int64_t preferred[] = { VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_R8G8B8A8_SRGB, VK_FORMAT_B8G8R8A8_SRGB };
int64_t format = 0;
for (int64_t want : preferred) {
for (int64_t have : formats) {
if (have == want) {
format = want;
break;
}
}
if (format) {
break;
}
}
if (!format) {
ALOGE("No usable Vulkan swapchain format");
return false;
}
frameBuffer->SwapchainFormat = format;
XrSwapchainCreateInfo swapChainCreateInfo{ XR_TYPE_SWAPCHAIN_CREATE_INFO };
swapChainCreateInfo.usageFlags = XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT;
if (format == VK_FORMAT_R8G8B8A8_SRGB || format == VK_FORMAT_B8G8R8A8_SRGB) {
// Drawn through a UNORM view.
swapChainCreateInfo.usageFlags |= XR_SWAPCHAIN_USAGE_MUTABLE_FORMAT_BIT;
}
swapChainCreateInfo.format = format;
swapChainCreateInfo.sampleCount = 1;
swapChainCreateInfo.width = width;
swapChainCreateInfo.height = height;
swapChainCreateInfo.faceCount = 1;
swapChainCreateInfo.arraySize = layers;
swapChainCreateInfo.mipCount = 1;
frameBuffer->ColorSwapChain.Width = width;
frameBuffer->ColorSwapChain.Height = height;
XrResult res;
OXR(res = xrCreateSwapchain(session, &swapChainCreateInfo, &frameBuffer->ColorSwapChain.Handle));
if (XR_FAILED(res)) {
return false;
}
OXR(xrEnumerateSwapchainImages(frameBuffer->ColorSwapChain.Handle, 0, &frameBuffer->TextureSwapChainLength, nullptr));
XrSwapchainImageVulkanKHR *images = (XrSwapchainImageVulkanKHR *)calloc(frameBuffer->TextureSwapChainLength, sizeof(XrSwapchainImageVulkanKHR));
for (uint32_t i = 0; i < frameBuffer->TextureSwapChainLength; i++) {
images[i].type = XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR;
}
OXR(xrEnumerateSwapchainImages(frameBuffer->ColorSwapChain.Handle, frameBuffer->TextureSwapChainLength, &frameBuffer->TextureSwapChainLength, (XrSwapchainImageBaseHeader *)images));
frameBuffer->ColorSwapChainImage = images;
return true;
}
#endif
void *ovrFramebuffer_GetVulkanImage(ovrFramebuffer* frameBuffer, uint32_t index) {
#ifdef XR_USE_GRAPHICS_API_VULKAN
if (frameBuffer->ColorSwapChainImage && index < frameBuffer->TextureSwapChainLength) {
return (void *)((XrSwapchainImageVulkanKHR *)frameBuffer->ColorSwapChainImage)[index].image;
}
#endif
return nullptr;
}
#if XR_USE_GRAPHICS_API_OPENGL || XR_USE_GRAPHICS_API_OPENGL_ES
@@ -154,9 +267,16 @@ static bool ovrFramebuffer_CreateGL(XrSession session, ovrFramebuffer* frameBuff
#endif
void ovrFramebuffer_Destroy(ovrFramebuffer* frameBuffer) {
if (frameBuffer->ColorSwapChain.Handle == XR_NULL_HANDLE) {
// Never created (the second eye on Vulkan).
ovrFramebuffer_Clear(frameBuffer);
return;
}
#if XR_USE_GRAPHICS_API_OPENGL_ES || XR_USE_GRAPHICS_API_OPENGL
GL(glDeleteRenderbuffers(frameBuffer->TextureSwapChainLength, frameBuffer->GLDepthBuffers));
GL(glDeleteFramebuffers(frameBuffer->TextureSwapChainLength, frameBuffer->GLFrameBuffers));
if (UseGL()) {
GL(glDeleteRenderbuffers(frameBuffer->TextureSwapChainLength, frameBuffer->GLDepthBuffers));
GL(glDeleteFramebuffers(frameBuffer->TextureSwapChainLength, frameBuffer->GLFrameBuffers));
}
free(frameBuffer->GLDepthBuffers);
free(frameBuffer->GLFrameBuffers);
#endif
@@ -168,7 +288,14 @@ void ovrFramebuffer_Destroy(ovrFramebuffer* frameBuffer) {
void* ovrFramebuffer_SetCurrent(ovrFramebuffer* frameBuffer) {
#if XR_USE_GRAPHICS_API_OPENGL_ES || XR_USE_GRAPHICS_API_OPENGL
GL(glBindFramebuffer(GL_DRAW_FRAMEBUFFER, frameBuffer->GLFrameBuffers[frameBuffer->TextureSwapChainIndex]));
if (UseGL()) {
GL(glBindFramebuffer(GL_DRAW_FRAMEBUFFER, frameBuffer->GLFrameBuffers[frameBuffer->TextureSwapChainIndex]));
// The swapchain is sRGB and our colors are sRGB-encoded already: GLES would encode them again on
// write (too bright). Context state, but the other framebuffers aren't sRGB, so it only affects this.
if (HasSRGBWriteControl()) {
GL(glDisable(GL_FRAMEBUFFER_SRGB_EXT));
}
}
#endif
return nullptr;
}
@@ -184,6 +311,10 @@ void ovrFramebuffer_Acquire(ovrFramebuffer* frameBuffer) {
XrResult res = xrWaitSwapchainImage(frameBuffer->ColorSwapChain.Handle, &waitInfo);
frameBuffer->Acquired = res == XR_SUCCESS;
if (!UseGL()) {
return;
}
ovrFramebuffer_SetCurrent(frameBuffer);
#if XR_USE_GRAPHICS_API_OPENGL_ES || XR_USE_GRAPHICS_API_OPENGL
@@ -202,13 +333,16 @@ void ovrFramebuffer_Release(ovrFramebuffer* frameBuffer) {
XrSwapchainImageReleaseInfo releaseInfo = {XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO, NULL};
OXR(xrReleaseSwapchainImage(frameBuffer->ColorSwapChain.Handle, &releaseInfo));
frameBuffer->Acquired = false;
frameBuffer->EverReleased = true;
// Clear the alpha channel, other way OpenXR would not transfer the framebuffer fully
#if XR_USE_GRAPHICS_API_OPENGL_ES || XR_USE_GRAPHICS_API_OPENGL
GL(glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE));
GL(glClearColor(0.0f, 0.0f, 0.0f, 1.0f));
GL(glClear(GL_COLOR_BUFFER_BIT));
GL(glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE));
if (UseGL()) {
GL(glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE));
GL(glClearColor(0.0f, 0.0f, 0.0f, 1.0f));
GL(glClear(GL_COLOR_BUFFER_BIT));
GL(glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE));
}
#endif
}
}
@@ -227,12 +361,19 @@ void ovrRenderer_Clear(ovrRenderer* renderer) {
}
}
void ovrRenderer_Create(XrSession session, ovrRenderer* renderer, int width, int height) {
bool ovrRenderer_Create(XrSession session, ovrRenderer* renderer, int width, int height) {
#ifdef XR_USE_GRAPHICS_API_VULKAN
if (!UseGL()) {
// Both eyes in one swapchain, a layer each, drawn with multiview.
return ovrFramebuffer_CreateVK(session, &renderer->FrameBuffer[0], width, height, ovrMaxNumEyes);
}
#endif
for (int i = 0; i < ovrMaxNumEyes; i++) {
#if XR_USE_GRAPHICS_API_OPENGL_ES || XR_USE_GRAPHICS_API_OPENGL
ovrFramebuffer_CreateGL(session, &renderer->FrameBuffer[i], width, height);
#endif
}
return true;
}
void ovrRenderer_Destroy(ovrRenderer* renderer) {
@@ -243,6 +384,9 @@ void ovrRenderer_Destroy(ovrRenderer* renderer) {
void ovrRenderer_MouseCursor(ovrRenderer* renderer, int x, int y, int sx, int sy) {
#if XR_USE_GRAPHICS_API_OPENGL_ES || XR_USE_GRAPHICS_API_OPENGL
if (!UseGL()) {
return;
}
GL(glEnable(GL_SCISSOR_TEST));
GL(glScissor(x, y, sx, sy));
GL(glViewport(x, y, sx, sy));
+2 -1
View File
@@ -10,6 +10,7 @@ void ovrFramebuffer_Acquire(ovrFramebuffer* frameBuffer);
void ovrFramebuffer_Release(ovrFramebuffer* frameBuffer);
void* ovrFramebuffer_SetCurrent(ovrFramebuffer* frameBuffer);
void ovrRenderer_Create(XrSession session, ovrRenderer* renderer, int width, int height);
bool ovrRenderer_Create(XrSession session, ovrRenderer* renderer, int width, int height);
void *ovrFramebuffer_GetVulkanImage(ovrFramebuffer* frameBuffer, uint32_t index);
void ovrRenderer_Destroy(ovrRenderer* renderer);
void ovrRenderer_MouseCursor(ovrRenderer* renderer, int x, int y, int sx, int sy);
+20
View File
@@ -375,6 +375,26 @@ void IN_VRInit( engine_t *engine ) {
inputInitialized = 1;
}
void IN_VRShutdown( engine_t* engine ) {
if (!inputInitialized) {
return;
}
// The aim spaces belong to the session and the action set is attached to it, so a new session
// (a new graphics context or activity) needs new ones.
if (leftControllerAimSpace != XR_NULL_HANDLE) {
OXR(xrDestroySpace(leftControllerAimSpace));
leftControllerAimSpace = XR_NULL_HANDLE;
}
if (rightControllerAimSpace != XR_NULL_HANDLE) {
OXR(xrDestroySpace(rightControllerAimSpace));
rightControllerAimSpace = XR_NULL_HANDLE;
}
// Destroys its actions too.
OXR(xrDestroyActionSet(runningActionSet));
runningActionSet = XR_NULL_HANDLE;
inputInitialized = 0;
}
void IN_VRInputFrame( engine_t* engine ) {
// sync action data
+1
View File
@@ -29,6 +29,7 @@ typedef enum ovrButton_ {
} ovrButton;
void IN_VRInit( engine_t *engine );
void IN_VRShutdown( engine_t *engine );
void IN_VRInputFrame( engine_t* engine );
uint32_t IN_VRGetButtonState( int controllerIndex );
XrVector2f IN_VRGetJoystickState( int controllerIndex );
+160 -15
View File
@@ -8,6 +8,21 @@
#include <cstdlib>
#include <cstring>
#include <condition_variable>
#include <mutex>
// On Vulkan, VR_InitFrame (emu thread) begins the frame and VR_FinishFrame (render thread, after the
// submit) ends it. The next frame can't begin before that.
static std::mutex g_frameMutex;
static std::condition_variable g_frameCond;
static bool g_frameOpen = false;
static bool g_presentQueued = false;
// The runtime may use the VkQueue in xrBeginFrame, xrEndFrame and the swapchain calls.
static std::recursive_mutex g_queueMutex;
static bool IsVulkan() {
return VR_GetPlatformFlag(VR_PLATFORM_RENDERER_VULKAN);
}
XrFovf fov;
XrView* projections;
@@ -141,8 +156,16 @@ void VR_Recenter(engine_t* engine) {
if (engine->appState.CurrentSpace != XR_NULL_HANDLE) {
XrSpaceLocation loc = {};
loc.type = XR_TYPE_SPACE_LOCATION;
OXR(xrLocateSpace(engine->appState.HeadSpace, engine->appState.CurrentSpace, engine->predictedDisplayTime, &loc));
hmdorientation = XrQuaternionf_ToEulerAngles(loc.pose.orientation);
XrResult locateResult = XR_ERROR_TIME_INVALID;
if (engine->predictedDisplayTime != 0) {
OXR(locateResult = xrLocateSpace(engine->appState.HeadSpace, engine->appState.CurrentSpace, engine->predictedDisplayTime, &loc));
}
if (XR_SUCCEEDED(locateResult) && (loc.locationFlags & XR_SPACE_LOCATION_ORIENTATION_VALID_BIT)) {
hmdorientation = XrQuaternionf_ToEulerAngles(loc.pose.orientation);
} else {
// Before the first frame, or not tracking. A zero quaternion would make every layer's pose invalid.
hmdorientation = {};
}
VR_SetConfigFloat(VR_CONFIG_RECENTER_YAW, VR_GetConfigFloat(VR_CONFIG_RECENTER_YAW) + hmdorientation.y);
float recenterYaw = ToRadians(VR_GetConfigFloat(VR_CONFIG_RECENTER_YAW));
@@ -183,8 +206,9 @@ void VR_Recenter(engine_t* engine) {
}
}
// Update menu orientation
VR_SetConfigFloat(VR_CONFIG_MENU_PITCH, hmdorientation.x);
// Update menu orientation. The screen stays upright: tilting it to the head's pitch at recenter
// time (often looking down while putting the headset on) left it at an angle for the session.
VR_SetConfigFloat(VR_CONFIG_MENU_PITCH, 0.0f);
VR_SetConfigFloat(VR_CONFIG_MENU_YAW, 0.0f);
}
@@ -237,7 +261,9 @@ void VR_InitRenderer( engine_t* engine ) {
projections[eye].type = XR_TYPE_VIEW;
}
ovrRenderer_Create(engine->appState.Session, &engine->appState.Renderer, eyeW, eyeH);
if (!ovrRenderer_Create(engine->appState.Session, &engine->appState.Renderer, eyeW, eyeH)) {
ALOGE("Failed to create the XR swapchains");
}
if (VR_GetPlatformFlag(VRPlatformFlag::VR_PLATFORM_EXTENSION_PASSTHROUGH)) {
XrPassthroughCreateInfoFB ptci = {XR_TYPE_PASSTHROUGH_CREATE_INFO_FB};
@@ -257,9 +283,17 @@ void VR_InitRenderer( engine_t* engine ) {
}
void VR_DestroyRenderer( engine_t* engine ) {
if (!initialized) {
return;
}
if (VR_GetPlatformFlag(VRPlatformFlag::VR_PLATFORM_EXTENSION_PASSTHROUGH)) {
if (passthroughRunning) {
OXR(xrPassthroughLayerPauseFB(passthroughLayer));
passthroughRunning = false;
}
if (passthroughLayer != XR_NULL_HANDLE) {
OXR(xrDestroyPassthroughLayerFB(passthroughLayer));
passthroughLayer = XR_NULL_HANDLE;
}
OXR(xrPassthroughPauseFB(passthrough));
OXR(xrDestroyPassthroughFB(passthrough));
@@ -272,6 +306,18 @@ void VR_DestroyRenderer( engine_t* engine ) {
}
bool VR_InitFrame( engine_t* engine ) {
if (IsVulkan()) {
// Before the events: they can end the session or recreate the space the last frame ends in.
std::unique_lock<std::mutex> lock(g_frameMutex);
if (g_frameOpen && !g_presentQueued) {
// The last frame never got to the render thread, so nothing there will end it.
lock.unlock();
VR_FinishFrame(engine);
lock.lock();
}
g_frameCond.wait(lock, [] { return !g_frameOpen; });
}
bool stageBoundsDirty = true;
if (ovrApp_HandleXrEvents(&engine->appState)) {
VR_Recenter(engine);
@@ -321,6 +367,16 @@ bool VR_InitFrame( engine_t* engine ) {
&projectionCountOutput,
projections));
// Not tracking (yet). Layers with these poses would be rejected.
for (int eye = 0; eye < ovrMaxNumEyes; eye++) {
if (!(viewState.viewStateFlags & XR_VIEW_STATE_ORIENTATION_VALID_BIT)) {
projections[eye].pose.orientation = { 0.0f, 0.0f, 0.0f, 1.0f };
}
if (!(viewState.viewStateFlags & XR_VIEW_STATE_POSITION_VALID_BIT)) {
projections[eye].pose.position = { 0.0f, 0.0f, 0.0f };
}
}
// Get the HMD pose, predicted for the middle of the time period during which
// the new eye images will be displayed. The number of frames predicted ahead
// depends on the pipeline depth of the engine and the synthesis rate.
@@ -328,7 +384,15 @@ bool VR_InitFrame( engine_t* engine ) {
XrFrameBeginInfo beginFrameDesc = {};
beginFrameDesc.type = XR_TYPE_FRAME_BEGIN_INFO;
beginFrameDesc.next = NULL;
OXR(xrBeginFrame(engine->appState.Session, &beginFrameDesc));
if (IsVulkan()) {
std::lock_guard<std::recursive_mutex> queueLock(g_queueMutex);
OXR(xrBeginFrame(engine->appState.Session, &beginFrameDesc));
std::lock_guard<std::mutex> lock(g_frameMutex);
g_frameOpen = true;
g_presentQueued = false;
} else {
OXR(xrBeginFrame(engine->appState.Session, &beginFrameDesc));
}
fov = {};
for (int eye = 0; eye < ovrMaxNumEyes; eye++) {
@@ -345,8 +409,10 @@ bool VR_InitFrame( engine_t* engine ) {
for (int i = 0; i < ovrMaxNumEyes; i++) {
ovrFramebuffer* frameBuffer = &engine->appState.Renderer.FrameBuffer[i];
frameBuffer->TextureSwapChainIndex++;
frameBuffer->TextureSwapChainIndex %= frameBuffer->TextureSwapChainLength;
if (frameBuffer->TextureSwapChainLength) {
frameBuffer->TextureSwapChainIndex++;
frameBuffer->TextureSwapChainIndex %= frameBuffer->TextureSwapChainLength;
}
}
engine->appState.LayerCount = 0;
@@ -354,6 +420,44 @@ bool VR_InitFrame( engine_t* engine ) {
return true;
}
void VR_NotifyPresentQueued() {
std::lock_guard<std::mutex> lock(g_frameMutex);
g_presentQueued = true;
}
void VR_LockQueue() {
g_queueMutex.lock();
}
void VR_UnlockQueue() {
g_queueMutex.unlock();
}
bool VR_AcquireVulkanImage(engine_t *engine, uint32_t *index) {
ovrFramebuffer *frameBuffer = &engine->appState.Renderer.FrameBuffer[0];
if (frameBuffer->ColorSwapChain.Handle == XR_NULL_HANDLE) {
return false;
}
{
std::lock_guard<std::mutex> lock(g_frameMutex);
if (!g_frameOpen) {
return false;
}
}
std::lock_guard<std::recursive_mutex> queueLock(g_queueMutex);
ovrFramebuffer_Acquire(frameBuffer);
if (!frameBuffer->Acquired) {
return false;
}
*index = frameBuffer->TextureSwapChainIndex;
return true;
}
void VR_ReleaseVulkanImage(engine_t *engine) {
std::lock_guard<std::recursive_mutex> queueLock(g_queueMutex);
ovrFramebuffer_Release(&engine->appState.Renderer.FrameBuffer[0]);
}
void VR_BeginFrame( engine_t* engine, int fboIndex ) {
vrConfig[VR_CONFIG_CURRENT_FBO] = fboIndex;
ovrFramebuffer_Acquire(&engine->appState.Renderer.FrameBuffer[fboIndex]);
@@ -378,6 +482,29 @@ void VR_EndFrame( engine_t* engine ) {
}
void VR_FinishFrame( engine_t* engine ) {
const bool vulkan = IsVulkan();
if (vulkan) {
std::lock_guard<std::mutex> lock(g_frameMutex);
if (!g_frameOpen) {
return;
}
}
if (vulkan && engine->appState.Renderer.FrameBuffer[0].Acquired) {
// A frame that never got to present.
VR_ReleaseVulkanImage(engine);
}
// On Vulkan both eyes are layers of FrameBuffer[0]. Its alpha isn't cleared to 1 like the GL path's,
// so the layers are opaque instead.
ovrFramebuffer *eyeBuffers[ovrMaxNumEyes];
uint32_t eyeLayers[ovrMaxNumEyes];
for (int eye = 0; eye < ovrMaxNumEyes; eye++) {
eyeBuffers[eye] = &engine->appState.Renderer.FrameBuffer[vulkan ? 0 : eye];
eyeLayers[eye] = vulkan ? eye : 0;
}
const XrCompositionLayerFlags alphaFlag = vulkan ? 0 : XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT;
// A swapchain that has never had an image released can't be shown.
const bool canShow = !vulkan || engine->appState.Renderer.FrameBuffer[0].EverReleased;
if (VR_GetPlatformFlag(VRPlatformFlag::VR_PLATFORM_EXTENSION_PASSTHROUGH) && VR_GetConfig(VR_CONFIG_PASSTHROUGH)) {
if (passthroughLayer != XR_NULL_HANDLE) {
XrCompositionLayerPassthroughFB passthrough_layer = {XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_FB};
@@ -396,13 +523,15 @@ void VR_FinishFrame( engine_t* engine ) {
VR_SetConfigFloat(VR_CONFIG_MENU_YAW, hmdorientation.y);
for (int eye = 0; eye < ovrMaxNumEyes; eye++) {;
ovrFramebuffer* frameBuffer = &engine->appState.Renderer.FrameBuffer[0];
ovrFramebuffer* frameBuffer = eyeBuffers[0];
uint32_t arrayIndex = eyeLayers[0];
XrPosef pose = invViewTransform[0];
if (vrMode != VR_MODE_MONO_6DOF) {
pose = invViewTransform[eye];
}
if (vrMode == VR_MODE_STEREO_6DOF) {
frameBuffer = &engine->appState.Renderer.FrameBuffer[eye];
frameBuffer = eyeBuffers[eye];
arrayIndex = eyeLayers[eye];
}
memset(&projection_layer_elements[eye], 0, sizeof(XrCompositionLayerProjectionView));
@@ -416,7 +545,7 @@ void VR_FinishFrame( engine_t* engine ) {
projection_layer_elements[eye].subImage.imageRect.offset.y = 0;
projection_layer_elements[eye].subImage.imageRect.extent.width = frameBuffer->ColorSwapChain.Width;
projection_layer_elements[eye].subImage.imageRect.extent.height = frameBuffer->ColorSwapChain.Height;
projection_layer_elements[eye].subImage.imageArrayIndex = 0;
projection_layer_elements[eye].subImage.imageArrayIndex = arrayIndex;
if (vrMode == VR_MODE_SBS_6DOF) {
projection_layer_elements[eye].subImage.imageRect.extent.width /= 2;
@@ -428,7 +557,7 @@ void VR_FinishFrame( engine_t* engine ) {
XrCompositionLayerProjection projection_layer = {};
projection_layer.type = XR_TYPE_COMPOSITION_LAYER_PROJECTION;
projection_layer.layerFlags = XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT;
projection_layer.layerFlags = alphaFlag;
projection_layer.layerFlags |= XR_COMPOSITION_LAYER_CORRECT_CHROMATIC_ABERRATION_BIT;
projection_layer.space = engine->appState.CurrentSpace;
projection_layer.viewCount = ovrMaxNumEyes;
@@ -453,7 +582,7 @@ void VR_FinishFrame( engine_t* engine ) {
// Setup the cylinder layer
XrCompositionLayerCylinderKHR cylinder_layer = {};
cylinder_layer.type = XR_TYPE_COMPOSITION_LAYER_CYLINDER_KHR;
cylinder_layer.layerFlags = XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT;
cylinder_layer.layerFlags = alphaFlag;
cylinder_layer.space = engine->appState.CurrentSpace;
memset(&cylinder_layer.subImage, 0, sizeof(XrSwapchainSubImage));
cylinder_layer.subImage.imageRect.offset.x = 0;
@@ -489,11 +618,16 @@ void VR_FinishFrame( engine_t* engine ) {
cylinder_layer.eyeVisibility = XR_EYE_VISIBILITY_LEFT;
engine->appState.Layers[engine->appState.LayerCount++].Cylinder = cylinder_layer;
cylinder_layer.eyeVisibility = XR_EYE_VISIBILITY_RIGHT;
cylinder_layer.subImage.swapchain = engine->appState.Renderer.FrameBuffer[1].ColorSwapChain.Handle;
cylinder_layer.subImage.swapchain = eyeBuffers[1]->ColorSwapChain.Handle;
cylinder_layer.subImage.imageArrayIndex = eyeLayers[1];
engine->appState.Layers[engine->appState.LayerCount++].Cylinder = cylinder_layer;
}
}
if (!canShow) {
engine->appState.LayerCount = 0;
}
// Compose the layers for this frame.
const XrCompositionLayerBaseHeader* layers[ovrMaxLayerCount] = {};
for (int i = 0; i < engine->appState.LayerCount; i++) {
@@ -506,7 +640,18 @@ void VR_FinishFrame( engine_t* engine ) {
endFrameInfo.environmentBlendMode = XR_ENVIRONMENT_BLEND_MODE_OPAQUE;
endFrameInfo.layerCount = engine->appState.LayerCount;
endFrameInfo.layers = layers;
OXR(xrEndFrame(engine->appState.Session, &endFrameInfo));
if (!vulkan) {
OXR(xrEndFrame(engine->appState.Session, &endFrameInfo));
return;
}
{
std::lock_guard<std::recursive_mutex> queueLock(g_queueMutex);
OXR(xrEndFrame(engine->appState.Session, &endFrameInfo));
}
std::lock_guard<std::mutex> lock(g_frameMutex);
g_frameOpen = false;
g_frameCond.notify_all();
}
int VR_GetConfig( VRConfig config ) {
+10
View File
@@ -52,5 +52,15 @@ float VR_GetConfigFloat( VRConfigFloat config );
void VR_SetConfigFloat( VRConfigFloat config, float value );
void* VR_BindFramebuffer(engine_t *engine);
// Vulkan. VR_InitFrame begins the frame on the emu thread, and the render thread ends it with
// VR_FinishFrame after submitting. Present() calls VR_NotifyPresentQueued so the next VR_InitFrame
// knows to wait for that, instead of ending the frame itself.
void VR_NotifyPresentQueued();
bool VR_AcquireVulkanImage(engine_t *engine, uint32_t *index);
void VR_ReleaseVulkanImage(engine_t *engine);
// Around every use of the VkQueue the session was created with.
void VR_LockQueue();
void VR_UnlockQueue();
XrView VR_GetView(int eye);
XrVector3f VR_GetHMDAngles();
+284
View File
@@ -0,0 +1,284 @@
// Copyright (c) 2012- PPSSPP Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0 or later versions.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official git repository and contact information can be found at
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
#include <cstring>
#include "Common/VR/VRVulkan.h"
#include "Common/VR/VRBase.h"
#include "Common/GPU/Vulkan/VulkanPresentation.h"
#ifdef XR_USE_GRAPHICS_API_VULKAN
#include "Common/Log.h"
#include "Common/GPU/Vulkan/VulkanContext.h"
#include "Common/VR/VRFramebuffer.h"
#include "Common/VR/VRInput.h"
#include "Common/VR/VRRenderer.h"
static std::vector<std::string> SplitExtensionList(const std::string &list) {
std::vector<std::string> result;
size_t start = 0;
while (start < list.size()) {
size_t end = list.find(' ', start);
if (end == std::string::npos) {
end = list.size();
}
if (end > start) {
result.push_back(list.substr(start, end - start));
}
start = end + 1;
}
return result;
}
// The runtime's extension queries return one space-separated string.
static std::vector<std::string> GetExtensionList(const char *funcName) {
engine_t *engine = VR_GetEngine();
PFN_xrGetVulkanInstanceExtensionsKHR func = nullptr; // The device one has the same signature.
if (XR_FAILED(xrGetInstanceProcAddr(engine->appState.Instance, funcName, (PFN_xrVoidFunction *)&func)) || !func) {
return {};
}
uint32_t size = 0;
if (XR_FAILED(func(engine->appState.Instance, engine->appState.SystemId, 0, &size, nullptr)) || size == 0) {
return {};
}
std::string buffer(size, '\0');
if (XR_FAILED(func(engine->appState.Instance, engine->appState.SystemId, size, &size, &buffer[0]))) {
return {};
}
buffer.resize(strlen(buffer.c_str()));
return SplitExtensionList(buffer);
}
bool VR_VulkanSupported() {
return VR_GetEngine()->appState.Instance != XR_NULL_HANDLE && VR_GetPlatformFlag(VR_PLATFORM_EXTENSION_VULKAN);
}
bool VR_VulkanUnsupported() {
return VR_GetEngine()->appState.Instance != XR_NULL_HANDLE && !VR_GetPlatformFlag(VR_PLATFORM_EXTENSION_VULKAN);
}
std::vector<std::string> VR_GetVulkanInstanceExtensions() {
std::vector<std::string> list = GetExtensionList("xrGetVulkanInstanceExtensionsKHR");
for (const std::string &ext : list) {
INFO_LOG(Log::G3D, "OpenXR wants Vulkan instance extension %s", ext.c_str());
}
return list;
}
const std::vector<const char *> &VR_GetVulkanDeviceExtensions() {
static std::vector<std::string> storage;
static std::vector<const char *> pointers;
storage = GetExtensionList("xrGetVulkanDeviceExtensionsKHR");
pointers.clear();
for (const std::string &ext : storage) {
INFO_LOG(Log::G3D, "OpenXR wants Vulkan device extension %s", ext.c_str());
pointers.push_back(ext.c_str());
}
return pointers;
}
int VR_GetVulkanPhysicalDevice(VulkanContext *vulkan) {
engine_t *engine = VR_GetEngine();
PFN_xrGetVulkanGraphicsDeviceKHR getDevice = nullptr;
if (XR_FAILED(xrGetInstanceProcAddr(engine->appState.Instance, "xrGetVulkanGraphicsDeviceKHR", (PFN_xrVoidFunction *)&getDevice)) || !getDevice) {
return -1;
}
VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
if (XR_FAILED(getDevice(engine->appState.Instance, engine->appState.SystemId, vulkan->GetInstance(), &physicalDevice))) {
return -1;
}
for (int i = 0; i < vulkan->GetNumPhysicalDevices(); i++) {
if (vulkan->GetPhysicalDevice(i) == physicalDevice) {
return i;
}
}
return -1;
}
static bool CreateSession(VulkanContext *vulkan, std::string *error) {
engine_t *engine = VR_GetEngine();
if (engine->appState.Session != XR_NULL_HANDLE) {
return true;
}
// Required before xrCreateSession, even when we don't care about the answer.
PFN_xrGetVulkanGraphicsRequirementsKHR getRequirements = nullptr;
OXR(xrGetInstanceProcAddr(engine->appState.Instance, "xrGetVulkanGraphicsRequirementsKHR", (PFN_xrVoidFunction *)&getRequirements));
if (!getRequirements) {
*error = "No xrGetVulkanGraphicsRequirementsKHR";
return false;
}
XrGraphicsRequirementsVulkanKHR requirements{ XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR };
OXR(getRequirements(engine->appState.Instance, engine->appState.SystemId, &requirements));
INFO_LOG(Log::G3D, "OpenXR Vulkan API version: min %d.%d, max %d.%d",
(int)XR_VERSION_MAJOR(requirements.minApiVersionSupported), (int)XR_VERSION_MINOR(requirements.minApiVersionSupported),
(int)XR_VERSION_MAJOR(requirements.maxApiVersionSupported), (int)XR_VERSION_MINOR(requirements.maxApiVersionSupported));
XrGraphicsBindingVulkanKHR &binding = engine->appState.VulkanBinding;
binding = { XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR };
binding.instance = vulkan->GetInstance();
binding.physicalDevice = vulkan->GetCurrentPhysicalDevice();
binding.device = vulkan->GetDevice();
binding.queueFamilyIndex = vulkan->GetGraphicsQueueFamilyIndex();
binding.queueIndex = 0;
VR_EnterVR(engine);
if (engine->appState.Session == XR_NULL_HANDLE) {
*error = "xrCreateSession failed";
return false;
}
IN_VRInit(engine);
return true;
}
static VkFormat ToUnormFormat(VkFormat format) {
switch (format) {
case VK_FORMAT_R8G8B8A8_SRGB: return VK_FORMAT_R8G8B8A8_UNORM;
case VK_FORMAT_B8G8R8A8_SRGB: return VK_FORMAT_B8G8R8A8_UNORM;
default: return format;
}
}
// The XR swapchain in place of the main swapchain. Acquire and present signal and wait on the
// frame's semaphores with empty submits (like the offscreen presentation), around the XR calls.
class OpenXRVulkanPresentation : public VulkanPresentation {
public:
bool Create() {
engine_ = VR_GetEngine();
VR_InitRenderer(engine_);
VR_SetConfig(VR_CONFIG_VIEWPORT_VALID, true);
fb_ = &engine_->appState.Renderer.FrameBuffer[0];
return fb_->ColorSwapChain.Handle != XR_NULL_HANDLE && fb_->TextureSwapChainLength > 0;
}
void Destroy(VulkanContext *vulkan) override {
if (!engine_) {
return;
}
// End a frame that's still open, while its swapchain exists.
VR_FinishFrame(engine_);
VR_DestroyRenderer(engine_);
VR_SetConfig(VR_CONFIG_VIEWPORT_VALID, false);
engine_ = nullptr;
fb_ = nullptr;
}
VkResult AcquireNextImage(VulkanContext *vulkan, VkSemaphore signalSemaphore, uint32_t *imageIndex) override {
if (!VR_AcquireVulkanImage(engine_, imageIndex)) {
// No frame to draw into (the session isn't running). Processed but not presented.
return VK_NOT_READY;
}
VkSubmitInfo submit{ VK_STRUCTURE_TYPE_SUBMIT_INFO };
submit.signalSemaphoreCount = 1;
submit.pSignalSemaphores = &signalSemaphore;
VR_LockQueue();
VkResult res = vkQueueSubmit(vulkan->GetGraphicsQueue(), 1, &submit, VK_NULL_HANDLE);
VR_UnlockQueue();
return res;
}
VkResult QueuePresent(VulkanContext *vulkan, VkQueue queue, uint32_t imageIndex, VkSemaphore waitSemaphore) override {
VkPipelineStageFlags stage = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
VkSubmitInfo submit{ VK_STRUCTURE_TYPE_SUBMIT_INFO };
submit.waitSemaphoreCount = 1;
submit.pWaitSemaphores = &waitSemaphore;
submit.pWaitDstStageMask = &stage;
VR_LockQueue();
VkResult res = vkQueueSubmit(queue, 1, &submit, VK_NULL_HANDLE);
VR_UnlockQueue();
// The rendering is submitted, so the runtime can have the image.
VR_ReleaseVulkanImage(engine_);
return res;
}
// Emu thread, from Present().
void BeginPresent() override {
VR_NotifyPresentQueued();
}
// Render thread, after the present (or the skipped one).
void EndPresent() override {
VR_FinishFrame(engine_);
}
void LockQueue() override { VR_LockQueue(); }
void UnlockQueue() override { VR_UnlockQueue(); }
uint32_t GetImageCount() const override { return fb_->TextureSwapChainLength; }
VkImage GetImage(uint32_t index) const override { return (VkImage)ovrFramebuffer_GetVulkanImage(fb_, index); }
VkExtent2D GetExtent() const override { return VkExtent2D{ (uint32_t)fb_->Width, (uint32_t)fb_->Height }; }
VkFormat GetFormat() const override { return ToUnormFormat((VkFormat)fb_->SwapchainFormat); }
uint32_t GetImageLayers() const override { return (uint32_t)fb_->ArraySize; }
// What OpenXR expects a released color image to be in.
VkImageLayout GetPresentLayout() const override { return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; }
private:
engine_t *engine_ = nullptr;
ovrFramebuffer *fb_ = nullptr;
};
std::unique_ptr<VulkanPresentation> VR_CreateVulkanPresentation(VulkanContext *vulkan, std::string *error) {
if (!CreateSession(vulkan, error)) {
return nullptr;
}
auto presentation = std::make_unique<OpenXRVulkanPresentation>();
if (!presentation->Create()) {
presentation->Destroy(vulkan);
*error = "Failed to create the XR swapchain";
return nullptr;
}
return presentation;
}
void VR_DestroyVulkanSession() {
engine_t *engine = VR_GetEngine();
VR_LeaveVR(engine);
engine->appState.VulkanBinding = {};
VR_SetPlatformFLag(VR_PLATFORM_RENDERER_VULKAN, false);
}
#else
bool VR_VulkanSupported() {
return false;
}
bool VR_VulkanUnsupported() {
return true;
}
std::vector<std::string> VR_GetVulkanInstanceExtensions() {
return {};
}
const std::vector<const char *> &VR_GetVulkanDeviceExtensions() {
static const std::vector<const char *> empty;
return empty;
}
int VR_GetVulkanPhysicalDevice(VulkanContext *vulkan) {
return -1;
}
std::unique_ptr<VulkanPresentation> VR_CreateVulkanPresentation(VulkanContext *vulkan, std::string *error) {
*error = "No OpenXR Vulkan support in this build";
return nullptr;
}
void VR_DestroyVulkanSession() {}
#endif
+47
View File
@@ -0,0 +1,47 @@
// Copyright (c) 2012- PPSSPP Project.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0 or later versions.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License 2.0 for more details.
// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/
// Official git repository and contact information can be found at
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
#pragma once
// OpenXR with a Vulkan session (XR_KHR_vulkan_enable). See docs/vr-openxr-vulkan.md.
#include <memory>
#include <string>
#include <vector>
class VulkanContext;
class VulkanPresentation;
// True if OpenXR is up and the runtime can take a Vulkan session.
bool VR_VulkanSupported();
// True if we know there will be no Vulkan session: OpenXR is up without it, or this build can't have one.
// Before OpenXR is up (the config is checked before it), false.
bool VR_VulkanUnsupported();
// What the runtime needs enabled on our VkInstance and VkDevice. The device list's strings stay valid.
std::vector<std::string> VR_GetVulkanInstanceExtensions();
const std::vector<const char *> &VR_GetVulkanDeviceExtensions();
// The physical device the headset is driven by, as an index for VulkanContext::CreateDevice. -1 if unknown.
int VR_GetVulkanPhysicalDevice(VulkanContext *vulkan);
// Creates the session the first time, then a presentation that renders into the XR swapchain.
// The device and graphics queue must exist.
std::unique_ptr<VulkanPresentation> VR_CreateVulkanPresentation(VulkanContext *vulkan, std::string *error);
// Before the device goes.
void VR_DestroyVulkanSession();
+2 -1
View File
@@ -610,7 +610,8 @@ const char * const vulkanDefaultBlacklist[] = {
static int DefaultGPUBackend() {
if (IsVREnabled()) {
return (int)GPUBackend::OPENGL;
// Falls back to OpenGL if the runtime can't take a Vulkan session (VulkanMayBeAvailable).
return (int)GPUBackend::VULKAN;
}
#if PPSSPP_PLATFORM(UWP)
+18 -4
View File
@@ -133,7 +133,23 @@ void RunGraphicsLoop(GraphicsContext *graphicsContext, Application *application,
if (!graphicsContext->NeedsSeparateEmuThread()) {
// The backend spawns its own render thread, so this thread is simply where emulation runs.
SetCurrentThreadName("EmuThread");
RunMainLoop(graphicsContext, application, frame);
if (!IsVREnabled()) {
RunMainLoop(graphicsContext, application, frame);
return;
}
// Vulkan VR. The frame begins here, so its view poses are there for the emulator's uniforms,
// and the render thread ends it once it's submitted. While the session is idle, nothing runs.
RunMainLoop(graphicsContext, application, [&](GraphicsContext *ctx) {
while (!StartVRRender()) {
if (shouldExit && shouldExit()) {
return false;
}
sleep_ms(16, "vr-session-idle");
}
const bool result = frame(ctx);
UpdateVRInput(g_Config.bHapticFeedback, g_display.dpi_scale_x, g_display.dpi_scale_y);
return result;
});
return;
}
@@ -149,9 +165,7 @@ void RunGraphicsLoop(GraphicsContext *graphicsContext, Application *application,
std::thread emuThread = EmuThread_Start(graphicsContext, application, frame);
if (IsVREnabled()) {
static bool vrFirstStart = true;
EnterVR(vrFirstStart);
vrFirstStart = false;
EnterVR();
}
// Normally ThreadFrame() returning false is what gets us out of here - the frame callback
+38 -2
View File
@@ -22,6 +22,7 @@
#include <cstring>
#include <memory>
#include "Common/GPU/thin3d.h"
#include "Common/GPU/ShaderWriter.h"
#include "Common/System/Display.h"
#include "Common/System/System.h"
@@ -598,6 +599,30 @@ void PresentationCommon::CreateDeviceObjects() {
texColor_ = CreatePipeline({ draw_->GetVshaderPreset(VS_TEXTURE_COLOR_2D), draw_->GetFshaderPreset(FS_TEXTURE_COLOR_2D) }, false, &vsTexColBufDesc);
texColorRBSwizzle_ = CreatePipeline({ draw_->GetVshaderPreset(VS_TEXTURE_COLOR_2D), draw_->GetFshaderPreset(FS_TEXTURE_COLOR_2D_RB_SWIZZLE) }, false, &vsTexColBufDesc);
texColorBlend_ = CreatePipeline({ draw_->GetVshaderPreset(VS_TEXTURE_COLOR_2D), draw_->GetFshaderPreset(FS_TEXTURE_COLOR_2D) }, false, &vsTexColBufDesc, true);
if (IsVREnabled() && lang_ == GLSL_VULKAN && draw_->GetDeviceCaps().multiViewSupported) {
// FS_TEXTURE_COLOR_2D, sampling the layer of the eye being drawn.
static const VaryingDef varyings[] = {
{ "vec4", "oColor0", SEM_COLOR0, 0, "lowp" },
{ "vec2", "oTexCoord0", SEM_TEXCOORD0, 1, "highp" },
};
static const SamplerDef samplers[] = {
{ 0, "tex", SamplerFlags::ARRAY_ON_VULKAN },
};
char code[2048];
ShaderWriter writer(code, draw_->GetShaderLanguageDesc(), ShaderStage::Fragment, Slice<const char *>::empty(), ShaderWriterFlags::FS_AUTO_STEREO);
writer.DeclareSamplers(samplers);
writer.BeginFSMain(Slice<UniformDef>::empty(), varyings);
writer.C("vec4 col = ");
writer.SampleTexture2D("tex", "oTexCoord0");
writer.C(" * oColor0;\n");
writer.C("col.rgb *= oColor0.a;\n");
writer.EndFSMain("col");
ShaderModule *fs = draw_->CreateShaderModule(ShaderStage::Fragment, lang_, (const uint8_t *)code, strlen(code), "present_stereo");
if (fs) {
texColorStereo_ = CreatePipeline({ draw_->GetVshaderPreset(VS_TEXTURE_COLOR_2D), fs }, false, &vsTexColBufDesc);
fs->Release();
}
}
overlayVdata_ = draw_->CreateBuffer(sizeof(Vertex) * 4, BufferUsageFlag::DYNAMIC | BufferUsageFlag::VERTEXDATA);
// Not resetting restorePostShader_: after a device loss, BeginFrame uses it to bring the post-shader back.
}
@@ -623,6 +648,7 @@ static void DoReleaseVector(std::vector<T *> &list) {
void PresentationCommon::DestroyDeviceObjects() {
DoRelease(texColor_);
DoRelease(texColorRBSwizzle_);
DoRelease(texColorStereo_);
DoRelease(texColorBlend_);
DoRelease(overlayVdata_);
DoRelease(overlayTexture_);
@@ -698,6 +724,10 @@ void PresentationCommon::SourceFramebuffer(Draw::Framebuffer *fb, int bufferWidt
srcHeight_ = bufferHeight;
}
bool PresentationCommon::UseVRStereoSource() const {
return texColorStereo_ && !srcTexture_ && srcFramebuffer_ && srcFramebuffer_->Layers() > 1;
}
// Return value is if stereo binding succeeded.
bool PresentationCommon::BindSource(int binding, bool bindStereo) {
if (srcTexture_) {
@@ -739,8 +769,10 @@ void PresentationCommon::RunPostshaderPasses(const DisplayLayoutConfig &config,
bool useNearest = flags & OutputFlags::NEAREST;
bool useStereo = gstate_c.Use(GPU_USE_SIMPLE_STEREO_PERSPECTIVE) && stereoPipeline_ != nullptr; // TODO: Also check that the backend has support for it.
// Post shaders output one layer, which would show the left eye's view to both.
const bool vrStereo = UseVRStereoSource();
const bool usePostShader = usePostShader_ && !useStereo && !(flags & (OutputFlags::RB_SWIZZLE | OutputFlags::NO_POST_SHADER));
const bool usePostShader = usePostShader_ && !useStereo && !vrStereo && !(flags & (OutputFlags::RB_SWIZZLE | OutputFlags::NO_POST_SHADER));
const bool isFinalAtOutputResolution = usePostShader && postShaderFramebuffers_.size() < postShaderPipelines_.size();
int lastWidth = srcWidth_;
int lastHeight = srcHeight_;
@@ -1032,8 +1064,9 @@ void PresentationCommon::DrawOverlay(const OverlayLayout &layout, const OutputPa
void PresentationCommon::CopyToOutput(const DisplayLayoutConfig &config) {
bool useNearest = outputFlags_ & OutputFlags::NEAREST;
bool useStereo = gstate_c.Use(GPU_USE_SIMPLE_STEREO_PERSPECTIVE) && stereoPipeline_ != nullptr; // TODO: Also check that the backend has support for it.
const bool vrStereo = UseVRStereoSource();
const bool usePostShader = usePostShader_ && !useStereo && !(outputFlags_ & (OutputFlags::RB_SWIZZLE | OutputFlags::NO_POST_SHADER));
const bool usePostShader = usePostShader_ && !useStereo && !vrStereo && !(outputFlags_ & (OutputFlags::RB_SWIZZLE | OutputFlags::NO_POST_SHADER));
const bool isFinalAtOutputResolution = usePostShader && postShaderFramebuffers_.size() < postShaderPipelines_.size();
int lastWidth = srcWidth_;
int lastHeight = srcHeight_;
@@ -1071,6 +1104,9 @@ void PresentationCommon::CopyToOutput(const DisplayLayoutConfig &config) {
draw_->BindPipeline(texColor_);
useStereo = false; // Otherwise we end up uploading the wrong uniforms
}
} else if (vrStereo) {
draw_->BindPipeline(texColorStereo_);
BindSource(0, true);
} else {
if (isFinalAtOutputResolution && previousFramebuffers_.empty()) {
pipeline = postShaderPipelines_.back();
+3
View File
@@ -193,6 +193,7 @@ protected:
Draw::ShaderModule *CompileShaderModule(ShaderStage stage, ShaderLanguage lang, const std::string &src, std::string *errorString) const;
Draw::Pipeline *CreatePipeline(std::vector<Draw::ShaderModule *> shaders, bool postShader, const UniformBufferDesc *uniformDesc, bool alphaBlend = false) const;
bool UseVRStereoSource() const;
bool CompilePostShader(const ShaderInfo *shaderInfo, Draw::Pipeline **outPipeline) const;
bool BuildPostShader(const DisplayLayoutConfig &config, const ShaderInfo *shaderInfo, const ShaderInfo *next, Draw::Pipeline **outPipeline);
bool AllocateFramebuffer(int w, int h);
@@ -209,6 +210,8 @@ protected:
Draw::DrawContext *draw_;
Draw::Pipeline *texColor_ = nullptr;
Draw::Pipeline *texColorRBSwizzle_ = nullptr;
// VR with a stereo (two-layer) source: each view of the multiview backbuffer samples its own layer.
Draw::Pipeline *texColorStereo_ = nullptr;
Draw::SamplerState *samplerNearest_ = nullptr;
Draw::SamplerState *samplerLinear_ = nullptr;
Draw::Buffer *vdata_ = nullptr;
+93
View File
@@ -9,6 +9,8 @@
#include "Common/Math/CrossSIMD.h"
#include "Common/Math/lin/vec3.h"
#include "Common/TimeUtil.h"
#include "Common/VR/PPSSPPVR.h"
#include "Core/Config.h"
#include "GPU/GPUState.h"
#include "GPU/Common/FramebufferManagerCommon.h"
#include "GPU/Common/GPUStateUtils.h"
@@ -180,6 +182,97 @@ void BaseUpdateUniforms(UB_VS_FS_Base *ub, uint64_t dirtyUniforms, bool useBuffe
}
}
bool GuessVRDrawingHUD(bool is2D, bool flatScreen) {
bool hud = true;
//HUD shouldn't be modified in nonVR mode
if (IsBigScreenVRMode()) hud = false;
//HUD can be disabled in settings
else if (!g_Config.bRescaleHUD) hud = false;
//HUD cannot be rendered in flatscreen
else if (flatScreen) hud = false;
//HUD has to be 2D
else if (!is2D) hud = false;
//HUD has to be blended
else if (!gstate.isAlphaBlendEnabled()) hud = false;
#ifdef __LIBRETRO__
// Untextured transition fades must cover the view, not be scaled with the HUD.
else if (!gstate.isTextureMapEnabled()) hud = false;
#endif
//HUD cannot be rendered with clear color mask
else if (gstate.isClearModeColorMask()) hud = false;
//HUD cannot be rendered with depth color mask
else if (gstate.isClearModeDepthMask()) hud = false;
//HUD texture has to contain alpha channel
else if (!gstate.isTextureAlphaUsed()) hud = false;
//HUD texture cannot be in 5551 format
else if (gstate.getTextureFormat() == GETextureFormat::GE_TFMT_5551) hud = false;
//HUD texture cannot be in CLUT16 format
else if (gstate.getTextureFormat() == GETextureFormat::GE_TFMT_CLUT16) hud = false;
//HUD texture cannot be in CLUT32 format
else if (gstate.getTextureFormat() == GETextureFormat::GE_TFMT_CLUT32) hud = false;
//HUD cannot have full texture alpha
else if (gstate_c.textureSolidAlpha && gstate.getTextureFormat() != GETextureFormat::GE_TFMT_CLUT4) hud = false;
//HUD must have full vertex alpha
else if (!gstate_c.vertexFullAlpha && gstate.getDepthTestFunction() == GE_COMP_NEVER) hud = false;
//HUD cannot render FB screenshot
else if (gstate_c.curTextureHeight % 68 <= 1) hud = false;
//HUD cannot be rendered with add function
else if (gstate.getTextureFunction() == GETexFunc::GE_TEXFUNC_ADD) hud = false;
//HUD cannot be rendered with replace function
else if (gstate.getTextureFunction() == GETexFunc::GE_TEXFUNC_REPLACE) hud = false;
//HUD cannot be rendered with full clear color mask
else if ((gstate.getClearModeColorMask() == 0xFFFFFF) && (gstate.getColorMask() == 0xFFFFFF)) hud = false;
return hud;
}
void VRUpdateUniforms(UB_VS_FS_Base *base, UB_VS_VR *vr, uint64_t dirtyUniforms) {
// Also counts the 3D draws that decide whether the scene is 3D, so once per draw.
const bool is2D = Is2DVRObject(gstate.projMatrix, gstate.isModeThrough());
const bool flatScreen = IsFlatVRScene();
if (GuessVRDrawingHUD(is2D, flatScreen)) {
float aspect = 480.0f / 272.0f * (IsImmersiveVRMode() ? 0.5f : 1.0f);
vr->scaleX = g_Config.fHeadUpDisplayScale * aspect;
vr->scaleY = g_Config.fHeadUpDisplayScale;
} else {
vr->scaleX = 1.0f;
vr->scaleY = 1.0f;
}
if (dirtyUniforms & DIRTY_FOGCOLOR) {
// For the skyplane hack's clear.
SetVRCompat(VR_COMPAT_FOG_COLOR, gstate.fogcolor);
}
// Every draw, not only when the game changes the matrices: the result also depends on whether this
// draw is 2D and on the head pose. GL gets away with dirty flags because its uniforms are per program
// (2D and 3D draws rarely share one), while this buffer is shared by all draws.
{
if (flatScreen || is2D) {
memcpy(vr->projLens, gstate.projMatrix, sizeof(vr->projLens));
} else {
UpdateVRProjection(gstate.projMatrix, vr->projLens);
}
UpdateVRParams(gstate.projMatrix);
}
{
float leftEyeView[16];
float rightEyeView[16];
ConvertMatrix4x3To4x4Transposed(leftEyeView, gstate.viewMatrix);
ConvertMatrix4x3To4x4Transposed(rightEyeView, gstate.viewMatrix);
if (!is2D) {
UpdateVRView(leftEyeView, rightEyeView);
}
// The head pose is a rotation and a translation, so the last row stays 0 0 0 1 and the
// first three are the 3x4 the shaders take.
memcpy(base->view, leftEyeView, sizeof(base->view));
memcpy(vr->viewRight, rightEyeView, sizeof(vr->viewRight));
}
}
void DirtyDepalIfPixelMappedChanged(bool pixelMapped) {
if (gstate_c.shaderDepalMode != ShaderDepalMode::OFF && pixelMapped != gstate_c.depalPixelMapped) {
gstate_c.Dirty(DIRTY_DEPAL);
+20
View File
@@ -104,9 +104,29 @@ R"( vec4 u_ambient;
vec3 u_lightspecular[4];
)";
// VR (GPU_USE_VIRTUAL_REALITY) on Vulkan. Pushed right after UB_VS_FS_Base, as the end of the
// vertex shader's base block, so other backends and non-VR drawing don't pay for it.
struct alignas(16) UB_VS_VR {
float projLens[16]; // The headset's projection, with the game's signs.
float viewRight[12]; // The right eye's view. The left eye's (or the only one) is in the base view.
float scaleX; float scaleY; float padding[2]; // HUD scaling.
};
static_assert(sizeof(UB_VS_VR) == 128);
static const char * const ub_vrStr =
R"( mat4 u_proj_lens;
mat3x4 u_viewR;
float u_scaleX; float u_scaleY; vec2 u_vrPadding;
)";
// useBufferedRendering is only used to determine the rotation uniform.
void BaseUpdateUniforms(UB_VS_FS_Base *ub, uint64_t dirtyUniforms, bool useBufferedRendering, bool pixelMapped);
void LightUpdateUniforms(UB_VS_Lights *ub, uint64_t dirtyUniforms);
// Call for every draw after BaseUpdateUniforms: the HUD guess depends on state that dirties nothing.
// Replaces the base view with the left eye's.
void VRUpdateUniforms(UB_VS_FS_Base *base, UB_VS_VR *vr, uint64_t dirtyUniforms);
// Whether a draw looks like part of the HUD, which VR scales down to keep in view.
bool GuessVRDrawingHUD(bool is2D, bool flatScreen);
uint32_t PackLightControlBits();
uint32_t PackDepalBits(bool pixelMapped);
+10 -13
View File
@@ -180,7 +180,7 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag
if (compat.shaderLanguage == GLSL_VULKAN) {
WRITE(p, "\n");
WRITE(p, "layout (std140, set = 0, binding = %d) uniform baseVars {\n%s};\n", DRAW_BINDING_DYNUBO_BASE, ub_baseStr);
WRITE(p, "layout (std140, set = 0, binding = %d) uniform baseVars {\n%s%s};\n", DRAW_BINDING_DYNUBO_BASE, ub_baseStr, gstate_c.Use(GPU_USE_VIRTUAL_REALITY) ? ub_vrStr : "");
if (enableLighting || doShadeMapping || readUnusedLights)
WRITE(p, "layout (std140, set = 0, binding = %d) uniform lightVars {\n%s};\n", DRAW_BINDING_DYNUBO_LIGHT, ub_vs_lightsStr);
@@ -544,8 +544,13 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag
}
}
WRITE(p, " vec4 viewPos = vec4(mul(vec4(worldpos, 1.0), u_view).xyz, 1.0);\n");
if (useSimpleStereo) {
if (useSimpleStereo && gstate_c.Use(GPU_USE_VIRTUAL_REALITY)) {
// Each eye's view comes from the headset (multiview, Vulkan).
WRITE(p, " vec4 viewPos = vec4(mul(vec4(worldpos, 1.0), gl_ViewIndex == 0 ? u_view : u_viewR).xyz, 1.0);\n");
} else {
WRITE(p, " vec4 viewPos = vec4(mul(vec4(worldpos, 1.0), u_view).xyz, 1.0);\n");
}
if (useSimpleStereo && !gstate_c.Use(GPU_USE_VIRTUAL_REALITY)) {
float ipd = 0.065f;
float scale = 1.0f;
if (PSP_CoreParameter().compat.vrCompat().UnitsPerMeter > 0) {
@@ -558,11 +563,10 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag
if (gstate_c.Use(GPU_USE_VIRTUAL_REALITY)) {
WRITE(p, " vec4 outPos = mul(u_proj_lens, viewPos);\n");
WRITE(p, " vec4 orgPos = mul(u_proj, viewPos);\n");
#ifdef __LIBRETRO__
// Preserve game depth before clipping and viewport conversion. The VR lens
// changes XY, but depth must still agree with through-mode draws and clears.
// changes XY, but depth must still agree with through-mode draws and clears,
// and go through the viewport's Z scale (often negative on the PSP).
WRITE(p, " outPos.z = orgPos.z * (outPos.w / orgPos.w);\n");
#endif
} else {
WRITE(p, " vec4 outPos = mul(u_proj, viewPos);\n");
}
@@ -1043,13 +1047,6 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag
WRITE(p, " %sgl_Position = outPos;\n", compat.vsOutPrefix);
if (gstate_c.Use(GPU_USE_VIRTUAL_REALITY)) {
#ifndef __LIBRETRO__
// Z correction for the depth buffer
if (useHWTransform) {
WRITE(p, " %sgl_Position.z = orgPos.z / abs(orgPos.w) * abs(outPos.w);\n", compat.vsOutPrefix);
}
#endif
// HUD scaling
WRITE(p, " %sgl_Position.x *= u_scaleX;\n", compat.vsOutPrefix);
WRITE(p, " %sgl_Position.y *= u_scaleY;\n", compat.vsOutPrefix);
-45
View File
@@ -301,51 +301,6 @@ static void SetMatrix4x3(GLRenderManager *render, GLint *uniform, const float *m
render->SetUniformM4x4(uniform, m4x4);
}
static inline bool GuessVRDrawingHUD(bool is2D, bool flatScreen) {
bool hud = true;
//HUD shouldn't be modified in nonVR mode
if (IsBigScreenVRMode()) hud = false;
//HUD can be disabled in settings
else if (!g_Config.bRescaleHUD) hud = false;
//HUD cannot be rendered in flatscreen
else if (flatScreen) hud = false;
//HUD has to be 2D
else if (!is2D) hud = false;
//HUD has to be blended
else if (!gstate.isAlphaBlendEnabled()) hud = false;
#ifdef __LIBRETRO__
// Untextured transition fades must cover the view, not be scaled with the HUD.
else if (!gstate.isTextureMapEnabled()) hud = false;
#endif
//HUD cannot be rendered with clear color mask
else if (gstate.isClearModeColorMask()) hud = false;
//HUD cannot be rendered with depth color mask
else if (gstate.isClearModeDepthMask()) hud = false;
//HUD texture has to contain alpha channel
else if (!gstate.isTextureAlphaUsed()) hud = false;
//HUD texture cannot be in 5551 format
else if (gstate.getTextureFormat() == GETextureFormat::GE_TFMT_5551) hud = false;
//HUD texture cannot be in CLUT16 format
else if (gstate.getTextureFormat() == GETextureFormat::GE_TFMT_CLUT16) hud = false;
//HUD texture cannot be in CLUT32 format
else if (gstate.getTextureFormat() == GETextureFormat::GE_TFMT_CLUT32) hud = false;
//HUD cannot have full texture alpha
else if (gstate_c.textureSolidAlpha && gstate.getTextureFormat() != GETextureFormat::GE_TFMT_CLUT4) hud = false;
//HUD must have full vertex alpha
else if (!gstate_c.vertexFullAlpha && gstate.getDepthTestFunction() == GE_COMP_NEVER) hud = false;
//HUD cannot render FB screenshot
else if (gstate_c.curTextureHeight % 68 <= 1) hud = false;
//HUD cannot be rendered with add function
else if (gstate.getTextureFunction() == GETexFunc::GE_TEXFUNC_ADD) hud = false;
//HUD cannot be rendered with replace function
else if (gstate.getTextureFunction() == GETexFunc::GE_TEXFUNC_REPLACE) hud = false;
//HUD cannot be rendered with full clear color mask
else if ((gstate.getClearModeColorMask() == 0xFFFFFF) && (gstate.getColorMask() == 0xFFFFFF)) hud = false;
return hud;
}
void LinkedShader::use(const ShaderID &VSID) const {
render_->BindProgram(program);
// Note that we no longer track attr masks here - we do it for the input layouts instead.
+2 -2
View File
@@ -394,7 +394,7 @@ void DrawEngineVulkan::Flush() {
descriptors[2].image.sampler = (boundDepal_ && boundDepalSmoothed_) ? samplerSecondaryLinear_ : samplerSecondaryNearest_;
descriptors[3].buffer.buffer = baseBuf;
descriptors[3].buffer.range = sizeof(UB_VS_FS_Base);
descriptors[3].buffer.range = ShaderManagerVulkan::BaseBufferSize();
descriptors[3].buffer.offset = 0;
descriptors[4].buffer.buffer = lightBuf;
@@ -553,7 +553,7 @@ void DrawEngineVulkan::Flush() {
descriptors[2].image.view = boundDepal_;
descriptors[2].image.sampler = (boundDepal_ && boundDepalSmoothed_) ? samplerSecondaryLinear_ : samplerSecondaryNearest_;
descriptors[3].buffer.buffer = baseBuf;
descriptors[3].buffer.range = sizeof(UB_VS_FS_Base);
descriptors[3].buffer.range = ShaderManagerVulkan::BaseBufferSize();
descriptors[3].buffer.offset = 0;
descriptors[4].buffer.buffer = lightBuf;
descriptors[4].buffer.range = sizeof(UB_VS_Lights);
+10 -1
View File
@@ -26,6 +26,7 @@
#include "Common/GPU/GraphicsContext.h"
#include "Common/StringUtils.h"
#include "Common/Data/Text/StringWriter.h"
#include "Common/VR/PPSSPPVR.h"
#include "Core/Config.h"
#include "Core/Reporting.h"
@@ -232,7 +233,15 @@ u32 GPU_Vulkan::CheckGPUFeatures() const {
}
}
if (g_Config.bStereoRendering && draw_->GetDeviceCaps().multiViewSupported) {
if (IsVREnabled() || g_Config.bForceVR) {
// bForceVR runs the VR shaders without a headset, for testing.
features |= GPU_USE_VIRTUAL_REALITY;
features &= ~GPU_USE_VS_RANGE_CULLING;
// Both eyes in one pass. The presentation copies each layer to its eye, so no stereo-to-mono shader.
if (IsVREnabled() && GetVRPassesCount() > 1 && draw_->GetDeviceCaps().multiViewSupported) {
features |= GPU_USE_SINGLE_PASS_STEREO;
}
} else if (g_Config.bStereoRendering && draw_->GetDeviceCaps().multiViewSupported) {
features |= GPU_USE_SINGLE_PASS_STEREO;
features |= GPU_USE_SIMPLE_STEREO_PERSPECTIVE;
}
+8
View File
@@ -19,6 +19,8 @@
//#define SHADERLOG
#endif
#include <cstddef>
#include "Common/LogReporting.h"
#include "Common/Profiler/Profiler.h"
#include "Common/GPU/thin3d.h"
@@ -176,6 +178,7 @@ ShaderManagerVulkan::ShaderManagerVulkan(Draw::DrawContext *draw)
_assert_(uniforms_);
static_assert(sizeof(uniforms_->ub_base) <= 512, "ub_base grew too big");
static_assert(offsetof(Uniforms, ub_vr) == sizeof(UB_VS_FS_Base), "ub_vr must follow ub_base");
static_assert(sizeof(uniforms_->ub_lights) <= 512, "ub_lights grew too big");
}
@@ -226,6 +229,11 @@ uint64_t ShaderManagerVulkan::UpdateUniforms(bool useBufferedRendering, bool pix
if (dirty & DIRTY_LIGHT_UNIFORMS)
LightUpdateUniforms(&uniforms_->ub_lights, dirty);
}
if (gstate_c.Use(GPU_USE_VIRTUAL_REALITY)) {
VRUpdateUniforms(&uniforms_->ub_base, &uniforms_->ub_vr, dirty);
// It rewrote the view and the VR block for this draw, so the base buffer is pushed again.
dirty |= DIRTY_VIEWMATRIX;
}
gstate_c.CleanUniforms();
return dirty;
}
+6 -1
View File
@@ -92,6 +92,7 @@ protected:
struct Uniforms {
// Uniform block scratchpad. These (the relevant ones) are copied to the current pushbuffer at draw time.
UB_VS_FS_Base ub_base{};
UB_VS_VR ub_vr{}; // Right after ub_base, pushed with it in VR.
UB_VS_Lights ub_lights{};
};
@@ -126,7 +127,11 @@ public:
bool IsBoneDirty() { return true; }
uint32_t PushBaseBuffer(VulkanPushPool *dest, VkBuffer *buf) const {
return dest->Push(&uniforms_->ub_base, sizeof(uniforms_->ub_base), uboAlignment_, buf);
return dest->Push(&uniforms_->ub_base, BaseBufferSize(), uboAlignment_, buf);
}
// With VR, the base buffer has the VR uniforms at the end.
static uint32_t BaseBufferSize() {
return gstate_c.Use(GPU_USE_VIRTUAL_REALITY) ? (uint32_t)(sizeof(UB_VS_FS_Base) + sizeof(UB_VS_VR)) : (uint32_t)sizeof(UB_VS_FS_Base);
}
uint32_t PushLightBuffer(VulkanPushPool *dest, VkBuffer *buf) const {
return dest->Push(&uniforms_->ub_lights, sizeof(uniforms_->ub_lights), uboAlignment_, buf);
+7
View File
@@ -1405,6 +1405,13 @@ void NativeFrame(GraphicsContext *graphicsContext) {
runImDebugger(g_draw);
});
renderImDebugger(g_draw);
int cursorX, cursorY, cursorW, cursorH;
if (IsVREnabled() && GetVRMouseCursorRect(&cursorX, &cursorY, &cursorW, &cursorH)) {
UIContext *uiContext = g_screenManager->getUIContext();
uiContext->Begin();
uiContext->FillRect(UI::Drawable(0xFFFFFFFF), Bounds(cursorX * g_display.dpi_scale_x, cursorY * g_display.dpi_scale_y, cursorW * g_display.dpi_scale_x, cursorH * g_display.dpi_scale_y));
uiContext->Flush();
}
// Last, since the readback ends the backbuffer pass. Nothing can draw after it.
ScreenshotNotifyEndOfFrame(g_draw);
if (g_screenManager->getUIContext()->Text()) {
+2
View File
@@ -236,6 +236,7 @@
<ClInclude Include="..\..\Common\VR\VRInput.h" />
<ClInclude Include="..\..\Common\VR\VRMath.h" />
<ClInclude Include="..\..\Common\VR\VRRenderer.h" />
<ClInclude Include="..\..\Common\VR\VRVulkan.h" />
<ClInclude Include="..\..\Common\x64Analyzer.h" />
<ClInclude Include="..\..\Common\x64Emitter.h" />
<ClInclude Include="..\..\ext\aemu_postoffice\client\delay_impl.h" />
@@ -435,6 +436,7 @@
<ClCompile Include="..\..\Common\VR\VRInput.cpp" />
<ClCompile Include="..\..\Common\VR\VRMath.cpp" />
<ClCompile Include="..\..\Common\VR\VRRenderer.cpp" />
<ClCompile Include="..\..\Common\VR\VRVulkan.cpp" />
<ClCompile Include="..\..\Common\x64Analyzer.cpp" />
<ClCompile Include="..\..\Common\x64Emitter.cpp" />
<ClCompile Include="..\..\ext\aemu_postoffice\client\delay_impl_cpp.cpp" />
+6
View File
@@ -419,6 +419,9 @@
<ClCompile Include="..\..\Common\VR\VRRenderer.cpp">
<Filter>VR</Filter>
</ClCompile>
<ClCompile Include="..\..\Common\VR\VRVulkan.cpp">
<Filter>VR</Filter>
</ClCompile>
<ClCompile Include="..\..\Common\VR\OpenXRLoader.cpp">
<Filter>VR</Filter>
</ClCompile>
@@ -969,6 +972,9 @@
<ClInclude Include="..\..\Common\VR\VRRenderer.h">
<Filter>VR</Filter>
</ClInclude>
<ClInclude Include="..\..\Common\VR\VRVulkan.h">
<Filter>VR</Filter>
</ClInclude>
<ClInclude Include="..\..\Common\VR\OpenXRLoader.h">
<Filter>VR</Filter>
</ClInclude>
+2 -1
View File
@@ -291,7 +291,8 @@ VR_FILES := \
$(SRC)/Common/VR/VRFramebuffer.cpp \
$(SRC)/Common/VR/VRInput.cpp \
$(SRC)/Common/VR/VRMath.cpp \
$(SRC)/Common/VR/VRRenderer.cpp
$(SRC)/Common/VR/VRRenderer.cpp \
$(SRC)/Common/VR/VRVulkan.cpp
EXT_FILES := \
$(SRC)/ext/cityhash/city.cpp \
+13 -6
View File
@@ -793,6 +793,14 @@ extern "C" void Java_org_ppsspp_ppsspp_NativeApp_init
bFirstResume = true;
// Before the graphics context: Vulkan has to know what OpenXR needs from its instance and device,
// and VulkanMayBeAvailable whether the runtime takes a Vulkan session at all.
if (IsVREnabled()) {
Version gitVer(PPSSPP_GIT_VERSION);
InitVROnAndroid(gJvm, ppssppActivity, systemName.c_str(), gitVer.ToInteger(), "PPSSPP");
SetVRCallbacks(NativeAxis, NativeKey, NativeTouch);
}
// In debug mode, don't allow creating software Vulkan devices (reject by VulkanMaybeAvailable).
// Needed for #16931.
#ifdef NDEBUG
@@ -838,12 +846,6 @@ retry:
g_Config.iGPUBackend = (int)GPUBackend::OPENGL;
goto retry;
}
if (IsVREnabled()) {
Version gitVer(PPSSPP_GIT_VERSION);
InitVROnAndroid(gJvm, ppssppActivity, systemName.c_str(), gitVer.ToInteger(), "PPSSPP");
SetVRCallbacks(NativeAxis, NativeKey, NativeTouch);
}
}
extern "C" void Java_org_ppsspp_ppsspp_NativeApp_setAchievementsHostOverride(JNIEnv *env, jclass, jstring jhost) {
@@ -943,6 +945,11 @@ extern "C" void Java_org_ppsspp_ppsspp_NativeApp_shutdown(JNIEnv *, jclass) {
INFO_LOG(Log::G3D, "Not shutting down renderer - not initialized");
}
// The instance belongs to this activity. A restart (recreate) creates a new one in this process.
if (IsVREnabled()) {
ShutdownVR();
}
NativeShutdown();
g_VFS.Clear();
}
@@ -148,6 +148,8 @@ public class PpssppActivity extends AppCompatActivity implements SensorEventList
// This is to avoid losing the game/menu state etc when we are just
// switched-away from or rotated etc.
private boolean shuttingDown;
// Shutting down for a graphics restart (recreate), which comes back up in this process.
private boolean restarting;
// There's one render loop thread. Whether it runs, and on which activity's surface (activityNumber).
// surfaceChanged also fires for rotations and resizes, where the thread just keeps going.
@@ -1133,8 +1135,9 @@ public class PpssppActivity extends AppCompatActivity implements SensorEventList
Log.i(TAG, "in onDestroy, but not shutting down.");
}
}
// Really ugly workaround for VR issues when PPSSPP restarts
if (isVRDevice()) {
// Really ugly workaround for VR issues when PPSSPP restarts. A graphics restart is fine, since the
// native shutdown takes OpenXR down too and the new activity sets it up again.
if (isVRDevice() && !restarting) {
System.exit(0);
}
Log.i(TAG, "onDestroy end");
@@ -1942,6 +1945,7 @@ public class PpssppActivity extends AppCompatActivity implements SensorEventList
overrideShortcutParam = params;
}
shuttingDown = true;
restarting = true;
recreate();
return true;
} else if (command.equals("ask_permission") && params.equals("storage")) {
+125
View File
@@ -0,0 +1,125 @@
# OpenXR on Vulkan (design and status)
VR used to be OpenGL ES only: `Common/VR` creates the OpenXR session with an EGL binding, makes one
GL swapchain per eye, and `GLRenderManager` replays the whole frame once per eye, swapping
`u_view` per pass (`UNIFORMSTEREOMATRIX`). This moves it to Vulkan, where both eyes are drawn in one
pass with multiview (the existing "stereo rendering" path, `GPU_USE_SINGLE_PASS_STEREO`), and then to
PC VR, where the desktop window stays the primary swapchain and the headset is a second output.
## Phase 1: Quest (standalone Android) on Vulkan
### Instance, device, session
- `XR_KHR_vulkan_enable` (version 1: we create the `VkInstance`/`VkDevice` ourselves, which keeps
`VulkanContext` in charge). `VR_Init` enables it next to the GLES binding when the runtime has
it, so the backend can be chosen later.
- Before `vkCreateInstance`/`vkCreateDevice`, `VulkanContext` asks a hook for extra extensions
(`xrGetVulkanInstanceExtensionsKHR`, `xrGetVulkanDeviceExtensionsKHR`), and the physical device
is the one `xrGetVulkanGraphicsDeviceKHR` names.
- The session is created with `XrGraphicsBindingVulkanKHR` once the device exists (in
`VulkanGraphicsContext::InitSurface`), with our graphics queue family and index.
### Presenting: the XR swapchain is a `VulkanPresentation`
There's no Android window to present to in VR, so the main swapchain is replaced the same way
libretro and the offscreen mode replace it (`VulkanPresentation`):
- One XR swapchain, `arraySize = 2`. We write sRGB-encoded values and want them shown as they are.
On the Quest it's plain `R8G8B8A8_UNORM`, which its compositor shows as it is. The spec's way,
`R8G8B8A8_SRGB` with `XR_SWAPCHAIN_USAGE_MUTABLE_FORMAT_BIT` drawn through a UNORM view, makes the
Quest compositor show "snow" along edges (worst when it reprojects a late frame), with or without
the view formats listed through `XR_KHR_vulkan_swapchain_format_list`, and with clean
synchronization validation on our side.
- **The backbuffer pass is multiview** (view mask 0b11), always, in VR. The backbuffer views are
2D arrays, the depth buffer has two layers. Everything that draws to the backbuffer (UI,
presentation) is the same in both views unless its shader reads `gl_ViewIndex`. That costs a
second layer of fill for the menus, which is small next to the game, and means the backbuffer
render pass and all pipelines compiled against it never change with the VR mode.
- Presenting the game samples layer `gl_ViewIndex` of the game framebuffer when that has two
layers (stereo on), else layer 0.
- Compositor layers, as before: in a flat mode (menus, flat games) a cylinder layer showing layer 0
(mono) or one cylinder per eye on layers 0 and 1 (stereo); in a 6DoF mode, a projection layer with
one view per layer.
### Frame loop and threads
OpenXR wants `xrWaitFrame` → `xrBeginFrame` → acquire/wait/release → `xrEndFrame` per frame, with
`xrBeginFrame` of the next frame after `xrEndFrame` of this one. With Vulkan, NativeFrame runs on
the emu thread and the render manager's thread submits and presents:
- **Emu thread,** before NativeFrame (`StartVRRender`): wait for the previous frame's
`xrEndFrame`, then `xrWaitFrame`, `xrBeginFrame`, locate the views, sync input. The view poses
are then used for this frame's uniforms. While the session isn't running, skip the frame.
- **Render thread:** acquiring the backbuffer is `xrAcquireSwapchainImage` +
`xrWaitSwapchainImage`. Presenting releases it, then `xrEndFrame` with the layers. A frame that
never drew to the backbuffer ends with no layers, so the emu thread is never left waiting.
- The runtime may use the `VkQueue` inside `xrBeginFrame`, `xrEndFrame` and the swapchain calls, so
they and our submits take the presentation's queue lock.
This serializes the XR frames (the emu thread can't begin frame N+1 until frame N is submitted),
which is what the OpenGL path did too. Pipelining `xrWaitFrame` is a later optimization.
### Shaders
`GPU_USE_VIRTUAL_REALITY` on Vulkan. The base uniform buffer gets the VR fields at the end:
`u_proj_lens`, the right eye's view matrix and the HUD scale. The vertex shader picks the view
matrix by `gl_ViewIndex` when multiview is on, instead of the simple stereo's fixed IPD offset. The
HUD heuristics (`GuessVRDrawingHUD`, `Is2DVRObject`, `UpdateVRProjection`, `UpdateVRView`) move out
of `ShaderManagerGLES` so both backends use them.
In VR the view and lens matrices are recomputed and the base buffer re-uploaded on every draw. They
depend on whether the draw is 2D and on the head pose, neither of which sets a dirty flag. GL gets away
with dirty flags because its uniforms are per program (2D and 3D draws rarely share one). Recomputing
only on dirty split GTA's scene into two layers moving at different speeds.
### The OpenGL-only parts, and their Vulkan versions
OpenGL VR stays an option for a while. What it does its own way, and the Vulkan equivalent:
- **Skyplane** (`compatvr.ini`, the GTA Stories games): `PreprocessSkyplane` edits GL render steps at
replay, `PreprocessSkyplaneVulkan` does the same to Vulkan steps in `PreprocessSteps`, before
passes are merged. A pass that samples another framebuffer is left alone (GL: a
`BIND_FB_TEXTURE` command; Vulkan: a dependency on a framebuffer other than the target). The
frame's first other pass is cleared to the fog color (GL inserts a `CLEAR`; Vulkan turns the
load op into a clear, unless it clears already). Indexed draws with the depth test off are
dropped (GL tracks `DEPTH` commands; Vulkan reads the bound pipeline's depth state). GL resets
the once-per-frame clear per eye, Vulkan once per frame in `StartVRRender`.
- **Per-eye view matrices:** GL replays the frame per eye and `UNIFORMSTEREOMATRIX` picks the
eye's `u_view`. Vulkan has `u_viewR` in the VR block and picks by `gl_ViewIndex`.
- **The pointer:** a scissored GL clear after the frame. On Vulkan the UI draws it
(`GetVRMouseCursorRect`).
- **Alpha:** GL clears the eye buffers' alpha to 1 after the frame. Vulkan submits opaque layers instead.
- **`VRForce`** (developer setting, VR shaders without a headset) works on both.
The other VR compat flags (`ForceMono`, `ForceFlatScreen`, `IdentityViewHack`, `MirroringVariant`,
`ProjectionHack`, `UnitsPerMeter`) are read in shared code (`PPSSPPVR.cpp`, the shader generator),
so they don't depend on the backend.
### Fixes found on the headset
- **Depth** was inverted, on GL too: the shader replaced the lens projection's Z with the game's
(`orgPos`) at the very end, skipping the viewport's Z scale, which broke when the viewport transform
moved into the shader. It's replaced before the transform now (libretro already did this).
- **Gamma on GL:** the GL eye swapchains are `GL_SRGB8_ALPHA8`, and GLES encodes writes to an sRGB
framebuffer, so our already sRGB-encoded colors came out too bright. Writes skip the encoding now
(`GL_EXT_sRGB_write_control`).
- **The flat screen** stays upright. It used to take the head's pitch at recenter time, often looking
down while putting the headset on. Recentering is the system gesture (hold the Meta button).
- **Restarting** (changing the backend): the native shutdown takes OpenXR down (renderer, input,
session, instance, `ShutdownVR`), and the recreated activity sets it up again in the same process.
It used to `System.exit` in `onDestroy` instead, which killed the restart. Controller input is
created per session, since its spaces and attached action set belong to one.
## Phase 2: PC VR
The desktop window (Windows, then Linux) stays the primary swapchain and shows a mirror. The
headset is an extra output through the multi-swapchain API (`docs/multi-swapchain.md`): its pass
renders into the XR swapchain images, acquired with `xrAcquireSwapchainImage` instead of
`vkAcquireNextImageKHR`. The runtime paces the frame (`xrWaitFrame`), so the desktop swapchain
becomes the non-pacing one. The OpenXR loader on desktop is our dynamic one (`OpenXRLoader.cpp`).
## Status
- [x] Phase 1: runs on a Quest 2 (menus, Burnout Legends, GTA LCS in flat mode, stereo and 6DoF on)
at 72 fps, backend switching both ways. Skyplane not checked specifically yet.
- [ ] Phase 2
+2 -1
View File
@@ -544,7 +544,8 @@ SOURCES_CXX += \
$(COMMONDIR)/VR/VRMath.cpp \
$(COMMONDIR)/VR/VRFramebuffer.cpp \
$(COMMONDIR)/VR/VRInput.cpp \
$(COMMONDIR)/VR/VRRenderer.cpp
$(COMMONDIR)/VR/VRRenderer.cpp \
$(COMMONDIR)/VR/VRVulkan.cpp
SOURCES_C += \
$(COMMONDIR)/GPU/OpenGL/gl3stub.c
+16 -2
View File
@@ -360,7 +360,8 @@ const ShaderLanguage languages[] = {
};
const int numLanguages = ARRAY_SIZE(languages);
bool TestVertexShaders() {
// vr: GPU_USE_VIRTUAL_REALITY is set, which only the GLSL backends (OpenGL, Vulkan) use.
bool TestVertexShaders(bool vr) {
char *buffer[numLanguages];
for (int i = 0; i < numLanguages; i++) {
@@ -393,6 +394,10 @@ bool TestVertexShaders() {
std::string genErrorString[numLanguages];
for (int j = 0; j < numLanguages; j++) {
if (vr && languages[j] == ShaderLanguage::HLSL_D3D11) {
buffer[j][0] = '\0';
continue;
}
generateSuccess[j] = GenerateVShader(id, buffer[j], languages[j], bugs, &genErrorString[j]);
if (!genErrorString[j].empty()) {
if (g_testLog) {
@@ -538,7 +543,16 @@ bool TestShaderGenerators() {
return false;
}
if (!TestVertexShaders()) {
if (!TestVertexShaders(false)) {
return false;
}
// Again with the VR uniforms and the per-eye view (with VS_BIT_SIMPLE_STEREO on Vulkan).
const u32 oldFlags = gstate_c.GetUseFlags();
gstate_c.SetUseFlags(oldFlags | GPU_USE_VIRTUAL_REALITY);
const bool vrResult = TestVertexShaders(true);
gstate_c.SetUseFlags(oldFlags);
if (!vrResult) {
return false;
}