GEEKING

Rendering/GfxCore/D3D11/OpenVRD3D11.cpp

@@ -0,0 +1,270 @@
+#if !defined(RBX_PLATFORM_DURANGO) && !defined(RBX_PLATFORM_UWP)
+#include "DeviceD3D11.h"
+
+#include "FramebufferD3D11.h"
+
+#include "G3D/Quat.h"
+
+#include "rbx/Profiler.h"
+
+#include <d3d11.h>
+
+LOGGROUP(VR)
+
+FASTFLAGVARIABLE(OpenVR, true)
+
+#include "../Rendering/OpenVR/headers/openvr.h"
+
+using namespace vr;
+
+#define OVR_CHECK(call) \
+	do { \
+		int vrResult = call; \
+		if (vrResult) FASTLOG1(FLog::VR, "VR ERROR: " #call " returned %d", vrResult); \
+	} while (0)
+
+namespace RBX
+{
+namespace Graphics
+{
+	using G3D::Quat;
+	using G3D::Vector3;
+	using G3D::Matrix3;
+
+	typedef HRESULT (WINAPI *TypeCreateDXGIFactory)(REFIID riid, void **ppFactory);
+
+	static TypeCreateDXGIFactory getFactoryCreationFunction()
+    {
+        HMODULE module = LoadLibraryA("d3d11.dll");
+        if (!module) return NULL;
+
+		return (TypeCreateDXGIFactory)GetProcAddress(module, "CreateDXGIFactory");
+    }
+
+	template <typename F> static F getOpenVRFunction(const char* name)
+	{
+        HMODULE module = LoadLibraryA("openvr_api.dll");
+		if (!module) return NULL;
+
+		return F(GetProcAddress(module, name));
+	}
+
+	static IDXGIAdapter* getAdapterForIndex(int index)
+	{
+		TypeCreateDXGIFactory createFactory = getFactoryCreationFunction();
+		if (!createFactory)
+			return NULL;
+
+		// Try to find adapter by LUID
+		IDXGIFactory* factory = NULL;
+		if (FAILED(createFactory(__uuidof(IDXGIFactory), (void**)&factory)))
+			return NULL;
+
+		IDXGIAdapter* adapter = NULL;
+		factory->EnumAdapters(index, &adapter);
+
+		ReleaseCheck(factory);
+
+		return adapter;
+    }
+
+	static std::string getStringProperty(IVRSystem* system, TrackedDeviceIndex_t device, TrackedDeviceProperty property)
+	{
+		char buf[128] = {};
+		system->GetStringTrackedDeviceProperty(device, property, buf, sizeof(buf), NULL);
+
+		return buf;
+	}
+
+	static DeviceVR::Pose getPose(const TrackedDevicePose_t& pose)
+	{
+		const HmdMatrix34_t& m = pose.mDeviceToAbsoluteTracking;
+
+		Quat orientation(Matrix3(m.m[0][0], m.m[0][1], m.m[0][2], m.m[1][0], m.m[1][1], m.m[1][2], m.m[2][0], m.m[2][1], m.m[2][2]));
+
+		DeviceVR::Pose result = {};
+
+		result.valid = pose.bPoseIsValid;
+
+		result.position[0] = m.m[0][3];
+		result.position[1] = m.m[1][3];
+		result.position[2] = m.m[2][3];
+
+		result.orientation[0] = orientation.x;
+		result.orientation[1] = orientation.y;
+		result.orientation[2] = orientation.z;
+		result.orientation[3] = orientation.w;
+
+		return result;
+	}
+
+	static DeviceVR::Pose getPoseForIndex(IVRCompositor* compositor, TrackedDeviceIndex_t index)
+	{
+		TrackedDevicePose_t pose;
+		OVR_CHECK(compositor->GetLastPoseForTrackedDeviceIndex(index, &pose, NULL));
+
+		return getPose(pose);
+	}
+
+	static DeviceVR::Pose getPoseForRole(IVRSystem* system, IVRCompositor* compositor, ETrackedControllerRole role)
+	{
+		TrackedDeviceIndex_t index = system->GetTrackedDeviceIndexForControllerRole(role);
+		if (index == k_unTrackedDeviceIndexInvalid)
+			return DeviceVR::Pose();
+
+		return getPoseForIndex(compositor, index);
+	}
+
+	struct OpenVRD3D11: DeviceVRD3D11
+	{
+		IVRSystem* system;
+		IVRCompositor* compositor;
+
+		shared_ptr<Framebuffer> fb[2];
+		shared_ptr<Texture> textures[2];
+
+		OpenVRD3D11(): system(NULL), compositor(NULL)
+		{
+		}
+
+		~OpenVRD3D11()
+		{
+			auto VR_ShutdownInternal = getOpenVRFunction<void (*)()>("VR_ShutdownInternal");
+
+			if (VR_ShutdownInternal)
+				VR_ShutdownInternal();
+		}
+
+		void update() override
+		{
+			compositor->SetTrackingSpace(TrackingUniverseSeated);
+		}
+
+		void recenter() override
+		{
+			system->ResetSeatedZeroPose();
+		}
+
+		Framebuffer* getEyeFramebuffer(int eye) override
+		{
+			RBXASSERT(eye == 0 || eye == 1);
+
+			return fb[eye].get();
+		}
+
+		State getState() override
+		{
+			State result = {};
+
+			result.headPose = getPoseForIndex(compositor, k_unTrackedDeviceIndex_Hmd);
+			result.handPose[0] = getPoseForRole(system, compositor, TrackedControllerRole_LeftHand);
+			result.handPose[1] = getPoseForRole(system, compositor, TrackedControllerRole_RightHand);
+
+			for (int eye = 0; eye < 2; ++eye)
+			{
+				HmdMatrix34_t eyeToHead = system->GetEyeToHeadTransform(EVREye(eye));
+
+				result.eyeOffset[eye][0] = eyeToHead.m[0][3];
+				result.eyeOffset[eye][1] = eyeToHead.m[1][3];
+				result.eyeOffset[eye][2] = eyeToHead.m[2][3];
+
+				float upTan, downTan, leftTan, rightTan;
+				system->GetProjectionRaw(EVREye(eye), &leftTan, &rightTan, &upTan, &downTan);
+
+				result.eyeFov[eye][0] = -upTan;
+				result.eyeFov[eye][1] = downTan;
+				result.eyeFov[eye][2] = -leftTan;
+				result.eyeFov[eye][3] = rightTan;
+			}
+
+			result.needsMirror = true;
+
+			return result;
+		}
+
+		void submitFrame(DeviceContext* context) override
+		{
+			RBXPROFILER_SCOPE("VR", "submitFrame");
+
+			for (int eye = 0; eye < 2; ++eye)
+			{
+				Texture_t texture = { static_cast<TextureD3D11*>(textures[eye].get())->getObject(), API_DirectX, ColorSpace_Gamma };
+				OVR_CHECK(compositor->Submit(EVREye(eye), &texture));
+			}
+
+			OVR_CHECK(compositor->WaitGetPoses(NULL, 0, NULL, 0));
+		}
+
+		void setup(Device* device) override
+		{
+			unsigned int width, height;
+			system->GetRecommendedRenderTargetSize(&width, &height);
+
+			shared_ptr<Renderbuffer> depthStencil = device->createRenderbuffer(Texture::Format_D24S8, width, height, 1);
+
+			for (int eye = 0; eye < 2; ++eye)
+			{
+				textures[eye] = device->createTexture(Texture::Type_2D, Texture::Format_RGBA8, width, height, 1, 1, Texture::Usage_Renderbuffer);
+				fb[eye] = device->createFramebuffer(textures[eye]->getRenderbuffer(0, 0), depthStencil);
+			}
+		}
+	};
+
+	DeviceVRD3D11* DeviceVRD3D11::createOpenVR(IDXGIAdapter** outAdapter)
+	{
+		if (!FFlag::OpenVR)
+			return NULL;
+
+		auto VR_InitInternal = getOpenVRFunction<uint32_t (*)(EVRInitError *peError, EVRApplicationType eApplicationType)>("VR_InitInternal");
+		auto VR_ShutdownInternal = getOpenVRFunction<void (*)()>("VR_ShutdownInternal");
+		auto VR_GetGenericInterface = getOpenVRFunction<void* (*)(const char *pchInterfaceVersion, EVRInitError *peError)>("VR_GetGenericInterface");
+
+		if (!VR_InitInternal || !VR_ShutdownInternal || !VR_GetGenericInterface)
+			return NULL;
+
+		EVRInitError error;
+		VR_InitInternal(&error, VRApplication_Scene);
+
+		if (error)
+		{
+			FASTLOG1(FLog::VR, "VR: VR_InitInternal returned %d", error);
+			return NULL;
+		}
+
+		IVRSystem* system = static_cast<IVRSystem*>(VR_GetGenericInterface(IVRSystem_Version, &error));
+
+		if (!system)
+		{
+			FASTLOG1(FLog::VR, "VR: Error creating system: %d", error);
+			VR_ShutdownInternal();
+			return NULL;
+		}
+
+		IVRCompositor* compositor = static_cast<IVRCompositor*>(VR_GetGenericInterface(IVRCompositor_Version, &error));
+
+		if (!compositor)
+		{
+			FASTLOG1(FLog::VR, "VR: Error creating compositor: %d", error);
+			VR_ShutdownInternal();
+			return NULL;
+		}
+
+		int adapterIndex = 0;
+		system->GetDXGIOutputInfo(&adapterIndex);
+
+		OpenVRD3D11* vr = new OpenVRD3D11();
+
+		vr->system = system;
+		vr->compositor = compositor;
+
+		if (outAdapter)
+			*outAdapter = getAdapterForIndex(adapterIndex);
+
+		FASTLOGS(FLog::VR, "VR: Connected to %s", getStringProperty(system, k_unTrackedDeviceIndex_Hmd, Prop_ModelNumber_String));
+
+		return vr;
+	}
+
+}
+}
+#endif