mirror of
https://github.com/hrydgard/ppsspp.git
synced 2026-11-16 11:03:45 +01:00
Merge pull request #22934 from hrydgard/vr-vulkan
VR: OpenXR on Vulkan, with single-pass stereo (Quest)
This commit is contained in:
47 files changed
+1300
-131
No files matched your search
@@ -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
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -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)) {
|
||||
|
||||
@@ -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_) {
|
||||
|
||||
@@ -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));
|
||||
|
||||
@@ -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;
|
||||
};
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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 &&
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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
@@ -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();
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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
@@ -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));
|
||||
|
||||
@@ -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);
|
||||
@@ -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
|
||||
|
||||
@@ -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
@@ -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 ) {
|
||||
|
||||
@@ -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();
|
||||
@@ -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
|
||||
@@ -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
@@ -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
@@ -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
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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()) {
|
||||
|
||||
@@ -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" />
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -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 \
|
||||
|
||||
@@ -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")) {
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
Reference in new issue
Block a user