OpenXR - Stereoscopic rendering

CMakeLists.txt

@@ -221,7 +221,9 @@ include_directories(ext/glslang)
 # Anyway, glew will be going away anyway.
 include_directories(ext/glew)
 
-if(NOT OPENGL_LIBRARIES AND USING_GLES2)
+if(OPENXR)
+	set(OPENGL_LIBRARIES GLESv3 EGL)
+elseif(NOT OPENGL_LIBRARIES AND USING_GLES2)
 	set(OPENGL_LIBRARIES GLESv2 EGL)
 endif()
 

Common/GPU/OpenGL/GLCommon.h

@@ -5,6 +5,9 @@
 #if PPSSPP_PLATFORM(IOS)
 #include <OpenGLES/ES3/gl.h>
 #include <OpenGLES/ES3/glext.h>
+#elif defined(OPEXR)
+#include <GLES3/gl3.h>
+#include <GLES3/gl3ext.h>
 #elif defined(USING_GLES2)
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>

Common/GPU/OpenGL/GLQueueRunner.cpp

@@ -110,6 +110,19 @@ static std::string GetInfoLog(GLuint name, Getiv getiv, GetLog getLog) {
 	return infoLog;
 }
 
+int GLQueueRunner::GetStereoBufferIndex(const char *uniformName) {
+	if (!uniformName) return -1;
+	else if (strcmp(uniformName, "u_view") == 0) return 0;
+	else if (strcmp(uniformName, "u_proj") == 0) return 1;
+	else return -1;
+}
+
+std::string GLQueueRunner::GetStereoBufferLayout(const char *uniformName) {
+	if (strcmp(uniformName, "u_view") == 0) return "ViewMatrices";
+	else if (strcmp(uniformName, "u_proj") == 0) return "ProjectionMatrix";
+	else return "undefined";
+}
+
 void GLQueueRunner::RunInitSteps(const std::vector<GLRInitStep> &steps, bool skipGLCalls) {
 	if (skipGLCalls) {
 		// Some bookkeeping still needs to be done.
@@ -263,7 +276,25 @@ void GLQueueRunner::RunInitSteps(const std::vector<GLRInitStep> &steps, bool ski
 			for (size_t j = 0; j < program->queries_.size(); j++) {
 				auto &query = program->queries_[j];
 				_dbg_assert_(query.name);
+#ifdef OPENXR
+				int location = -1;
+				int index = GetStereoBufferIndex(query.name);
+				if (index >= 0) {
+					std::string layout = GetStereoBufferLayout(query.name);
+					glUniformBlockBinding(program->program, glGetUniformBlockIndex(program->program, layout.c_str()), index);
+
+					GLuint buffer = 0;
+					glGenBuffers(1, &buffer);
+					glBindBuffer(GL_UNIFORM_BUFFER, buffer);
+					glBufferData(GL_UNIFORM_BUFFER,2 * 16 * sizeof(float),NULL, GL_STATIC_DRAW);
+					glBindBuffer(GL_UNIFORM_BUFFER, 0);
+					location = buffer;
+				} else {
+					location = glGetUniformLocation(program->program, query.name);
+				}
+#else
 				int location = glGetUniformLocation(program->program, query.name);
+#endif
 				if (location < 0 && query.required) {
 					WARN_LOG(G3D, "Required uniform query for '%s' failed", query.name);
 				}
@@ -995,6 +1026,24 @@ void GLQueueRunner::PerformRenderPass(const GLRStep &step, bool first, bool last
 			CHECK_GL_ERROR_IF_DEBUG();
 			break;
 		}
+#ifdef OPENXR
+		case GLRRenderCommand::UNIFORMSTEREOMATRIX:
+		{
+			_dbg_assert_(curProgram);
+			int layout = GetStereoBufferIndex(c.uniformMatrix4.name);
+			if (layout >= 0) {
+				int size = 2 * 16 * sizeof(float);
+				glBindBufferBase(GL_UNIFORM_BUFFER, layout, *c.uniformMatrix4.loc);
+				glBindBuffer(GL_UNIFORM_BUFFER, *c.uniformMatrix4.loc);
+				void *viewMatrices = glMapBufferRange(GL_UNIFORM_BUFFER, 0, size, GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
+				memcpy(viewMatrices, c.uniformMatrix4.m, size);
+				glUnmapBuffer(GL_UNIFORM_BUFFER);
+				glBindBuffer(GL_UNIFORM_BUFFER, 0);
+			}
+			CHECK_GL_ERROR_IF_DEBUG();
+			break;
+		}
+#endif
 		case GLRRenderCommand::UNIFORMMATRIX:
 		{
 			_dbg_assert_(curProgram);
@@ -1666,7 +1715,7 @@ void GLQueueRunner::fbo_unbind() {
 #endif
 
 #ifdef OPENXR
-	VR_BindFramebuffer(VR_GetEngine(), 0);
+	VR_BindFramebuffer(VR_GetEngine());
 #endif
 
 	currentDrawHandle_ = 0;

Common/GPU/OpenGL/GLQueueRunner.h

@@ -47,6 +47,7 @@ enum class GLRRenderCommand : uint8_t {
 	UNIFORM4UI,
 	UNIFORM4F,
 	UNIFORMMATRIX,
+	UNIFORMSTEREOMATRIX,
 	TEXTURESAMPLER,
 	TEXTURELOD,
 	VIEWPORT,
@@ -128,7 +129,7 @@ struct GLRRenderData {
 		struct {
 			const char *name;  // if null, use loc
 			const GLint *loc;
-			float m[16];
+			float m[32];
 		} uniformMatrix4;
 		struct {
 			uint32_t clearColor;
@@ -357,6 +358,9 @@ class GLQueueRunner {
 		caps_ = caps;
 	}
 
+	int GetStereoBufferIndex(const char *uniformName);
+	std::string GetStereoBufferLayout(const char *uniformName);
+
 	void RunInitSteps(const std::vector<GLRInitStep> &steps, bool skipGLCalls);
 
 	void RunSteps(const std::vector<GLRStep *> &steps, bool skipGLCalls);

Common/GPU/OpenGL/GLRenderManager.cpp

@@ -203,22 +203,6 @@ bool GLRenderManager::ThreadFrame() {
 	std::unique_lock<std::mutex> lock(mutex_);
 	if (!run_)
 		return false;
-#ifdef OPENXR
-	VR_BeginFrame(VR_GetEngine());
-
-	// Decide if the scene is 3D or not
-	if (g_Config.bEnableVR && !VR_GetConfig(VR_CONFIG_FORCE_2D) && (VR_GetConfig(VR_CONFIG_3D_GEOMETRY_COUNT) > 15)) {
-		VR_SetConfig(VR_CONFIG_MODE, VR_MODE_MONO_6DOF);
-	} else {
-		VR_SetConfig(VR_CONFIG_MODE, VR_MODE_FLAT_SCREEN);
-	}
-	VR_SetConfig(VR_CONFIG_3D_GEOMETRY_COUNT, VR_GetConfig(VR_CONFIG_3D_GEOMETRY_COUNT) / 2);
-
-	// Set customizations
-	VR_SetConfig(VR_CONFIG_6DOF_ENABLED, g_Config.bEnable6DoF);
-	VR_SetConfig(VR_CONFIG_CANVAS_DISTANCE, g_Config.iCanvasDistance);
-	VR_SetConfig(VR_CONFIG_FOV_SCALE, g_Config.iFieldOfViewPercentage);
-#endif
 
 	// In case of syncs or other partial completion, we keep going until we complete a frame.
 	do {
@@ -254,12 +238,33 @@ bool GLRenderManager::ThreadFrame() {
 			INFO_LOG(G3D, "Running first frame (%d)", threadFrame_);
 			firstFrame = false;
 		}
+
+#ifdef OPENXR
+		if (VR_BeginFrame(VR_GetEngine())) {
+
+			// Decide if the scene is 3D or not
+			if (g_Config.bEnableVR && !VR_GetConfig(VR_CONFIG_FORCE_2D) && (VR_GetConfig(VR_CONFIG_3D_GEOMETRY_COUNT) > 15)) {
+				VR_SetConfig(VR_CONFIG_MODE, g_Config.bEnableStereo ? VR_MODE_STEREO_6DOF : VR_MODE_MONO_6DOF);
+			} else {
+				VR_SetConfig(VR_CONFIG_MODE, VR_MODE_FLAT_SCREEN);
+			}
+			VR_SetConfig(VR_CONFIG_3D_GEOMETRY_COUNT, VR_GetConfig(VR_CONFIG_3D_GEOMETRY_COUNT) / 2);
+
+			// Set customizations
+			VR_SetConfig(VR_CONFIG_6DOF_ENABLED, g_Config.bEnable6DoF);
+			VR_SetConfig(VR_CONFIG_CANVAS_DISTANCE, g_Config.iCanvasDistance);
+			VR_SetConfig(VR_CONFIG_FOV_SCALE, g_Config.iFieldOfViewPercentage);
+
+			// Render scene
+			GL(Run(threadFrame_));
+			VR_EndFrame(VR_GetEngine());
+		}
+#else
 		Run(threadFrame_);
+#endif
 		VLOG("PULL: Finished frame %d", threadFrame_);
 	} while (!nextFrame);
-#ifdef OPENXR
-	VR_EndFrame(VR_GetEngine());
-#endif
+
 	return true;
 }
 

Common/GPU/OpenGL/GLRenderManager.h

@@ -743,6 +743,21 @@ class GLRenderManager {
 		curRenderStep_->commands.push_back(data);
 	}
 
+#ifdef OPENXR
+	void SetUniformM4x4Stereo(const char *name, const GLint *loc, const float *left, const float *right) {
+		_dbg_assert_(curRenderStep_ && curRenderStep_->stepType == GLRStepType::RENDER);
+#ifdef _DEBUG
+		_dbg_assert_(curProgram_);
+#endif
+		GLRRenderData data{ GLRRenderCommand::UNIFORMSTEREOMATRIX };
+		data.uniformMatrix4.name = name;
+		data.uniformMatrix4.loc = loc;
+		memcpy(&data.uniformMatrix4.m[0], left, sizeof(float) * 16);
+		memcpy(&data.uniformMatrix4.m[16], right, sizeof(float) * 16);
+		curRenderStep_->commands.push_back(data);
+	}
+#endif
+
 	void SetUniformM4x4(const char *name, const float *udata) {
 		_dbg_assert_(curRenderStep_ && curRenderStep_->stepType == GLRStepType::RENDER);
 #ifdef _DEBUG

Common/UI/UIScreen.cpp

@@ -94,7 +94,7 @@ void UIScreen::preRender() {
 	screenManager()->getUIContext()->BeginFrame();
 
 #ifdef OPENXR
-	VR_BindFramebuffer(VR_GetEngine(), 0);
+	VR_BindFramebuffer(VR_GetEngine());
 #endif
 
 	Draw::Viewport viewport;

Common/VR/VRBase.h

@@ -1,10 +1,155 @@
 #pragma once
 
-#include "VRFramebuffer.h"
+#ifdef ANDROID
+#include <android/log.h>
+#define ALOGE(...) __android_log_print(ANDROID_LOG_ERROR, "OpenXR", __VA_ARGS__);
+#define ALOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, "OpenXR", __VA_ARGS__);
+#else
+#define ALOGE(...) printf(__VA_ARGS__)
+#define ALOGV(...) printf(__VA_ARGS__)
+#endif
+
+//OpenXR
+#define XR_USE_PLATFORM_ANDROID 1
+#define XR_USE_GRAPHICS_API_OPENGL_ES 1
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <jni.h>
+#include <math.h>
+#include <openxr.h>
+#include <openxr_platform.h>
+#include <GLES3/gl3.h>
+#include <GLES3/gl3ext.h>
+
+#ifdef _DEBUG
+static const char* GlErrorString(GLenum error) {
+	switch (error) {
+		case GL_NO_ERROR:
+			return "GL_NO_ERROR";
+		case GL_INVALID_ENUM:
+			return "GL_INVALID_ENUM";
+		case GL_INVALID_VALUE:
+			return "GL_INVALID_VALUE";
+		case GL_INVALID_OPERATION:
+			return "GL_INVALID_OPERATION";
+		case GL_INVALID_FRAMEBUFFER_OPERATION:
+			return "GL_INVALID_FRAMEBUFFER_OPERATION";
+		case GL_OUT_OF_MEMORY:
+			return "GL_OUT_OF_MEMORY";
+		default:
+			return "unknown";
+	}
+}
+
+static void GLCheckErrors(char* file, int line) {
+	for (int i = 0; i < 10; i++) {
+		const GLenum error = glGetError();
+		if (error == GL_NO_ERROR) {
+			break;
+		}
+		ALOGE("GL error on line %s:%d %s", file, line, GlErrorString(error));
+	}
+}
+
+#define GL(func) func; GLCheckErrors(__FILE__ , __LINE__);
+#else
+#define GL(func) func;
+#endif
+
+#if defined(_DEBUG)
+static void OXR_CheckErrors(XrInstance instance, XrResult result, const char* function, bool failOnError) {
+	if (XR_FAILED(result)) {
+		char errorBuffer[XR_MAX_RESULT_STRING_SIZE];
+		xrResultToString(instance, result, errorBuffer);
+		if (failOnError) {
+			ALOGE("OpenXR error: %s: %s\n", function, errorBuffer);
+		} else {
+			ALOGV("OpenXR error: %s: %s\n", function, errorBuffer);
+		}
+	}
+}
+#define OXR(func) OXR_CheckErrors(VR_GetEngine()->appState.Instance, func, #func, true);
+#else
+#define OXR(func) func;
+#endif
+
+enum { ovrMaxLayerCount = 1 };
+enum { ovrMaxNumEyes = 2 };
+
+typedef union {
+	XrCompositionLayerProjection Projection;
+	XrCompositionLayerCylinderKHR Cylinder;
+} ovrCompositorLayer_Union;
+
+typedef struct {
+	XrSwapchain Handle;
+	uint32_t Width;
+	uint32_t Height;
+} ovrSwapChain;
+
+typedef struct {
+	int Width;
+	int Height;
+	uint32_t TextureSwapChainLength;
+	uint32_t TextureSwapChainIndex;
+	ovrSwapChain ColorSwapChain;
+	ovrSwapChain DepthSwapChain;
+	XrSwapchainImageOpenGLESKHR* ColorSwapChainImage;
+	XrSwapchainImageOpenGLESKHR* DepthSwapChainImage;
+	unsigned int* FrameBuffers;
+	bool Acquired;
+} ovrFramebuffer;
+
+typedef struct {
+	ovrFramebuffer FrameBuffer;
+} ovrRenderer;
+
+typedef struct {
+	int Focused;
+
+	XrInstance Instance;
+	XrSession Session;
+	XrViewConfigurationProperties ViewportConfig;
+	XrViewConfigurationView ViewConfigurationView[ovrMaxNumEyes];
+	XrSystemId SystemId;
+	XrSpace HeadSpace;
+	XrSpace StageSpace;
+	XrSpace FakeStageSpace;
+	XrSpace CurrentSpace;
+	int SessionActive;
+
+	int SwapInterval;
+	// These threads will be marked as performance threads.
+	int MainThreadTid;
+	int RenderThreadTid;
+	ovrCompositorLayer_Union Layers[ovrMaxLayerCount];
+	int LayerCount;
+
+	ovrRenderer Renderer;
+} ovrApp;
+
+typedef struct {
+	JavaVM* Vm;
+	jobject ActivityObject;
+	JNIEnv* Env;
+	char AppName[64];
+	int AppVersion;
+} ovrJava;
+
+typedef struct {
+	uint64_t frameIndex;
+	ovrApp appState;
+	ovrJava java;
+	float predictedDisplayTime;
+} engine_t;
 
 void VR_Init( ovrJava java );
 void VR_Destroy( engine_t* engine );
 void VR_EnterVR( engine_t* engine );
 void VR_LeaveVR( engine_t* engine );
 
 engine_t* VR_GetEngine( void );
+
+void ovrApp_Clear(ovrApp* app);
+void ovrApp_Destroy(ovrApp* app);
+int ovrApp_HandleXrEvents(ovrApp* app);