#include "plugin.h"
static plugfsfuncs_t *fsfuncs;
static pluginputfuncs_t *inputfuncs;

#include "../engine/client/vr.h"

//#define XR_NO_PROTOTYPES

//figure out which platforms(read: windowing apis) we need...
#if defined(_WIN32)
	#define XR_USE_PLATFORM_WIN32
//#elif defined(ANDROID)
//	#define XR_USE_PLATFORM_ANDROID
#else
	#ifndef NO_X11
		#define XR_USE_PLATFORM_XLIB
	#endif
	#if defined(GLQUAKE) && defined(USE_EGL)
		//wayland, android, and x11-egl can all just use the EGL path...
		//at least once the openxr spec gets fixed (the wayland extension is apparently basically unusable)
		//note: XR_MND_egl_enable is a vendor extension to work around openxr stupidly trying to ignore it entirely.
		#define XR_USE_PLATFORM_EGL
	#endif
#endif

//figure out which graphics apis we need...
#ifdef GLQUAKE
	#define XR_USE_GRAPHICS_API_OPENGL
#endif
#ifdef VKQUAKE
	#define XR_USE_GRAPHICS_API_VULKAN
#endif
#ifdef D3D11QUAKE
	#ifdef _WIN32
		#define XR_USE_GRAPHICS_API_D3D11
	#endif
#endif

//include any headers we need for things to make sense.
#ifdef XR_USE_GRAPHICS_API_OPENGL
	#include "glquake.h"
#endif
#ifdef XR_USE_GRAPHICS_API_VULKAN
	#include "../engine/vk/vkrenderer.h"
#endif
#ifdef XR_USE_GRAPHICS_API_D3D11
	#include <d3d11.h>
#endif
#ifdef XR_USE_PLATFORM_EGL
	#include "gl_videgl.h"
#endif
#ifdef XR_USE_PLATFORM_XLIB
	#include <GL/glx.h>
#endif

//and finally include openxr stuff now that its hopefully not going to fail about missing typedefs.
#include <openxr/openxr_platform.h>
#if XR_CURRENT_API_VERSION < XR_MAKE_VERSION(1, 0, 16)
#define XR_ERROR_RUNTIME_UNAVAILABLE -51	//available starting 1.0.16
#endif

#ifdef XR_NO_PROTOTYPES
#define XRFUNCS		\
		XRFUNC(xrGetInstanceProcAddr)	\
		XRFUNC(xrResultToString)	\
		XRFUNC(xrEnumerateApiLayerProperties) \
		XRFUNC(xrEnumerateInstanceExtensionProperties)	\
		XRFUNC(xrCreateInstance)	\
		XRFUNC(xrGetInstanceProperties)	\
		XRFUNC(xrGetSystem)	\
		XRFUNC(xrGetSystemProperties)	\
		XRFUNC(xrEnumerateViewConfigurations) \
		XRFUNC(xrEnumerateViewConfigurationViews)	\
		XRFUNC(xrCreateSession)	\
		XRFUNC(xrCreateReferenceSpace)	\
		XRFUNC(xrCreateActionSet)	\
		XRFUNC(xrStringToPath)	\
		XRFUNC(xrCreateAction)	\
		XRFUNC(xrSuggestInteractionProfileBindings)	\
		XRFUNC(xrCreateActionSpace)	\
		XRFUNC(xrAttachSessionActionSets)	\
		XRFUNC(xrSyncActions)	\
		XRFUNC(xrGetActionStatePose)	\
		XRFUNC(xrApplyHapticFeedback)	\
		XRFUNC(xrLocateSpace)	\
		XRFUNC(xrGetActionStateBoolean)	\
		XRFUNC(xrGetActionStateFloat)	\
		XRFUNC(xrGetActionStateVector2f)	\
		XRFUNC(xrGetCurrentInteractionProfile)	\
		XRFUNC(xrEnumerateBoundSourcesForAction)	\
		XRFUNC(xrGetInputSourceLocalizedName)	\
		XRFUNC(xrPathToString)	\
		XRFUNC(xrCreateSwapchain)	\
		XRFUNC(xrEnumerateSwapchainFormats)	\
		XRFUNC(xrEnumerateSwapchainImages)	\
		XRFUNC(xrPollEvent)	\
		XRFUNC(xrBeginSession)	\
		XRFUNC(xrWaitFrame)	\
		XRFUNC(xrBeginFrame)	\
		XRFUNC(xrLocateViews)	\
		XRFUNC(xrAcquireSwapchainImage)	\
		XRFUNC(xrWaitSwapchainImage)	\
		XRFUNC(xrReleaseSwapchainImage)	\
		XRFUNC(xrEndFrame)	\
		XRFUNC(xrRequestExitSession)	\
		XRFUNC(xrEndSession)	\
		XRFUNC(xrDestroySwapchain)	\
		XRFUNC(xrDestroySpace)	\
		XRFUNC(xrDestroySession)	\
		XRFUNC(xrDestroyInstance)
#define XRFUNC(n) static PFN_##n n;
XRFUNCS
#undef XRFUNC
#endif

#ifdef XR_EXT_hand_tracking
static PFN_xrCreateHandTrackerEXT	xrCreateHandTrackerEXT;
static PFN_xrLocateHandJointsEXT	xrLocateHandJointsEXT;
static PFN_xrDestroyHandTrackerEXT	xrDestroyHandTrackerEXT;
#endif


#ifdef SVNREVISION
	#define APPLICATIONVERSION atoi(STRINGIFY(SVNREVISION))
	#define ENGINEVERSION atoi(STRINGIFY(SVNREVISION))
#else
	#define APPLICATIONVERSION 0
	#define ENGINEVERSION 0
#endif

static cvar_t *xr_enable;
static cvar_t *xr_debug;
static cvar_t *xr_formfactor;
static cvar_t *xr_viewconfig;
static cvar_t *xr_metresize;
static cvar_t *xr_skipregularview;
static cvar_t *xr_fingertracking;

static void XR_SetupInputs_Instance(void);

#define METRES_TO_QUAKE(x) ((x)*xr_metresize->value)
#define QUAKE_TO_METRES(x) ((x)/xr_metresize->value)

#define SECONDS_TO_NANOSECONDS(x) ((x)*1000000000)
#define NANOSECONDS_TO_SECONDS(x) ((x)/1000000000.0)

static void XR_PoseToAngOrg(const XrPosef *pose, vec3_t ang, vec3_t org)
{
	XrQuaternionf q = pose->orientation;
    const float sqw = q.w * q.w;
    const float sqx = q.x * q.x;
    const float sqy = q.y * q.y;
    const float sqz = q.z * q.z;

    ang[PITCH] = -asin(-2 * (q.y * q.z - q.w * q.x)) * (180/M_PI);
    ang[YAW] = atan2(2 * (q.x * q.z + q.w * q.y), sqw - sqx - sqy + sqz) * (180/M_PI);
    ang[ROLL] = -atan2(2 * (q.x * q.y + q.w * q.z), sqw - sqx + sqy - sqz) * (180/M_PI);

#if 1
	org[0]  =     METRES_TO_QUAKE(-pose->position.z);
	org[1]  =     METRES_TO_QUAKE(-pose->position.x);
	org[2]  =     METRES_TO_QUAKE(pose->position.y);
#else
	org[0]  =     METRES_TO_QUAKE(pose->position.x);
	org[1]  =     METRES_TO_QUAKE(pose->position.y);
	org[2]  =     METRES_TO_QUAKE(pose->position.z);
#endif
}

enum actset_e
{
	AS_COMMON,
	AS_MENU,
	AS_GAME,
	MAX_ACTIONSETS
};

static struct
{
//instance state (in case we want to start up)
	XrInstance instance;	//loader context
	XrSystemId systemid;	//device type thingie we're going for
#define MAX_VIEW_COUNT 12	//kinda abusive, but that's VR for you.
	unsigned int viewcount;
	XrViewConfigurationView *views;
	XrViewConfigurationType viewtype;

//engine context info (for restarting sessions)
	int renderer;			//rendering api we're using
	void *bindinginfo;		//appropriate XrGraphicsBinding*KHR struct so we can restart sessions.

//session state
	XrSession session;		//driver context
	XrSessionState state;
	qboolean beginning;
	qboolean ending;
	XrSpace space;
	struct
	{	//basically just swapchain state.
		XrSwapchain swapchain;
		unsigned int numswapimages;
		XrSwapchainSubImage subimage;
		image_t *swapimages;
	} eye[MAX_VIEW_COUNT];	//note that eye is a vauge term.

	XrActiveActionSet actionset[MAX_ACTIONSETS];

	qboolean timeknown;
	XrTime time;
	XrFrameState framestate;
	qboolean needrender;	//we MUST call xrBegin before the next xrWait
	int srgb;	//<0 = gamma-only. 0 = no srgb at all, >0 full srgb, including textures and stuff
	int colourformat;

	unsigned int numactions;
	unsigned int maxactions;
	struct
	{
		enum actset_e set;
		XrActionType acttype;
		const char *actname;		//doubles up as command names for buttons
		const char *actdescription;	//user-visible string (exposed via openxr runtime somehow)
		const char *subactionpath;	//somethingblahblah

		XrAction	action;	//for querying.
		XrPath		path;	//for querying.
		XrSpace		space;	//for poses.
		qboolean	held;	//for buttons.
	} *actions;
	qboolean inputsdirty;	//mostly for printing them.

#ifdef XR_EXT_hand_tracking
	struct
	{
		XrHandTrackerEXT handle;
		qboolean active;
		XrHandJointLocationEXT jointloc[XR_HAND_JOINT_COUNT_EXT];
		XrHandJointVelocityEXT jointvel[XR_HAND_JOINT_COUNT_EXT];
	} hand[2];
#endif
} xr;

static qboolean QDECL XR_PluginMayUnload(void)
{
	if (xr.instance)
		return false;	//something is still using us... don't let our code go away.
	return true;
}
static void XR_SessionEnded(void)
{
	size_t u;
	if (xr.space)
	{
		xrDestroySpace(xr.space);
		xr.space = XR_NULL_HANDLE;
	}

	for (u = 0; u < countof(xr.eye); u++)
	{
		free(xr.eye[u].swapimages);
		xr.eye[u].swapimages = NULL;
		xr.eye[u].numswapimages = 0;
		if (xr.eye[u].swapchain)
		{
			xrDestroySwapchain(xr.eye[u].swapchain);
			xr.eye[u].swapchain = XR_NULL_HANDLE;
		}
	}

#ifdef XR_EXT_hand_tracking
	for (u = 0; u < countof(xr.hand); u++)
	{
		if (xr.hand[u].handle)
			xrDestroyHandTrackerEXT(xr.hand[u].handle);
		xr.hand[u].handle = XR_NULL_HANDLE;
		xr.hand[u].active = false;
	}
#endif

	if (xr.session)
	{
		xrDestroySession(xr.session);
		xr.session = XR_NULL_HANDLE;
	}
	xr.state = XR_SESSION_STATE_UNKNOWN;
	xr.beginning = false;
}
static void XR_Shutdown(void)
{	//called on any kind of failure
	XR_SessionEnded();

	free(xr.bindinginfo);
	free(xr.views);
	if (xr.instance)
		xrDestroyInstance(xr.instance);

	memset(&xr, 0, sizeof(xr));
}

static const char *XR_StringForResult(XrResult res)
{
#if 0
	//this is a bit of a joke really. xrResultToString requires a valid instance so is unusable for printing out the various reasons why we might fail to create an instance.
	static char buffer[XR_MAX_RESULT_STRING_SIZE];
	if (XR_SUCCEEDED(res=xrResultToString(xr.instance, res, buffer)))
		return buffer;
	return va("XrResult %i", res);
#else
	switch(res)
	{
	case XR_SUCCESS: return "XR_SUCCESS";
	case XR_TIMEOUT_EXPIRED: return "XR_TIMEOUT_EXPIRED";
	case XR_SESSION_LOSS_PENDING: return "XR_SESSION_LOSS_PENDING";
	case XR_EVENT_UNAVAILABLE: return "XR_EVENT_UNAVAILABLE";
	case XR_SPACE_BOUNDS_UNAVAILABLE: return "XR_SPACE_BOUNDS_UNAVAILABLE";
	case XR_SESSION_NOT_FOCUSED: return "XR_SESSION_NOT_FOCUSED";
	case XR_FRAME_DISCARDED: return "XR_FRAME_DISCARDED";
	case XR_ERROR_VALIDATION_FAILURE: return "XR_ERROR_VALIDATION_FAILURE";
	case XR_ERROR_RUNTIME_FAILURE: return "XR_ERROR_RUNTIME_FAILURE";
	case XR_ERROR_OUT_OF_MEMORY: return "XR_ERROR_OUT_OF_MEMORY";
	case XR_ERROR_API_VERSION_UNSUPPORTED: return "XR_ERROR_API_VERSION_UNSUPPORTED";
	case XR_ERROR_INITIALIZATION_FAILED: return "XR_ERROR_INITIALIZATION_FAILED";
	case XR_ERROR_FUNCTION_UNSUPPORTED: return "XR_ERROR_FUNCTION_UNSUPPORTED";
	case XR_ERROR_FEATURE_UNSUPPORTED: return "XR_ERROR_FEATURE_UNSUPPORTED";
	case XR_ERROR_EXTENSION_NOT_PRESENT: return "XR_ERROR_EXTENSION_NOT_PRESENT";
	case XR_ERROR_LIMIT_REACHED: return "XR_ERROR_LIMIT_REACHED";
	case XR_ERROR_SIZE_INSUFFICIENT: return "XR_ERROR_SIZE_INSUFFICIENT";
	case XR_ERROR_HANDLE_INVALID: return "XR_ERROR_HANDLE_INVALID";
	case XR_ERROR_INSTANCE_LOST: return "XR_ERROR_INSTANCE_LOST";
	case XR_ERROR_SESSION_RUNNING: return "XR_ERROR_SESSION_RUNNING";
	case XR_ERROR_SESSION_NOT_RUNNING: return "XR_ERROR_SESSION_NOT_RUNNING";
	case XR_ERROR_SESSION_LOST: return "XR_ERROR_SESSION_LOST";
	case XR_ERROR_SYSTEM_INVALID: return "XR_ERROR_SYSTEM_INVALID";
	case XR_ERROR_PATH_INVALID: return "XR_ERROR_PATH_INVALID";
	case XR_ERROR_PATH_COUNT_EXCEEDED: return "XR_ERROR_PATH_COUNT_EXCEEDED";
	case XR_ERROR_PATH_FORMAT_INVALID: return "XR_ERROR_PATH_FORMAT_INVALID";
	case XR_ERROR_PATH_UNSUPPORTED: return "XR_ERROR_PATH_UNSUPPORTED";
	case XR_ERROR_LAYER_INVALID: return "XR_ERROR_LAYER_INVALID";
	case XR_ERROR_LAYER_LIMIT_EXCEEDED: return "XR_ERROR_LAYER_LIMIT_EXCEEDED";
	case XR_ERROR_SWAPCHAIN_RECT_INVALID: return "XR_ERROR_SWAPCHAIN_RECT_INVALID";
	case XR_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED: return "XR_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED";
	case XR_ERROR_ACTION_TYPE_MISMATCH: return "XR_ERROR_ACTION_TYPE_MISMATCH";
	case XR_ERROR_SESSION_NOT_READY: return "XR_ERROR_SESSION_NOT_READY";
	case XR_ERROR_SESSION_NOT_STOPPING: return "XR_ERROR_SESSION_NOT_STOPPING";
	case XR_ERROR_TIME_INVALID: return "XR_ERROR_TIME_INVALID";
	case XR_ERROR_REFERENCE_SPACE_UNSUPPORTED: return "XR_ERROR_REFERENCE_SPACE_UNSUPPORTED";
	case XR_ERROR_FILE_ACCESS_ERROR: return "XR_ERROR_FILE_ACCESS_ERROR";
	case XR_ERROR_FILE_CONTENTS_INVALID: return "XR_ERROR_FILE_CONTENTS_INVALID";
	case XR_ERROR_FORM_FACTOR_UNSUPPORTED: return "XR_ERROR_FORM_FACTOR_UNSUPPORTED";
	case XR_ERROR_FORM_FACTOR_UNAVAILABLE: return "XR_ERROR_FORM_FACTOR_UNAVAILABLE";
	case XR_ERROR_API_LAYER_NOT_PRESENT: return "XR_ERROR_API_LAYER_NOT_PRESENT";
	case XR_ERROR_CALL_ORDER_INVALID: return "XR_ERROR_CALL_ORDER_INVALID";
	case XR_ERROR_GRAPHICS_DEVICE_INVALID: return "XR_ERROR_GRAPHICS_DEVICE_INVALID";
	case XR_ERROR_POSE_INVALID: return "XR_ERROR_POSE_INVALID";
	case XR_ERROR_INDEX_OUT_OF_RANGE: return "XR_ERROR_INDEX_OUT_OF_RANGE";
	case XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED: return "XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED";
	case XR_ERROR_ENVIRONMENT_BLEND_MODE_UNSUPPORTED: return "XR_ERROR_ENVIRONMENT_BLEND_MODE_UNSUPPORTED";
	case XR_ERROR_NAME_DUPLICATED: return "XR_ERROR_NAME_DUPLICATED";
	case XR_ERROR_NAME_INVALID: return "XR_ERROR_NAME_INVALID";
	case XR_ERROR_ACTIONSET_NOT_ATTACHED: return "XR_ERROR_ACTIONSET_NOT_ATTACHED";
	case XR_ERROR_ACTIONSETS_ALREADY_ATTACHED: return "XR_ERROR_ACTIONSETS_ALREADY_ATTACHED";
	case XR_ERROR_LOCALIZED_NAME_DUPLICATED: return "XR_ERROR_LOCALIZED_NAME_DUPLICATED";
	case XR_ERROR_LOCALIZED_NAME_INVALID: return "XR_ERROR_LOCALIZED_NAME_INVALID";
//	case XR_ERROR_RUNTIME_UNAVAILABLE: return "XR_ERROR_RUNTIME_UNAVAILABLE";
	default:
		return va("XrResult %i", res);
	}
#endif
}


static XrBool32 XRAPI_CALL XR_DebugPrint(XrDebugUtilsMessageSeverityFlagsEXT messageSeverity, XrDebugUtilsMessageTypeFlagsEXT messageTypes, const XrDebugUtilsMessengerCallbackDataEXT *callbackData, void *userData)
{
	char *sev;
	switch(messageSeverity)
	{
	case 1/*XR_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT*/:		sev = "^8";			break;
	case 16/*XR_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT*/:		sev = "";			break;
	case 256/*XR_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT*/:	sev = CON_WARNING;	break;
	default:
	case 4096/*XR_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT*/:		sev = CON_ERROR;	break;
	}

	Con_Printf("%s%s: %s\n", sev, callbackData->functionName, callbackData->message);
	return XR_FALSE;
}

static qboolean XR_PreInit(vrsetup_t *qreqs)
{
	XrResult res;
	const char *xrexts[8], *ext;
	const char *xrlayers[8];
	uint32_t numext = 0, numlayers = 0;
	qboolean havedebugutils = false;
#ifdef XR_EXT_hand_tracking
	qboolean havehandtrack = false;
#endif

	XR_Shutdown();	//just in case...

	if (qreqs->structsize != sizeof(*qreqs) || xr_enable->ival < 0)
		return false;	//nope, get lost.
	if (!strncasecmp(xr_formfactor->string, "none", 4))
		qreqs->vrplatform = VR_HEADLESS;
	switch(qreqs->vrplatform)
	{
#ifdef XR_MND_HEADLESS_EXTENSION_NAME
	case VR_HEADLESS:
		ext = XR_MND_HEADLESS_EXTENSION_NAME;
		break;
#endif
#ifdef XR_USE_GRAPHICS_API_VULKAN
	case VR_VULKAN:
		ext = XR_KHR_VULKAN_ENABLE_EXTENSION_NAME;
		break;
#endif
#ifdef XR_USE_GRAPHICS_API_OPENGL
#ifdef XR_MND_EGL_ENABLE_EXTENSION_NAME
	case VR_EGL:
		ext = XR_MND_EGL_ENABLE_EXTENSION_NAME;
		break;
#elif defined(XR_MNDX_EGL_ENABLE_EXTENSION_NAME)
	case VR_EGL:
		ext = XR_MNDX_EGL_ENABLE_EXTENSION_NAME;
		break;
#endif
#ifdef XR_USE_PLATFORM_XLIB
	case VR_X11_GLX:
#endif
#ifdef XR_USE_PLATFORM_WIN32
	case VR_WIN_WGL:
#endif
		ext = XR_KHR_OPENGL_ENABLE_EXTENSION_NAME;
		break;
#endif
#ifdef XR_USE_GRAPHICS_API_D3D11
	case VR_D3D11:
		ext = XR_KHR_D3D11_ENABLE_EXTENSION_NAME;
		break;
#endif
	default:
		Con_Printf(CON_ERROR"OpenXR: windowing-api or rendering-api not supported\n");
		return false;
	}

	xr.instance = XR_NULL_HANDLE;

	if (xr_debug->ival)
	{
		uint32_t count, u;
		struct XrApiLayerProperties *props;
		if (XR_SUCCEEDED(xrEnumerateApiLayerProperties(0, &count, NULL)))
		{
			props = calloc(count, sizeof(*props));
			for (u = 0; u < count; u++)
				props[u].type = XR_TYPE_API_LAYER_PROPERTIES;
			xrEnumerateApiLayerProperties(count, &count, props);
			for (u = 0; u < count; u++)
				Con_Printf("OpenXR Layer %s: %s\n", props[u].layerName, props[u].description);

			if (xr_debug->ival>1)
			{
				for (u = 0; u < count; u++)
					if (!strcmp(props[u].layerName, "XR_APILAYER_LUNARG_core_validation"))
					{
						xrlayers[numlayers++] = "XR_APILAYER_LUNARG_core_validation";
						break;
					}
				if (u==count)
					Con_Printf("OpenXR: Validation layers not found\n");
			}
			free(props);
		}
	}

	{
		unsigned int exts = 0, u=0;
		XrExtensionProperties *extlist;
		res = xrEnumerateInstanceExtensionProperties(NULL, 0, &exts, NULL);
		if (res == XR_ERROR_RUNTIME_UNAVAILABLE || res == XR_ERROR_INSTANCE_LOST)
		{
			Con_Printf(CON_WARNING"OpenXR: no runtime installed\n");
			return false;
		}
		else if (XR_SUCCEEDED(res))
		{
			extlist = calloc(exts, sizeof(*extlist));
			for (u = 0; u < exts; u++)
				extlist[u].type = XR_TYPE_EXTENSION_PROPERTIES;
			xrEnumerateInstanceExtensionProperties(NULL, exts, &exts, extlist);

			//print a list of them all, if we can.
			if (xr_debug->ival)
			{
				Con_DPrintf("OpenXR:\n");
				for (u = 0; u < exts; u++)
					Con_DPrintf("\t%s\n", extlist[u].extensionName);
			}

			//make sure we have an appropriate extension for the API we're using.
			if (ext)
			{
				for (u = 0; u < exts; u++)
					if (!strcmp(extlist[u].extensionName, ext))
						break;
				if (u == exts)
				{
					Con_Printf(CON_ERROR"OpenXR: instance driver does not support required %s\n", ext);
					free(extlist);
					return false;	//would just give an error on xrCreateInstance anyway.
				}

				xrexts[numext++] = ext;
			}

			//look for some interesting extensions
			for (u = 0; u < exts; u++)
			{
				if (!strcmp(extlist[u].extensionName, XR_EXT_DEBUG_UTILS_EXTENSION_NAME) && !havedebugutils && xr_debug->ival)
					havedebugutils = true, xrexts[numext++] = XR_EXT_DEBUG_UTILS_EXTENSION_NAME;

#ifdef XR_EXT_hand_tracking
				if (!strcmp(extlist[u].extensionName, XR_EXT_HAND_TRACKING_EXTENSION_NAME) && !havehandtrack && xr_fingertracking->ival)
					havehandtrack = true, xrexts[numext++] = XR_EXT_HAND_TRACKING_EXTENSION_NAME;
#endif
			}

			free(extlist);
		}
		else
		{
			Con_Printf(CON_ERROR"OpenXR: xrEnumerateInstanceExtensionProperties failed (%s)\n", XR_StringForResult(res));
			return false;
		}
	}

	//create our instance
	{
		XrInstanceCreateInfo createinfo = {XR_TYPE_INSTANCE_CREATE_INFO};
		createinfo.createFlags = 0;
		Q_strlcpy(createinfo.applicationInfo.applicationName, FULLENGINENAME, sizeof(createinfo.applicationInfo.applicationName));
		createinfo.applicationInfo.applicationVersion = APPLICATIONVERSION;
		Q_strlcpy(createinfo.applicationInfo.engineName, "FTEQW", sizeof(createinfo.applicationInfo.engineName));
		createinfo.applicationInfo.engineVersion = ENGINEVERSION;
		createinfo.applicationInfo.apiVersion = XR_CURRENT_API_VERSION;
		createinfo.enabledApiLayerCount = numlayers;
		createinfo.enabledApiLayerNames = xrlayers;
		createinfo.enabledExtensionCount = numext;
		createinfo.enabledExtensionNames = xrexts;
		res = xrCreateInstance(&createinfo, &xr.instance);
	}
	if (res == XR_ERROR_RUNTIME_UNAVAILABLE || res == XR_ERROR_INSTANCE_LOST)
	{
		Con_Printf(CON_WARNING"OpenXR: no runtime installed\n");
		return false;
	}
	if (XR_FAILED(res) || !xr.instance)
	{
		Con_Printf(CON_ERROR"OpenXR Runtime: xrCreateInstance failed (%s)\n", XR_StringForResult(res));
		return false;
	}

	if (havedebugutils)
	{
		XrDebugUtilsMessengerEXT messenger1 = XR_NULL_HANDLE;
		XrDebugUtilsMessengerCreateInfoEXT cb = {XR_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT};
		PFN_xrCreateDebugUtilsMessengerEXT xrCreateDebugUtilsMessengerEXT;
		cb.messageSeverities = XR_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT | XR_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | XR_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT | XR_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT;
		cb.messageTypes = XR_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |  XR_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | XR_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT | XR_DEBUG_UTILS_MESSAGE_TYPE_CONFORMANCE_BIT_EXT;
		cb.userCallback = XR_DebugPrint;
		cb.userData = NULL;

		if (!XR_FAILED(xrGetInstanceProcAddr(xr.instance, "xrCreateDebugUtilsMessengerEXT", (PFN_xrVoidFunction*) &xrCreateDebugUtilsMessengerEXT)))
			xrCreateDebugUtilsMessengerEXT(xr.instance, &cb, &messenger1);
	}

	if (xr_debug->ival)
	{
		XrInstanceProperties props = {XR_TYPE_INSTANCE_PROPERTIES};
		if (!XR_FAILED(xrGetInstanceProperties(xr.instance, &props)))
			Con_Printf("OpenXR Runtime: %s    %u.%u.%u\n", props.runtimeName, XR_VERSION_MAJOR(props.runtimeVersion), XR_VERSION_MINOR(props.runtimeVersion), XR_VERSION_PATCH(props.runtimeVersion));
		else
			Con_Printf("OpenXR Runtime: Unable to determine runtime version (%s)\n", XR_StringForResult(res));
	}

	{
		XrSystemGetInfo systemInfo = { XR_TYPE_SYSTEM_GET_INFO };
		if (qreqs->vrplatform == VR_HEADLESS)
			systemInfo.formFactor = XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY;	//err... woteva
		else if (!strncasecmp(xr_formfactor->string, "hand", 4))
			systemInfo.formFactor = XR_FORM_FACTOR_HANDHELD_DISPLAY;
		else if (!strncasecmp(xr_formfactor->string, "head",4))
			systemInfo.formFactor = XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY;
		else
		{
			if (*xr_formfactor->string)
				Con_Printf("\"%s\" is not a recognised value for xr_formfactor\n", xr_formfactor->string);
			else
				Con_Printf("xr_formfactor not set, assuming headmounted\n");
			systemInfo.formFactor = XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY;
		}
		res = xrGetSystem(xr.instance, &systemInfo, &xr.systemid);
		if (XR_FAILED(res) || !xr.systemid)
			return false;
	}

	{
		XrSystemProperties props = {XR_TYPE_SYSTEM_PROPERTIES};
#ifdef XR_EXT_hand_tracking
		XrSystemHandTrackingPropertiesEXT handtrackprops = {XR_TYPE_SYSTEM_HAND_TRACKING_PROPERTIES_EXT};
		if (havehandtrack)
		{	//instance might support it, but the specific hardware we're trying to use might not, in which case don't try using it after all.
			handtrackprops.next = props.next;
			props.next = &handtrackprops;
		}
#endif
		if (qreqs->vrplatform != VR_HEADLESS)
			if (XR_SUCCEEDED(xrGetSystemProperties(xr.instance, xr.systemid, &props)))
			{
				if (xr_debug->ival)
					Con_Printf("OpenXR System: %s\n", props.systemName);
			}

#ifdef XR_EXT_hand_tracking
		havehandtrack = handtrackprops.supportsHandTracking;
#endif
	}

#ifdef XR_EXT_hand_tracking
	if (havehandtrack)
	{
		xrGetInstanceProcAddr(xr.instance, "xrCreateHandTrackerEXT", (PFN_xrVoidFunction*) &xrCreateHandTrackerEXT);
		xrGetInstanceProcAddr(xr.instance, "xrLocateHandJointsEXT", (PFN_xrVoidFunction*) &xrLocateHandJointsEXT);
		xrGetInstanceProcAddr(xr.instance, "xrDestroyHandTrackerEXT", (PFN_xrVoidFunction*) &xrDestroyHandTrackerEXT);
	}
	else
	{
		xrCreateHandTrackerEXT = NULL;
		xrLocateHandJointsEXT = NULL;
		xrDestroyHandTrackerEXT = NULL;
	}
#endif

	switch(qreqs->vrplatform)
	{
	default:
		XR_Shutdown();
		return false;
	case VR_HEADLESS:
		break;

#ifdef XR_USE_GRAPHICS_API_VULKAN
	case VR_VULKAN:
		{
			XrGraphicsRequirementsVulkanKHR reqs = {XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR};
			VkInstance inst = VK_NULL_HANDLE;
			VkPhysicalDevice physdev;
			uint32_t extlen;
			char *extstr;	//space-delimited list, for some reason. writable though.

			PFN_xrGetVulkanGraphicsRequirementsKHR xrGetVulkanGraphicsRequirementsKHR;
			PFN_xrGetVulkanInstanceExtensionsKHR xrGetVulkanInstanceExtensionsKHR;
			PFN_xrGetVulkanDeviceExtensionsKHR xrGetVulkanDeviceExtensionsKHR;
			PFN_xrGetVulkanGraphicsDeviceKHR xrGetVulkanGraphicsDeviceKHR;
			if (XR_FAILED(xrGetInstanceProcAddr(xr.instance, "xrGetVulkanGraphicsRequirementsKHR", (PFN_xrVoidFunction*)&xrGetVulkanGraphicsRequirementsKHR)) ||
				XR_FAILED(xrGetInstanceProcAddr(xr.instance, "xrGetVulkanInstanceExtensionsKHR", (PFN_xrVoidFunction*)&xrGetVulkanInstanceExtensionsKHR)) ||
				XR_FAILED(xrGetInstanceProcAddr(xr.instance, "xrGetVulkanDeviceExtensionsKHR", (PFN_xrVoidFunction*)&xrGetVulkanDeviceExtensionsKHR)) ||
				XR_FAILED(xrGetInstanceProcAddr(xr.instance, "xrGetVulkanGraphicsDeviceKHR", (PFN_xrVoidFunction*)&xrGetVulkanGraphicsDeviceKHR)))
				return false;
			xrGetVulkanGraphicsRequirementsKHR(xr.instance, xr.systemid, &reqs);
			qreqs->maxver.major = XR_VERSION_MAJOR(reqs.maxApiVersionSupported);
			qreqs->maxver.minor = XR_VERSION_MINOR(reqs.maxApiVersionSupported);
			qreqs->minver.major = XR_VERSION_MAJOR(reqs.minApiVersionSupported);
			qreqs->minver.minor = XR_VERSION_MINOR(reqs.minApiVersionSupported);

			xrGetVulkanInstanceExtensionsKHR(xr.instance, xr.systemid, 0, &extlen, NULL);
			extstr = malloc(extlen);
			xrGetVulkanInstanceExtensionsKHR(xr.instance, xr.systemid, extlen, &extlen, extstr);

			//create vulkan instance now...
			qreqs->createinstance(qreqs, extstr, &inst);
			free(extstr);

			xrGetVulkanDeviceExtensionsKHR(xr.instance, xr.systemid, 0, &extlen, NULL);
			extstr = malloc(extlen);
			xrGetVulkanDeviceExtensionsKHR(xr.instance, xr.systemid, extlen, &extlen, extstr);

			res = xrGetVulkanGraphicsDeviceKHR(xr.instance, xr.systemid, inst, &physdev);

			qreqs->deviceextensions = extstr;
			qreqs->vk.physicaldevice = physdev;
		}
		break;
#endif

#ifdef XR_USE_GRAPHICS_API_OPENGL
	case VR_X11_GLX:
	case VR_EGL:
	case VR_WIN_WGL:
		{
			XrGraphicsRequirementsOpenGLKHR reqs = {XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_KHR};
			PFN_xrGetOpenGLGraphicsRequirementsKHR xrGetOpenGLGraphicsRequirementsKHR;
			if (XR_SUCCEEDED(xrGetInstanceProcAddr(xr.instance, "xrGetOpenGLGraphicsRequirementsKHR", (PFN_xrVoidFunction*)&xrGetOpenGLGraphicsRequirementsKHR)))
				xrGetOpenGLGraphicsRequirementsKHR(xr.instance, xr.systemid, &reqs);

			qreqs->maxver.major = XR_VERSION_MAJOR(reqs.maxApiVersionSupported);
			qreqs->maxver.minor = XR_VERSION_MINOR(reqs.maxApiVersionSupported);
			qreqs->minver.major = XR_VERSION_MAJOR(reqs.minApiVersionSupported);
			qreqs->minver.minor = XR_VERSION_MINOR(reqs.minApiVersionSupported);
			//caller must validate when creating its context.
		}
		break;
#endif

#ifdef XR_USE_GRAPHICS_API_D3D11
	case VR_D3D11:
		{
			XrGraphicsRequirementsD3D11KHR reqs = {XR_TYPE_GRAPHICS_REQUIREMENTS_D3D11_KHR};
			PFN_xrGetD3D11GraphicsRequirementsKHR xrGetD3D11GraphicsRequirementsKHR;
			if (XR_SUCCEEDED(xrGetInstanceProcAddr(xr.instance, "xrGetD3D11GraphicsRequirementsKHR", (PFN_xrVoidFunction*)&xrGetD3D11GraphicsRequirementsKHR)))
				xrGetD3D11GraphicsRequirementsKHR(xr.instance, xr.systemid, &reqs);

			qreqs->minver.major = reqs.minFeatureLevel;
			qreqs->deviceid[0] = reqs.adapterLuid.LowPart;
			qreqs->deviceid[1] = reqs.adapterLuid.HighPart;
		}
		break;
#endif
	}

	{
		XrViewConfigurationType *viewtype;
		uint32_t viewtypes, u;
		res = xrEnumerateViewConfigurations(xr.instance, xr.systemid, 0, &viewtypes, NULL);
		viewtype = alloca(viewtypes*sizeof(viewtype));
		res = xrEnumerateViewConfigurations(xr.instance, xr.systemid, viewtypes, &viewtypes, viewtype);
		xr.viewtype = (XrViewConfigurationType)0;
		for (u = 0; u < viewtypes; u++)
		{
			switch(viewtype[u])
			{
			case XR_VIEW_CONFIGURATION_TYPE_PRIMARY_MONO:
				if (!strcasecmp(xr_viewconfig->string, "mono"))
					xr.viewtype = viewtype[u];
				break;
			case XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO:
				if (!strcasecmp(xr_viewconfig->string, "stereo"))
					xr.viewtype = viewtype[u];
				break;
			case XR_VIEW_CONFIGURATION_TYPE_PRIMARY_QUAD_VARJO:
				if (!strcasecmp(xr_viewconfig->string, "quad"))
					xr.viewtype = viewtype[u];
				break;
			default:
				break;
			}
		}
		if (!xr.viewtype)
		{
			if (viewtypes)
				xr.viewtype = viewtype[0];

			if (*xr_viewconfig->string)
			{
				Con_Printf("OpenXR: Viewtype %s unavailable, using ", xr_viewconfig->string);
				switch(xr.viewtype)
				{
				case XR_VIEW_CONFIGURATION_TYPE_PRIMARY_MONO:		Con_Printf("mono\n"); break;
				case XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO:		Con_Printf("stereo\n"); break;
				case XR_VIEW_CONFIGURATION_TYPE_PRIMARY_QUAD_VARJO:	Con_Printf("quad\n"); break;
				default:
					Con_Printf("unknown (%i)\n", xr.viewtype);
					break;
				}
			}
		}
	}

	if (qreqs->vrplatform == VR_HEADLESS)
		return true;

	res = xrEnumerateViewConfigurationViews(xr.instance, xr.systemid, xr.viewtype, 0, &xr.viewcount, NULL);
	if (xr.viewcount > MAX_VIEW_COUNT)
		xr.viewcount = MAX_VIEW_COUNT;	//oh noes! evile!
	xr.views = calloc(1,sizeof(*xr.views)*xr.viewcount);
	{
		uint32_t u;
		for (u = 0; u < xr.viewcount; u++)
			xr.views[u].type = XR_TYPE_VIEW_CONFIGURATION_VIEW;
	}
	res = xrEnumerateViewConfigurationViews(xr.instance, xr.systemid, xr.viewtype, xr.viewcount, &xr.viewcount, xr.views);

	//caller now knows what device/contextversion/etc to init with
	return true;
}

static qboolean XR_Init(vrsetup_t *qreqs, rendererstate_t *info)
{
	xr.srgb = info->srgb;
	switch(qreqs->vrplatform)
	{
	case VR_HEADLESS:
		break;
	default:
		return false;	//error. not supported in this build.
#ifdef XR_USE_GRAPHICS_API_VULKAN
	case VR_VULKAN:
		{
			XrGraphicsBindingVulkanKHR *vk = xr.bindinginfo = calloc(1, sizeof(*vk));
			vk->type = XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR;
			vk->instance = qreqs->vk.instance;
			vk->physicalDevice = qreqs->vk.physicaldevice;
			vk->device = qreqs->vk.device;
			vk->queueFamilyIndex = qreqs->vk.queuefamily;
			vk->queueIndex = qreqs->vk.queueindex;
			xr.renderer = QR_VULKAN;
		}
		break;
#endif
#ifdef XR_USE_GRAPHICS_API_OPENGL
#ifdef XR_MND_EGL_ENABLE_EXTENSION_NAME
	case VR_EGL:	//x11-egl, wayland, and hopefully android...
		{
			XrGraphicsBindingEGLMND *egl = xr.bindinginfo = calloc(1, sizeof(*egl));
			egl->type = XR_TYPE_GRAPHICS_BINDING_EGL_MND;
			egl->getProcAddress = qreqs->egl.getprocaddr;
			egl->display = qreqs->egl.egldisplay;
			egl->config = qreqs->egl.eglconfig;
			egl->context = qreqs->egl.eglcontext;
			xr.renderer = QR_OPENGL;
		}
		break;
#elif defined(XR_MNDX_EGL_ENABLE_EXTENSION_NAME)
	case VR_EGL:	//x11-egl, wayland, and hopefully android...
		{
			XrGraphicsBindingEGLMNDX *egl = xr.bindinginfo = calloc(1, sizeof(*egl));
			egl->type = XR_TYPE_GRAPHICS_BINDING_EGL_MNDX;
			egl->getProcAddress = (PFNEGLGETPROCADDRESSPROC)qreqs->egl.getprocaddr;
			egl->display = qreqs->egl.egldisplay;
			egl->config = qreqs->egl.eglconfig;
			egl->context = qreqs->egl.eglcontext;
			xr.renderer = QR_OPENGL;
		}
		break;
#endif
#ifdef XR_USE_PLATFORM_XLIB
	case VR_X11_GLX:
		{
			XrGraphicsBindingOpenGLXlibKHR *glx = xr.bindinginfo = calloc(1, sizeof(*glx));
			glx->type = XR_TYPE_GRAPHICS_BINDING_OPENGL_XLIB_KHR;
			glx->xDisplay = qreqs->x11_glx.display;
			glx->visualid = qreqs->x11_glx.visualid;
			glx->glxFBConfig = qreqs->x11_glx.glxfbconfig;
			glx->glxDrawable = qreqs->x11_glx.drawable;
			glx->glxContext = qreqs->x11_glx.glxcontext;
			xr.renderer = QR_OPENGL;
		}
		break;
#endif
#ifdef XR_USE_PLATFORM_WIN32
	case VR_WIN_WGL:
		{
			XrGraphicsBindingOpenGLWin32KHR *wgl = xr.bindinginfo = calloc(1, sizeof(*wgl));
			wgl->type = XR_TYPE_GRAPHICS_BINDING_OPENGL_WIN32_KHR;
			wgl->hDC = qreqs->wgl.hdc;
			wgl->hGLRC = qreqs->wgl.hglrc;
			xr.renderer = QR_OPENGL;
		}
		break;
#endif
#endif	//def XR_USE_GRAPHICS_API_OPENGL
#ifdef XR_USE_GRAPHICS_API_D3D11
	case VR_D3D11:
		{
			XrGraphicsBindingD3D11KHR *d3d = xr.bindinginfo = calloc(1, sizeof(*d3d));
			d3d->type = XR_TYPE_GRAPHICS_BINDING_D3D11_KHR;
			d3d->device = qreqs->d3d.device;
			xr.renderer = QR_DIRECT3D11;
		}
		break;
#endif
	}


	XR_SetupInputs_Instance();
	return true;
}

static void XR_HapticCommand_f(void)
{
	size_t u;
	char actionname[XR_MAX_ACTION_NAME_SIZE];
	cmdfuncs->Argv(0, actionname, sizeof(actionname));
	for (u = 0; u < xr.numactions; u++)
	{
		if (!strcasecmp(xr.actions[u].actname, actionname) && xr.actions[u].acttype == XR_ACTION_TYPE_VIBRATION_OUTPUT)
		{
			if (xr.session)
			{
				XrHapticActionInfo info = {XR_TYPE_HAPTIC_ACTION_INFO};
				XrHapticVibration haptic = {XR_TYPE_HAPTIC_VIBRATION};
				info.action = xr.actions[u].action;
				info.subactionPath = XR_NULL_PATH;

				cmdfuncs->Argv(1, actionname, sizeof(actionname));
				haptic.duration = *actionname?SECONDS_TO_NANOSECONDS(atof(actionname)):XR_MIN_HAPTIC_DURATION;
				cmdfuncs->Argv(2, actionname, sizeof(actionname));
				haptic.amplitude = *actionname?atof(actionname):0;
				cmdfuncs->Argv(3, actionname, sizeof(actionname));
				haptic.frequency = *actionname?atof(actionname):XR_FREQUENCY_UNSPECIFIED;
				xrApplyHapticFeedback(xr.session, &info, (XrHapticBaseHeader*)&haptic);
			}
			break;
		}
	}
}

static XrAction XR_DefineAction(enum actset_e set, XrActionType type, const char *name, const char *description, const char *root)
{
	XrActionCreateInfo info = {XR_TYPE_ACTION_CREATE_INFO};
	XrResult res;
	char *ffs;

	size_t u;
	int nconflicts = 0;
	int dconflicts = 0;
	for (u = 0; u < xr.numactions; u++)
	{
		if (xr.actions[u].set != set)
			continue;
		if ((xr.actions[u].acttype == type || !type) && !strcmp(xr.actions[u].actname, name) /*&& !strcmp(xr.actions[u].actdescription, description)*/ && !strcmp(xr.actions[u].subactionpath?xr.actions[u].subactionpath:"", root?root:""))
		{	//looks like a dupe...
			return xr.actions[u].action;
		}
		if (!strcasecmp(xr.actions[u].actname, name))
			nconflicts++;	//arse balls knob cock
		if (description && !strcasecmp(xr.actions[u].actdescription, description))
			dconflicts++;	//arse balls knob cock
	}
	if (!description)
		return XR_NULL_HANDLE;	//none found
	if (u == xr.maxactions)
	{
		size_t nm = (xr.maxactions+1)*2;
		void *n = plugfuncs->Realloc(xr.actions, sizeof(*xr.actions) * nm);
		if (!n)
			return XR_NULL_HANDLE;	//erk!
		xr.actions = n;
		xr.maxactions = nm;
	}

	memset(&xr.actions[u], 0, sizeof(xr.actions[u]));
	xr.actions[u].set = set;
	xr.actions[u].acttype = type;
	xr.actions[u].actname = strdup(name);
	xr.actions[u].actdescription = strdup(description);
	xr.actions[u].subactionpath = (root&&*root)?strdup(root):NULL;
	xr.numactions++;

	if (xr.actions[u].subactionpath)
		xrStringToPath(xr.instance, xr.actions[u].subactionpath, &xr.actions[u].path);
	else
		xr.actions[u].path = XR_NULL_PATH;
	if (xr.actions[u].path == XR_NULL_PATH)
	{
		info.countSubactionPaths = 0;
		info.subactionPaths = NULL;
	}
	else
	{
		info.countSubactionPaths = 1;
		info.subactionPaths = &xr.actions[u].path;
	}
	info.actionType = xr.actions[u].acttype;
	Q_strlcpy(info.actionName, xr.actions[u].actname, sizeof(info.actionName));
	for (ffs = info.actionName; *ffs; ffs++)
	{
		if (*ffs >= 'A' && *ffs < 'Z')
			*ffs += 'a'-'A';	//must be lower-case
		else if (*ffs >= 'a' && *ffs <= 'z')
			;	//allowed
		else if (*ffs >= '0' && *ffs <= '9')
			;	//allowed
		else if (*ffs == '.' || *ffs == '-' || *ffs == '_')
			;	//allowed
		// '/' is not allowed as it must be a single segment.
		else
			*ffs = '_';	//everything else is blocked
	}
	Q_strlcpy(info.localizedActionName, xr.actions[u].actdescription, sizeof(info.localizedActionName));
	res = xrCreateAction(xr.actionset[set].actionSet, &info, &xr.actions[u].action);
	if (XR_FAILED(res))
		Con_Printf("openxr: Unable to create action %s [%s] - %s\n", info.actionName, info.localizedActionName, XR_StringForResult(res));

	if (info.actionType == XR_ACTION_TYPE_VIBRATION_OUTPUT)
		cmdfuncs->AddCommand(xr.actions[u].actname, XR_HapticCommand_f, "Linked to an OpenXR haptic feedback.");

	return xr.actions[u].action;
}

static qboolean XR_ReadLine(const char **text, char *buffer, size_t buflen)
{
	char in;
	char *out = buffer;
	size_t len;
	if (buflen <= 1)
		return false;
	len = buflen-1;
	while (len > 0)
	{
		in = *(*text);
		if (!in)
		{
			if (len == buflen-1)
				return false;
			*out = 0;
			return true;
		}
		(*text)++;
		if (in == '\n')
			break;
		*out++ = in;
		len--;
	}
	*out = '\0';

	//if there's a trailing \r, strip it.
	if (out > buffer)
		if (out[-1] == '\r')
			out[-1] = 0;

	return true;
}

static int XR_BindProfileStr(const char *fname, const char *file)
{
	XrAction act;
	XrResult res;
	XrPath profilepath = XR_NULL_PATH;
	char line[1024], *linestart;
	char name[1024];
	char type[256];
	char desc[1024];
	char bind[1024];
	char root[1024];
	unsigned int p;
	char prefix[2][1024];
	enum actset_e set;

	XrInteractionProfileSuggestedBinding suggestedbindings = {XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING};
	unsigned int acts = 0;
	XrActionSuggestedBinding bindings[256];
	unsigned int totalacts = 0;

	while (XR_ReadLine(&file, line, sizeof(line)))
	{
		set = AS_COMMON;
		linestart = line;
		while (*linestart == ' ' || *linestart == '\t')
			linestart++;

		if (!strncasecmp(linestart, "menu:", 5))
		{
			set = AS_MENU;
			linestart+=5;
		}
		else if (!strncasecmp(linestart, "game:", 5))
		{
			set = AS_GAME;
			linestart+=5;
		}
		else if (!strncasecmp(linestart, "common:", 7))
		{	//the default, but nice to be able to be explicit (especially if you want a colon in the action name).
			set = AS_COMMON;
			linestart+=7;
		}

		cmdfuncs->TokenizeString(linestart);
		if (cmdfuncs->Argc())
		{
			cmdfuncs->Argv(0, name, sizeof(name));

			if (!strcasecmp(name, "dev"))
			{
				cmdfuncs->Argv(1, root, sizeof(root));
				continue;
			}
			else if (!strcasecmp(name, "profile"))
			{
				if (acts)
				{
					suggestedbindings.interactionProfile = profilepath;
					suggestedbindings.countSuggestedBindings = acts;
					suggestedbindings.suggestedBindings = bindings;
					res = xrSuggestInteractionProfileBindings(xr.instance, &suggestedbindings);
					if (XR_FAILED(res))
						Con_Printf(CON_ERROR"%s: xrSuggestInteractionProfileBindings failed - %s\n", fname, XR_StringForResult(res));
					totalacts += acts;
					acts = 0;
				}

				cmdfuncs->Argv(1, name, sizeof(name));
				for (p = 0; p < countof(prefix); p++)
					cmdfuncs->Argv(2+p, prefix[p], sizeof(prefix[p]));
				*root = 0;
				if (XR_FAILED(xrStringToPath(xr.instance, name, &profilepath)))
					profilepath = XR_NULL_PATH;
				continue;
			}
			else if (!strcasecmp(name, "action"))
			{
				cmdfuncs->Argv(1, name, sizeof(name));
				cmdfuncs->Argv(2, desc, sizeof(desc));
				cmdfuncs->Argv(3, type, sizeof(type));
				cmdfuncs->Argv(4, bind, sizeof(bind));
			}
			else if (cmdfuncs->Argc() == 2)
			{
				*desc = 0;
				*type = 0;
				cmdfuncs->Argv(1, bind, sizeof(desc));
			}
			else
			{
				if (cmdfuncs->Argc() < 4)
				{
					Con_Printf("Unknown action command \"%s\"\n", name);
					continue;
				}
				cmdfuncs->Argv(1, desc, sizeof(desc));
				cmdfuncs->Argv(2, type, sizeof(type));
				cmdfuncs->Argv(3, bind, sizeof(bind));
				if (cmdfuncs->Argc() >= 5)
					Con_Printf("%s: %s: Extra tokens found\n", fname, name);
			}

			if (*type)
			{
				XrActionType xrtype;
				if (!strcasecmp(type, "button"))
					xrtype = XR_ACTION_TYPE_BOOLEAN_INPUT;
				else if (!strcasecmp(type, "float"))
					xrtype = XR_ACTION_TYPE_FLOAT_INPUT;
				else if (!strcasecmp(type, "vector2f"))
					xrtype = XR_ACTION_TYPE_VECTOR2F_INPUT;
				else if (!strcasecmp(type, "pose"))
					xrtype = XR_ACTION_TYPE_POSE_INPUT;
				else if (!strcasecmp(type, "vibration") || !strcasecmp(type, "haptic"))
					xrtype = XR_ACTION_TYPE_VIBRATION_OUTPUT;
				else
					continue;

				//define our action...
				act = XR_DefineAction(set, xrtype, name, desc, root);
			}
			else
			{
				act = XR_DefineAction(set, (XrActionType)0, name, NULL, root);
				if(act==XR_NULL_HANDLE)
					Con_Printf("Action %s not defined yet\n", name);
			}

			//and add it to the profile we're building.
			if (act != XR_NULL_HANDLE && *bind && profilepath!=XR_NULL_PATH)
			{
				if (*bind == '/')
				{
					res = xrStringToPath(xr.instance, bind, &bindings[acts].binding);
					if (XR_SUCCEEDED(res) && acts < countof(bindings))
						bindings[acts++].action = act;
				}
				else if (*root == '/')
				{
					res = xrStringToPath(xr.instance, va("%s/%s", root, bind), &bindings[acts].binding);
					if (XR_SUCCEEDED(res) && acts < countof(bindings))
						bindings[acts++].action = act;
				}
				else for (p = 0; p < countof(prefix) && *prefix[p]=='/'; p++)
				{
					res = xrStringToPath(xr.instance, va("%s%s", prefix[p], bind), &bindings[acts].binding);
					if (XR_SUCCEEDED(res) && acts < countof(bindings))
						bindings[acts++].action = act;
				}
			}
		}
	}

	if (acts)
	{
		suggestedbindings.interactionProfile = profilepath;
		suggestedbindings.countSuggestedBindings = acts;
		suggestedbindings.suggestedBindings = bindings;
		res = xrSuggestInteractionProfileBindings(xr.instance, &suggestedbindings);
		if (XR_FAILED(res))
			Con_Printf(CON_ERROR"%s: xrSuggestInteractionProfileBindings failed - %s\n", fname, XR_StringForResult(res));
		totalacts += acts;
	}
	return totalacts;
}

static int QDECL XR_BindProfileFile(const char *fname, qofs_t fsize, time_t mtime, void *ctx, struct searchpathfuncs_s *package)
{
	vfsfile_t *f = fsfuncs->OpenVFS(fname, "rb", FS_GAME);
	if (f)
	{
		size_t len = VFS_GETLEN(f);
		char *buf = malloc(len+1);
		VFS_READ(f, buf, len);
		buf[len] = 0;
		*(unsigned int*)ctx += XR_BindProfileStr(fname, buf);
		free(buf);
		VFS_CLOSE(f);
	}
	return true;
}

static const struct
{
	const char *name;
	const char *script;
} xr_knownprofiles[] =
{
	//FIXME: set up some proper bindings!
	{"khr_simple",		"profile /interaction_profiles/khr/simple_controller    /user/hand/left/ /user/hand/right/\n"
			"dev /user/hand/left\n"
				"+attack_left			\"Left Attack\"		button	input/select/click\n"
				"+menu_left				\"Left Menu\"		button	input/menu/click\n"
				"#POSE_LEFT				\"Left Aim Pose\"	pose	input/aim/pose\n"
				//"left_grip			\"Left Grip Pose\"	pose	input/grip/pose\n"
				"haptic_left			\"Left Haptic\"		haptic	output/haptic\n"
			"dev /user/hand/right\n"
				"menu: #GP_START		\"Menu Enter\"		button	input/select/click\n"
				"menu: #GP_BACK			\"Menu Escape\"		button	input/menu/click\n"
				"game: +attack_right	\"Right Attack\"	button	input/select/click\n"
				"game: +menu_right		\"Right Menu\"		button	input/menu/click\n"
				"#POSE_RIGHT			\"Right Aim Pose\"	pose	input/aim/pose\n"
				//"right_grip			\"Right Grip Pose\"	pose	input/grip/pose\n"
				"haptic_right			\"Right Haptic\"	haptic	output/haptic\n"
	},

/*	{"valve_index",		"profile /interaction_profiles/valve/index_controller    /user/hand/left/ /user/hand/right/\n"
			//"unbound		\"Unused Button\"		button		input/system/click\n"
			//"unbound		\"Unused Button\"		button		input/system/touch\n"
			//"unbound		\"Unused Button\"		button		input/a/click\n"
			//"unbound		\"Unused Button\"		button		input/a/touch\n"
			//"unbound		\"Unused Button\"		button		input/b/click\n"
			//"unbound		\"Unused Button\"		button		input/b/touch\n"
			//"unbound		\"Unused Button\"		float		input/squeeze/value\n"
			//"unbound		\"Unused Button\"		button		input/squeeze/force\n"
			//"unbound		\"Unused Button\"		button		input/trigger/click\n"
			//"unbound		\"Unused Button\"		float		input/trigger/value\n"
			//"unbound		\"Unused Button\"		button		input/trigger/touch\n"
			//"unbound		\"Unused Button\"		vector2f	input/thumbstick\n"
			//"unbound		\"Unused Button\"		button		input/thumbstick/click\n"
			//"unbound		\"Unused Button\"		button		input/thumbstick/touch\n"
			//"unbound		\"Unused Button\"		vector2f	input/trackpad\n"
			//"unbound		\"Unused Button\"		button		input/trackpad/force\n"
			//"unbound		\"Unused Button\"		button		input/trackpad/touch\n"
			//"unbound		\"Unused Button\"		pose		input/grip/pose\n"
			//"unbound		\"Unused Button\"		pose		input/aim/pose\n"
			//"unbound		\"Unused Button\"		haptic		output/haptic\n"
	},
*/
/*	{"htc_vive",		"profile /interaction_profiles/htc/vive_controller    /user/hand/left/ /user/hand/right/\n"
			//"unbound		\"Unused Button\"		button		input/system/click\n"
			//"unbound		\"Unused Button\"		button		input/squeeze/click\n"
			//"unbound		\"Unused Button\"		button		input/menu/click\n"
			//"unbound		\"Unused Button\"		button		input/trigger/click\n"
			//"unbound		\"Unused Button\"		float		input/trigger/value\n"
			//"unbound		\"Unused Button\"		vector2f	input/trackpad\n"
			//"unbound		\"Unused Button\"		button		input/trackpad/click\n"
			//"unbound		\"Unused Button\"		button		input/trackpad/touch\n"
			//"unbound		\"Unused Button\"		pose		input/grip/pose\n"
			//"unbound		\"Unused Button\"		pose		input/aim/pose\n"
			//"unbound		\"Unused Button\"		haptic		output/haptic\n"
			);
*/
/*	{"htc_vive_pro",	"profile /interaction_profiles/htc/vive_pro    /user/head/\n"
			//"unbound		\"Unused Button\"		button		input/system/click\n"
			//"unbound		\"Unused Button\"		button		input/volume_up/click\n"
			//"unbound		\"Unused Button\"		button		input/volume_down/click\n"
			//"unbound		\"Unused Button\"		button		input/mute_mic/click\n"
			);
*/

	//just map everything to quake's various buttons so that mods with proper gamepad mapping will work here too.
	{"gamepad", "profile /interaction_profiles/microsoft/xbox_controller    /user/gamepad/\n"
			"#GP_START				\"Start\"				button		input/menu/click\n"
			"#GP_BACK				\"Back\"				button		input/view/click\n"
			"#GP_A					\"A Button\"			button		input/a/click\n"
			"#GP_B					\"B Button\"			button		input/b/click\n"
			"#GP_X					\"X Button\"			button		input/x/click\n"
			"#GP_Y					\"Y Button\"			button		input/y/click\n"
			"#GP_DPAD_DOWN			\"Move Backwards\"		button		input/dpad_down/click\n"
			"#GP_DPAD_RIGHT			\"Move Right\"			button		input/dpad_right/click\n"
			"#GP_DPAD_UP			\"Move Forward\"		button		input/dpad_up/click\n"
			"#GP_DPAD_LEFT			\"Move Left\"			button		input/dpad_left/click\n"
			"#GP_LSHOULDER			\"Jump\"				button		input/shoulder_left/click\n"
			"#GP_RSHOULDER			\"Attack\"				button		input/shoulder_right/click\n"
			"#GP_LTHUMB				\"Left Thumb\"			button		input/thumbstick_left/click\n"
			"#GP_RTHUMB				\"Right Thumb\"			button		input/thumbstick_right/click\n"
			"#GP_AXIS_LTRIGGER		\"Left Trigger\"		float		input/trigger_left/value\n"
			"#GP_AXIS_RTRIGGER		\"Right Trigger\"		float		input/trigger_right/value\n"
			"#GP_AXIS_LEFT_X		\"Left Thumbstick X\"	float		input/thumbstick_left/x\n"
			"#GP_AXIS_LEFT_Y		\"Left Thumbstick y\"	float		input/thumbstick_left/y\n"
			"#GP_AXIS_RIGHT_X		\"Right Thumbstick X\"	float		input/thumbstick_right/x\n"
			"#GP_AXIS_RIGHT_X		\"Right Thumbstick Y\"	float		input/thumbstick_right/y\n"
			"haptic_gp_left			\"Left Haptic (Main)\"		haptic	output/haptic_left\n"
			"haptic_gp_left_trigger	\"Left-Trigger Haptic\"		haptic	output/haptic_left_trigger\n"
			"haptic_gp_right		\"Right Haptic (Main)\"		haptic	output/haptic_right\n"
			"haptic_gp_right_trigger \"Right-Trigger Haptic\"	haptic	output/haptic_right_trigger\n"
	},
};

static void XR_SetupInputs_Instance(void)
{
	unsigned int h;
	XrResult res;
	int set;
	char *actionsetNames[] = {"genericactions", "menuactions", "gameactions"};
	char *actionsetNamesText[] = {"Generic Actions", "Menu Actions", "Game Actions"};

	for (set = 0; set < MAX_ACTIONSETS; set++)
	{
		XrActionSetCreateInfo info = {XR_TYPE_ACTION_SET_CREATE_INFO};
		Q_strlcpy(info.actionSetName, actionsetNames[set], sizeof(info.actionSetName));
		Q_strlcpy(info.localizedActionSetName, actionsetNamesText[set], sizeof(info.localizedActionSetName));
		info.priority = 0;

		xr.actionset[set].subactionPath = XR_NULL_PATH;
		res = xrCreateActionSet(xr.instance, &info, &xr.actionset[set].actionSet);
		if (XR_FAILED(res))
			Con_Printf("openxr: Unable to create actionset - %s\n", XR_StringForResult(res));
	}

	h = 0;
	if (fsfuncs)
		fsfuncs->EnumerateFiles("oxr_*.binds", XR_BindProfileFile, &h);
	if (!h)	//no user bindings defined, use fallbacks. probably this needs to be per-mod.
	{
		for (h = 0; h < countof(xr_knownprofiles); h++)
			XR_BindProfileStr(xr_knownprofiles[h].name, xr_knownprofiles[h].script);
	}
}
static void XR_SetupInputs_Session(void)
{
	unsigned int h;
	XrResult res;

	//create action space stuff.
	for (h = 0; h < xr.numactions; h++)
	{
		switch(xr.actions[h].acttype)
		{
		case XR_ACTION_TYPE_POSE_INPUT:
			{
				XrActionSpaceCreateInfo info = {XR_TYPE_ACTION_SPACE_CREATE_INFO};
				info.action = xr.actions[h].action;
				info.subactionPath = xr.actions[h].path;
				info.poseInActionSpace.orientation.w = 1;	//just fill with identity.

				res = xrCreateActionSpace(xr.session, &info, &xr.actions[h].space);
				if (XR_FAILED(res))
					Con_Printf("openxr: xrCreateActionSpace failed - %s\n", XR_StringForResult(res));
			}
			break;
		default:
			xr.actions[h].space = XR_NULL_HANDLE;
			break;
		}
	}

	//and attach it.
	{
		XrSessionActionSetsAttachInfo info = {XR_TYPE_SESSION_ACTION_SETS_ATTACH_INFO};
		XrActionSet sets[MAX_ACTIONSETS];
		unsigned int set;
		for (set = 0; set < MAX_ACTIONSETS; set++)
			if (xr.actionset[set].actionSet)
				sets[info.countActionSets++] = xr.actionset[set].actionSet;
		info.actionSets = sets;
		res = xrAttachSessionActionSets(xr.session, &info);
		if (XR_FAILED(res))
			Con_Printf("openxr: xrAttachSessionActionSets failed - %s\n", XR_StringForResult(res));
	}

#ifdef XR_EXT_hand_tracking
	//create some hand trackers... try to create one for each hand...
	//(note: this is more a finger-joint tracker than a hand tracker, though limited controllers generally mean its good only for fingers)
	if (xrCreateHandTrackerEXT)
	for (h = 0; h < 2; h++)
	{
		XrHandTrackerCreateInfoEXT info = {XR_TYPE_HAND_TRACKER_CREATE_INFO_EXT};
		info.hand = h?XR_HAND_RIGHT_EXT:XR_HAND_LEFT_EXT;
		info.handJointSet = XR_HAND_JOINT_SET_DEFAULT_EXT;
		res = xrCreateHandTrackerEXT(xr.session, &info, &xr.hand[h].handle);
		if (XR_FAILED(res))
			Con_Printf("openxr: xrCreateHandTrackerEXT failed - %s\n", XR_StringForResult(res));
	}
#endif
}

static void XR_PrintInputs(void)
{
	XrResult res;
	XrInteractionProfileState profile = {XR_TYPE_INTERACTION_PROFILE_STATE};
	XrPath path;
	unsigned int u;
	static const char *paths[] = {"/user/hand/left", "/user/hand/right", "/user/head", "/user/gamepad"};
	Con_Printf("OpenXR Interaction Profiles:\n");
	for (u = 0; u < countof(paths); u++)
	{
		xrStringToPath(xr.instance, paths[u], &path);
		res = xrGetCurrentInteractionProfile(xr.session, path, &profile);
		if (XR_SUCCEEDED(res))
		{
			char buf[256];
			uint32_t len = sizeof(buf);
			if (!profile.interactionProfile)
				Con_Printf("\t%s: "S_COLOR_GRAY"no profile/device\n", paths[u]);
			else
			{
				res = xrPathToString(xr.instance, profile.interactionProfile, sizeof(buf), &len, buf);
				Con_Printf("\t%s: "S_COLOR_GREEN"%s\n", paths[u], buf);
			}
		}
	}


	Con_Printf("Bound actions:\n");
	for (u = 0; u < xr.numactions; u++)
	{
		XrBoundSourcesForActionEnumerateInfo info = {XR_TYPE_BOUND_SOURCES_FOR_ACTION_ENUMERATE_INFO};
		uint32_t inputs, i, bufsize;
		XrPath input[20];
		info.action = xr.actions[u].action;
		res = xrEnumerateBoundSourcesForAction(xr.session, &info, countof(input), &inputs, input);
		if (XR_SUCCEEDED(res))
		{
			Con_Printf("\t%s "S_COLOR_GRAY"(%s)"S_COLOR_WHITE":\n", xr.actions[u].actname, xr.actions[u].actdescription);
			if (!inputs)
				Con_Printf(S_COLOR_GRAY"\t\t(unbound)\n");
			else for (i = 0; i < inputs; i++)
			{
				char buffer[8192];
				XrInputSourceLocalizedNameGetInfo info = {XR_TYPE_INPUT_SOURCE_LOCALIZED_NAME_GET_INFO};
				info.sourcePath = input[i];
				info.whichComponents =	XR_INPUT_SOURCE_LOCALIZED_NAME_USER_PATH_BIT|	//'left hand'
										XR_INPUT_SOURCE_LOCALIZED_NAME_INTERACTION_PROFILE_BIT|	//'foo controller'
										XR_INPUT_SOURCE_LOCALIZED_NAME_COMPONENT_BIT;	//'trigger'
				res = xrGetInputSourceLocalizedName(xr.session, &info, sizeof(buffer), &bufsize, buffer);
				if (XR_FAILED(res))
					Q_snprintf(buffer, sizeof(buffer), S_COLOR_RED"error %i", res);
				else
					Con_Printf(S_COLOR_GREEN"\t\t%s\n", buffer);
			}
		}
		else if (res == XR_ERROR_HANDLE_INVALID)	//monado reports this for unimplemented things.
			Con_Printf(S_COLOR_RED"\t%s: error XR_ERROR_HANDLE_INVALID (not implemented?)\n", xr.actions[u].actname);
		else
			Con_Printf(S_COLOR_RED"\t%s: error %s\n", xr.actions[u].actname, XR_StringForResult(res));
	}
}

static void XR_UpdateInputs(XrTime time)
{
	XrResult res;
	size_t h;
	qboolean activesets[MAX_ACTIONSETS] = {true};

	if (inputfuncs->GetKeyDest() & ~kdm_game)
		activesets[AS_MENU] = true;	//used while looking at the menuqc/emenus/console/etc.
	else
		activesets[AS_GAME] = true;	//used while the game has focus.

	{
		XrActionsSyncInfo syncinfo = {XR_TYPE_ACTIONS_SYNC_INFO};
		XrActiveActionSet sets[MAX_ACTIONSETS];
		for (h = 0; h < MAX_ACTIONSETS; h++)
			if (activesets[h])
				sets[syncinfo.countActiveActionSets++] = xr.actionset[h];
		syncinfo.activeActionSets = sets;
		res = xrSyncActions(xr.session, &syncinfo);
		if (res == XR_SESSION_NOT_FOCUSED)
			;	//handle it anyway, giving us a chance to disable various inputs.
		else if (XR_FAILED(res))
			return;
	}

	for (h = 0; h < xr.numactions; h++)
	{
		if (xr.actions[h].action == XR_NULL_HANDLE)	//failed to init
			continue;
		safeswitch(xr.actions[h].acttype)
		{
		case XR_ACTION_TYPE_POSE_INPUT:
			{
				XrActionStatePose pose = {XR_TYPE_ACTION_STATE_POSE};
				XrActionStateGetInfo info = {XR_TYPE_ACTION_STATE_GET_INFO};
				info.action = xr.actions[h].action;
				info.subactionPath = xr.actions[h].path;

				if (XR_FAILED(xrGetActionStatePose(xr.session, &info, &pose)))
					break;
				if (pose.isActive && activesets[xr.actions[h].set])
				{	//its mapped to something, woo.
					XrSpaceVelocity vel = {XR_TYPE_SPACE_VELOCITY};
					XrSpaceLocation loc = {XR_TYPE_SPACE_LOCATION, &vel};
					vec3_t angles, org, lvel, avel;
					res = xrLocateSpace(xr.actions[h].space, xr.space, time, &loc);
					XR_PoseToAngOrg(&loc.pose, angles, org);

					VectorSet(lvel, vel.linearVelocity.x, vel.linearVelocity.y, vel.linearVelocity.z);
					VectorSet(avel, vel.angularVelocity.x, vel.angularVelocity.y, vel.angularVelocity.z);
					if (!strncasecmp(xr.actions[h].actname, "#POSE_", 6))
					{
						if (inputfuncs->SetHandPosition(xr.actions[h].actname+6,
								(loc.locationFlags&XR_SPACE_LOCATION_POSITION_VALID_BIT)?org:NULL,
								(loc.locationFlags&XR_SPACE_LOCATION_ORIENTATION_VALID_BIT)?angles:NULL,
								(vel.velocityFlags&XR_SPACE_VELOCITY_LINEAR_VALID_BIT)?lvel:NULL,
								(vel.velocityFlags&XR_SPACE_VELOCITY_ANGULAR_VALID_BIT)?avel:NULL))
							;
						else
							Con_Printf("Pose \"%s\" for action \"%s\" is not a known pose name\n", xr.actions[h].actname+1, xr.actions[h].actdescription);
					}
					else
					{	//custom poses that mods might want to handle themselves...
						char cmd[256];
						unsigned int status = 0;
						status |= (loc.locationFlags&XR_SPACE_LOCATION_POSITION_VALID_BIT)?VRSTATUS_ORG:0;
						status |= (loc.locationFlags&XR_SPACE_LOCATION_ORIENTATION_VALID_BIT)?VRSTATUS_ANG:0;
						status |= (vel.velocityFlags&XR_SPACE_VELOCITY_LINEAR_VALID_BIT)?VRSTATUS_VEL:0;
						status |= (vel.velocityFlags&XR_SPACE_VELOCITY_ANGULAR_VALID_BIT)?VRSTATUS_AVEL:0;
						if (status & (VRSTATUS_VEL|VRSTATUS_AVEL))
						{
							Q_snprintf(cmd, sizeof(cmd), "%s %u %g %g %g %g %g %g %g %g %g %g %g %g\n", xr.actions[h].actname, status,
											 angles[0], angles[1], angles[2], org[0], org[1], org[2],
											 vel.angularVelocity.x, vel.angularVelocity.y, vel.angularVelocity.z, vel.linearVelocity.x, vel.linearVelocity.y, vel.linearVelocity.z);
						}
						else if (status & VRSTATUS_ORG)
						{
							Q_snprintf(cmd, sizeof(cmd), "%s %u %g %g %g %g %g %g\n", xr.actions[h].actname, status,
											 angles[0], angles[1], angles[2], org[0], org[1], org[2]);
						}
						else
						{
							Q_snprintf(cmd, sizeof(cmd), "%s %u %g %g %g\n", xr.actions[h].actname, status,
											 angles[0], angles[1], angles[2]);
						}
						cmdfuncs->AddText(cmd, false);
					}
				}
			}
			break;
		case XR_ACTION_TYPE_BOOLEAN_INPUT:
			{
				XrActionStateBoolean state = {XR_TYPE_ACTION_STATE_BOOLEAN};
				XrActionStateGetInfo info = {XR_TYPE_ACTION_STATE_GET_INFO};
				info.action = xr.actions[h].action;
				info.subactionPath = xr.actions[h].path;
				if (XR_FAILED(xrGetActionStateBoolean(xr.session, &info, &state)))
					break;
				if (!state.isActive) state.currentState = XR_FALSE;
				if ((!!state.currentState) != xr.actions[h].held)
				{
					xr.actions[h].held = !!state.currentState;
					if (xr.actions[h].held && !activesets[xr.actions[h].set])
						break;	//don't fire the down event when this action's set isn't meant to be active...
					if (*xr.actions[h].actname == '#')
					{
						int k = inputfuncs->GetKeyCode(xr.actions[h].actname+1, NULL);
						if (k >= 0)
							inputfuncs->KeyEvent(0, xr.actions[h].held, k, 0);
						else
							Con_Printf("Key \"%s\" for action \"%s\" is not a known key code\n", xr.actions[h].actname+1, xr.actions[h].actdescription);
					}
					else if (xr.actions[h].held || *xr.actions[h].actname == '+')
					{
						char cmd[256];
						Q_strlcpy(cmd, xr.actions[h].actname, sizeof(cmd));
						Q_strlcat(cmd, "\n", sizeof(cmd));
						if (!xr.actions[h].held)
							*cmd = '-';	//release events.
						cmdfuncs->AddText(cmd, false);
					}
				}
			}
			break;
		case XR_ACTION_TYPE_FLOAT_INPUT:
			{
				XrActionStateFloat state = {XR_TYPE_ACTION_STATE_FLOAT};
				XrActionStateGetInfo info = {XR_TYPE_ACTION_STATE_GET_INFO};
				info.action = xr.actions[h].action;
				info.subactionPath = xr.actions[h].path;
				if (XR_FAILED(xrGetActionStateFloat(xr.session, &info, &state)))
					break;

				if (state.isActive && activesets[xr.actions[h].set])
				{
					char cmd[256];
					if (!strncasecmp(xr.actions[h].actname, "#GP_AXIS_", 9))
					{
						int axis = -1;
						if (!strcasecmp(xr.actions[h].actname+9, "LTRIGGER"))
							axis = GPAXIS_LT_TRIGGER;
						else if (!strcasecmp(xr.actions[h].actname+9, "RTRIGGER"))
							axis = GPAXIS_RT_TRIGGER;
						else if (!strcasecmp(xr.actions[h].actname+9, "LEFT_X"))
							axis = GPAXIS_LT_RIGHT;
						else if (!strcasecmp(xr.actions[h].actname+9, "LEFT_Y"))
							axis = GPAXIS_LT_DOWN;
						else if (!strcasecmp(xr.actions[h].actname+9, "RIGHT_X"))
							axis = GPAXIS_RT_RIGHT;
						else if (!strcasecmp(xr.actions[h].actname+9, "RIGHT_Y"))
							axis = GPAXIS_RT_DOWN;
						else
							Con_Printf("Unknown gamepad axis: \"%s\"\n", xr.actions[h].actname+1);
						inputfuncs->JoystickAxisEvent(0, axis, state.currentState);
					}
					else
					{
						Q_snprintf(cmd, sizeof(cmd), "%s %g\n", xr.actions[h].actname, state.currentState);
						cmdfuncs->AddText(cmd, false);
					}
				}
			}
			break;
		case XR_ACTION_TYPE_VECTOR2F_INPUT:
			{
				XrActionStateVector2f state = {XR_TYPE_ACTION_STATE_VECTOR2F};
				XrActionStateGetInfo info = {XR_TYPE_ACTION_STATE_GET_INFO};
				info.action = xr.actions[h].action;
				info.subactionPath = xr.actions[h].path;
				if (XR_FAILED(xrGetActionStateVector2f(xr.session, &info, &state)))
					break;

				if (state.isActive && activesets[xr.actions[h].set])
				{
					char cmd[256];
					Q_snprintf(cmd, sizeof(cmd), "%s %g %g\n", xr.actions[h].actname, state.currentState.x, state.currentState.y);
					cmdfuncs->AddText(cmd, false);
				}
			}
			break;
		case XR_ACTION_TYPE_VIBRATION_OUTPUT:	//output only, nothing to read.
		case XR_ACTION_TYPE_MAX_ENUM: //not a real value
		safedefault:
			break;
		}
	}
}

static int64_t XR_CheckSwapFormats(int64_t *tryformat, int64_t *fmts, size_t fmtcount)
{
	size_t i, j;
	for (j = 0; j < fmtcount; j++)
	{	//the openxr driver lists is supposed to list formats in the order that it favours, so favour those.
		for (i = 0; tryformat[i]; i++)
		{	//now make sure its one that we allow. (steamvr lists ones that are NOT renderable - even though they should be)
			if (tryformat[i] == fmts[j])
				return fmts[j];
		}
	}
	return 0;
}
static int64_t XR_FindSwapFormat(int64_t **tryformats, int64_t *fmts, size_t fmtcount)
{
	int64_t fmt;
	/*try to use a format that matches the user's choice*/
	if (xr.srgb == 2)
		fmt = XR_CheckSwapFormats(tryformats[0], fmts, fmtcount);
	else if (xr.srgb)
		fmt = XR_CheckSwapFormats(tryformats[1], fmts, fmtcount);
	else
		fmt = XR_CheckSwapFormats(tryformats[2], fmts, fmtcount);

	/*try others out of desperation*/
	if (!fmt)
		fmt = XR_CheckSwapFormats(tryformats[1], fmts, fmtcount);
	if (!fmt)
		fmt = XR_CheckSwapFormats(tryformats[0], fmts, fmtcount);
	if (!fmt)
		fmt = XR_CheckSwapFormats(tryformats[2], fmts, fmtcount);
	if (!fmt)
		fmt = tryformats[1][0];	//fall back on the first srgb format we know of, in the hope that the driver just failed to list it.
	return fmt;
}
static qboolean XR_Begin(void)
{
	uint32_t u;
	XrResult res;
	uint32_t swapfmts;
	int64_t *fmts, fmttouse=0;

	xr.beginning = false;
	xr.ending = false;
	xr.inputsdirty = true;

	{
		XrSessionCreateInfo sessioninfo = {XR_TYPE_SESSION_CREATE_INFO};
		sessioninfo.next = xr.bindinginfo;
		sessioninfo.createFlags = 0;
		sessioninfo.systemId = xr.systemid;
		res = xrCreateSession(xr.instance, &sessioninfo, &xr.session);
	}
	if (XR_FAILED(res))
	{
		Con_Printf("OpenXR: xrCreateSession failed (%s)\n", XR_StringForResult(res));
		return false;
	}

	{
		XrReferenceSpaceCreateInfo info = {XR_TYPE_REFERENCE_SPACE_CREATE_INFO};
		info.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_LOCAL;
		info.poseInReferenceSpace.orientation.w = 1;
		res = xrCreateReferenceSpace(xr.session, &info, &xr.space);
		if (XR_FAILED(res))
			return false;
	}

	xrEnumerateSwapchainFormats(xr.session, 0, &swapfmts, NULL);
	fmts = alloca(sizeof(*fmts)*swapfmts);
	res = xrEnumerateSwapchainFormats(xr.session, swapfmts, &swapfmts, fmts);
	if (xr.renderer == QR_HEADLESS)
		;
	else if (!swapfmts)
		Con_Printf("OpenXR: No swapchain formats to use (%s)\n", XR_StringForResult(res));
#ifdef XR_USE_GRAPHICS_API_OPENGL
	else if (xr.renderer == QR_OPENGL)
	{
		static int64_t hdrformats[] = {GL_RGBA16F,GL_RGBA32F, 0};
		static int64_t srgbformats[] = {GL_SRGB8_ALPHA8_EXT, GL_SRGB8_EXT, 0};
		static int64_t rgbformats[] = {GL_RGB10_A2, GL_RGBA8, /*broken on steamvr - GL_RGBA16_EXT,*/ GL_RGB8, 0};
		static int64_t *formats[] = {hdrformats, srgbformats, rgbformats};
		fmttouse = XR_FindSwapFormat(formats, fmts, swapfmts);
	}
#endif
#ifdef XR_USE_GRAPHICS_API_VULKAN
	else if (xr.renderer == QR_VULKAN)
	{
		static int64_t hdrformats[] = {VK_FORMAT_R16G16B16A16_SFLOAT,VK_FORMAT_R32G32B32A32_SFLOAT, VK_FORMAT_R16G16B16_SFLOAT,VK_FORMAT_R32G32B32_SFLOAT, 0};
		static int64_t srgbformats[] = {VK_FORMAT_R8G8B8A8_SRGB, VK_FORMAT_B8G8R8A8_SRGB, VK_FORMAT_R8G8B8_SRGB, VK_FORMAT_B8G8R8_SRGB, 0};
		static int64_t rgbformats[] = {VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_R8G8B8_UNORM, VK_FORMAT_B8G8R8_UNORM, 0};
		static int64_t *formats[] = {hdrformats, srgbformats, rgbformats};
		fmttouse = XR_FindSwapFormat(formats, fmts, swapfmts);
	}
#endif
#ifdef XR_USE_GRAPHICS_API_D3D11
	else if (xr.renderer == QR_DIRECT3D11)
	{
		static int64_t hdrformats[] = {DXGI_FORMAT_R16G16B16A16_FLOAT, 0};
		static int64_t srgbformats[] = {DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, DXGI_FORMAT_B8G8R8A8_UNORM_SRGB, DXGI_FORMAT_B8G8R8X8_UNORM_SRGB, 0};
		static int64_t rgbformats[] = {DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_FORMAT_B8G8R8X8_UNORM, 0};
		static int64_t *formats[] = {hdrformats, srgbformats, rgbformats};
		fmttouse = XR_FindSwapFormat(formats, fmts, swapfmts);
	}
#endif
	else
	{
		fmttouse = fmts[0];
		for (u = 0; u < swapfmts; u++)
			Con_Printf("fmt%u: %u / %x\n", u, (unsigned)fmts[u], (unsigned)fmts[u]);
	}

	xr.colourformat = fmttouse;
	for (u = 0; u < xr.viewcount; u++)
	{
		XrSwapchainCreateInfo swapinfo = {XR_TYPE_SWAPCHAIN_CREATE_INFO};
		swapinfo.createFlags = 0;
		swapinfo.usageFlags = XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT;
		swapinfo.format = fmttouse;
		swapinfo.sampleCount = 1;//xr.views->recommendedSwapchainSampleCount;
		swapinfo.width = xr.views->recommendedImageRectWidth;
		swapinfo.height = xr.views->recommendedImageRectHeight;
		swapinfo.faceCount = 1;	//2d, not a cube
		swapinfo.arraySize = 1;	//1 for 2d, a 1d array isn't allowed
		swapinfo.mipCount = 1;
		res = xrCreateSwapchain(xr.session, &swapinfo, &xr.eye[u].swapchain);
		if (XR_FAILED(res))
		{
			Con_Printf("OpenXR: xrCreateSwapchain failed (%s)\n", XR_StringForResult(res));
			return false;
		}
		res = xrEnumerateSwapchainImages(xr.eye[u].swapchain, 0, &xr.eye[u].numswapimages, NULL);
		if (XR_FAILED(res))
		{
			Con_Printf("OpenXR: xrEnumerateSwapchainImages failed (%s)\n", XR_StringForResult(res));
			return false;
		}

		//using a separate swapchain for each eye, so just depend upon npot here and use the whole image.
		xr.eye[u].subimage.imageRect.offset.x = 0;
		xr.eye[u].subimage.imageRect.offset.y = 0;
		xr.eye[u].subimage.imageRect.extent.width = swapinfo.width;
		xr.eye[u].subimage.imageRect.extent.height = swapinfo.height;
		xr.eye[u].subimage.swapchain = xr.eye[u].swapchain;
		xr.eye[u].subimage.imageArrayIndex = 0;

		//okay, this is annoying. the returned array size has different strides for different apis, etc.
		//translate it into something the relevant backend should understand.
		switch(xr.renderer)
		{
		default:
			return false;	//erk?
#ifdef XR_USE_GRAPHICS_API_D3D11
		case QR_DIRECT3D11:
			{
				uint32_t i;
				XrSwapchainImageD3D11KHR *xrimg = calloc(xr.eye[u].numswapimages, sizeof(*xrimg));
				for (i = 0; i < xr.eye[u].numswapimages; i++)
					xrimg[i].type = XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR;
				res = xrEnumerateSwapchainImages(xr.eye[u].swapchain, xr.eye[u].numswapimages, &xr.eye[u].numswapimages, (XrSwapchainImageBaseHeader*)xrimg);
				if (XR_FAILED(res))
					xr.eye[u].numswapimages = 0;

				xr.eye[u].swapimages = calloc(xr.eye[u].numswapimages, sizeof(*xr.eye[u].swapimages));
				for (i = 0; i < xr.eye[u].numswapimages; i++)
				{
					xr.eye[u].swapimages[i].ptr = xrimg[i].texture;
					xr.eye[u].swapimages[i].ptr2 = NULL;	//view
					xr.eye[u].swapimages[i].width = swapinfo.width;
					xr.eye[u].swapimages[i].height = swapinfo.height;
					xr.eye[u].swapimages[i].depth = 1;
					xr.eye[u].swapimages[i].status = TEX_LOADED;
				}
			}
			break;
#endif
#ifdef XR_USE_GRAPHICS_API_VULKAN
		case QR_VULKAN:
			{
				uint32_t i;
				XrSwapchainImageVulkanKHR *xrimg = calloc(xr.eye[u].numswapimages, sizeof(*xrimg));
				struct vk_image_s *vkimg;
				for (i = 0; i < xr.eye[u].numswapimages; i++)
					xrimg[i].type = XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR;
				res = xrEnumerateSwapchainImages(xr.eye[u].swapchain, xr.eye[u].numswapimages, &xr.eye[u].numswapimages, (XrSwapchainImageBaseHeader*)xrimg);
				if (XR_FAILED(res))
					xr.eye[u].numswapimages = 0;

				xr.eye[u].swapimages = calloc(xr.eye[u].numswapimages, sizeof(*xr.eye[u].swapimages)+sizeof(struct vk_image_s));
				vkimg = (struct vk_image_s*)&xr.eye[u].swapimages[xr.eye[u].numswapimages];
				for (i = 0; i < xr.eye[u].numswapimages; i++)
				{
					xr.eye[u].swapimages[i].vkimage = &vkimg[i];
					vkimg[i].vkformat = fmttouse;
					vkimg[i].image = xrimg[i].image;
					//vkimg[i].mem.* = 0;
					vkimg[i].view = VK_NULL_HANDLE;
					vkimg[i].sampler = VK_NULL_HANDLE;
					vkimg[i].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
					vkimg[i].width = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
					xr.eye[u].swapimages[i].width = vkimg[i].width = swapinfo.width;
					xr.eye[u].swapimages[i].height = vkimg[i].height = swapinfo.height;
					xr.eye[u].swapimages[i].depth = vkimg[i].layers = 1;
					vkimg[i].mipcount = swapinfo.mipCount;
					vkimg[i].encoding = PTI_INVALID; //blurgh, is this needed?
					vkimg[i].type = PTI_2D;
					xr.eye[u].swapimages[i].status = TEX_LOADED;
				}
			}
			break;
#endif
#ifdef XR_USE_GRAPHICS_API_OPENGL
		case QR_OPENGL:
			{
				uint32_t i;
				XrSwapchainImageOpenGLKHR *xrimg = calloc(xr.eye[u].numswapimages, sizeof(*xrimg));
				for (i = 0; i < xr.eye[u].numswapimages; i++)
					xrimg[i].type = XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_KHR;
				res = xrEnumerateSwapchainImages(xr.eye[u].swapchain, xr.eye[u].numswapimages, &xr.eye[u].numswapimages, (XrSwapchainImageBaseHeader*)xrimg);
				if (XR_FAILED(res))
					xr.eye[u].numswapimages = 0;

				xr.eye[u].swapimages = calloc(xr.eye[u].numswapimages, sizeof(*xr.eye[u].swapimages));
				for (i = 0; i < xr.eye[u].numswapimages; i++)
				{
					xr.eye[u].swapimages[i].format = swapinfo.format;
					xr.eye[u].swapimages[i].num = xrimg[i].image;
					xr.eye[u].swapimages[i].width = swapinfo.width;
					xr.eye[u].swapimages[i].height = swapinfo.height;
					xr.eye[u].swapimages[i].depth = 1;
					xr.eye[u].swapimages[i].status = TEX_LOADED;
				}
			}
			break;
#endif
		}
	}
	if (XR_FAILED(res))
		return false;

	XR_SetupInputs_Session();

	return true;
}

static void XR_ProcessEvents(void)
{
	XrEventDataBuffer ev;
	XrResult res;
	for (;;)
	{
		ev.type = XR_TYPE_EVENT_DATA_BUFFER;
		ev.next = NULL;
		res = xrPollEvent(xr.instance, &ev);
		if (res == XR_EVENT_UNAVAILABLE || XR_FAILED(res))
			return;	//nothing interesting here folks

		switch(ev.type)
		{
		default:	//no idea wtf that is
			Con_Printf("openxr event %u\n", ev.type);
			break;

		case XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING:
			XR_Shutdown();	//we're meant to try restarting, but that's a hassle. FIXME: expect the user to do a vid_restart.
			return;

		case XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING:
			break;
		case XR_TYPE_EVENT_DATA_EVENTS_LOST:
			{
				XrEventDataEventsLost *s = (XrEventDataEventsLost*)&ev;
				Con_Printf(CON_ERROR"OpenXR: Lost %u events!\n", s->lostEventCount);
			}
			break;
		case XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED:
			xr.inputsdirty = true;
			break;

		case XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED:
			{
				XrEventDataSessionStateChanged *s = (XrEventDataSessionStateChanged*)&ev;
				xr.state = s->state;
				return;	//make sure the outer loop actually sees each state change.
			}
			break;
		}
	}
}
static qboolean XR_SyncFrame(double *frametime)
{
	XrResult res;

	if (!xr.instance)
		return false;

	if (xr.needrender)
	{	//something screwed up.
//		*frametime = 0;
		return true;
	}

	if (!xr.session)
	{
		if (xr_enable->ival && !XR_Begin())
		{
			XR_Shutdown();
			return false;
		}
	}
	else
	{
		if (!xr_enable->ival && !xr.ending)
		{	//user doesn't want a session apparently. try and end the current session cleanly.
			res = xrRequestExitSession(xr.session);
			if (XR_FAILED(res))
				Con_Printf("openxr: Unable to request session end: %s\n", XR_StringForResult(res));
			xr.ending = true;
		}
	}

	XR_ProcessEvents();

	memset(&xr.framestate, 0, sizeof(xr.framestate));
	xr.framestate.type = XR_TYPE_FRAME_STATE;
	safeswitch(xr.state)
	{
	case XR_SESSION_STATE_IDLE:		//not allowed to progress till the user puts it on their head/etc
		xr.beginning = false;
		break;
	case XR_SESSION_STATE_READY:
		if (!xr.beginning)
		{
			XrSessionBeginInfo info = {XR_TYPE_SESSION_BEGIN_INFO};
			info.primaryViewConfigurationType = xr.viewtype;
			res = xrBeginSession(xr.session, &info);
			if (XR_FAILED(res))
				Con_Printf("Unable to begin session: %s\n", XR_StringForResult(res));
			xr.beginning = true;	//begin our xr loop... (and/or stop the spam just above)
		}
		break;
	case XR_SESSION_STATE_SYNCHRONIZED:	//no rendering or input yet
	case XR_SESSION_STATE_VISIBLE:		//now generating video frames, but no input yet
	case XR_SESSION_STATE_FOCUSED:		//we have inputs! (and still generating video frames)
		break;
	case XR_SESSION_STATE_STOPPING:		//going back to idle (user took it off their head). we'll go back to rendering to our window again.
		xrEndSession(xr.session);
		xr.beginning = false;
		break;
	case XR_SESSION_STATE_LOSS_PENDING:	//terminate for now. recreate later if you want.
		XR_SessionEnded();	//destroys the session but not the instance, so it can be started up again if desired.
		xr.beginning = false;
		break;
	case XR_SESSION_STATE_EXITING:		//terminate with prejudice.
		XR_SessionEnded();
		xr.beginning = false;
		if (!xr.ending)
			XR_Shutdown();	//this doesn't look like one we requested... don't let it start back up again.
		break;
	case XR_SESSION_STATE_UNKNOWN:
	case XR_SESSION_STATE_MAX_ENUM:
	safedefault:
		xr.beginning = false;	//some weird error.
		break;
	}

	if (xr.beginning)
	{
		XrTime time;
		res = xrWaitFrame(xr.session, NULL, &xr.framestate);
		if (XR_FAILED(res))
		{
			Con_Printf("xrWaitFrame: %s\n", XR_StringForResult(res));
			return false;
		}
		time = xr.framestate.predictedDisplayTime;
		if (xr.timeknown)
		{
			if (time < xr.time)	//make sure time doesn't go backward...
				time = xr.time;
			*frametime = NANOSECONDS_TO_SECONDS(time-xr.time);
		}
		xr.time = time;
		xr.timeknown = true;

		xr.needrender = true;
	}

	if (xr.session)
		XR_UpdateInputs(xr.framestate.predictedDisplayTime);

	return true;
}
static qboolean XR_Render(void(*rendereye)(texid_t tex, vec4_t fovoverride, vec3_t angorg[2]))
{
	XrFrameEndInfo endframeinfo = {XR_TYPE_FRAME_END_INFO};
	unsigned int u;
	XrResult res;

	XrCompositionLayerProjection proj = {XR_TYPE_COMPOSITION_LAYER_PROJECTION};
	const XrCompositionLayerBaseHeader *projlist[] = {(XrCompositionLayerBaseHeader*)&proj};
	XrCompositionLayerProjectionView projviews[MAX_VIEW_COUNT];

	if (!xr.instance)
		return false;	//err... noooes!

	if (!xr.session || !xr.beginning)
		return false;

	if (xr.inputsdirty && xr.state==XR_SESSION_STATE_FOCUSED)
	{
		xr.inputsdirty = false;
		if (xr_debug->ival)
			XR_PrintInputs();
	}
#ifdef XR_EXT_hand_tracking
	for (u = 0; u < 2; u++)
	{
		vec3_t ang, org;
		unsigned int j;
		static const char *jointnames[] = {
			"PALM",
			"WRIST",
			"THUMB_METACARPAL",
			"THUMB_PROXIMAL",
			"THUMB_DISTAL",
			"THUMB_TIP",
			"INDEX_METACARPAL",
			"INDEX_PROXIMAL",
			"INDEX_INTERMEDIATE",
			"INDEX_DISTAL",
			"INDEX_TIP",
			"MIDDLE_METACARPAL",
			"MIDDLE_PROXIMAL",
			"MIDDLE_INTERMEDIATE",
			"MIDDLE_DISTAL",
			"MIDDLE_TIP",
			"RING_METACARPAL",
			"RING_PROXIMAL",
			"RING_INTERMEDIATE",
			"RING_DISTAL",
			"RING_TIP",
			"LITTLE_METACARPAL",
			"LITTLE_PROXIMAL",
			"LITTLE_INTERMEDIATE",
			"LITTLE_DISTAL",
			"LITTLE_TIP",
		};
		XrHandJointsLocateInfoEXT info = {XR_TYPE_HAND_JOINTS_LOCATE_INFO_EXT};
		XrHandJointLocationsEXT loc = {XR_TYPE_HAND_JOINT_LOCATIONS_EXT};
		XrHandJointVelocitiesEXT vel = {XR_TYPE_HAND_JOINT_VELOCITIES_EXT};
		loc.next = &vel;
		loc.jointCount = countof(xr.hand[u].jointloc);
		loc.jointLocations = xr.hand[u].jointloc;

		vel.next = &vel;
		vel.jointCount = countof(xr.hand[u].jointvel);
		vel.jointVelocities = xr.hand[u].jointvel;

		if (xr.hand[u].handle)
			xrLocateHandJointsEXT(xr.hand[u].handle, &info, &loc);
		xr.hand[u].active = loc.isActive;

		if (!xr.hand[u].active || !xr_debug->ival)
			continue;
		for (j = 0; j < countof(jointnames); j++)
		{
			if (!xr.hand[u].jointloc[j].locationFlags && !xr.hand[u].jointvel[j].velocityFlags)
				continue;
			XR_PoseToAngOrg(&xr.hand[u].jointloc[j].pose, ang, org);

			Con_Printf("%s %s: (%g %g %g) [%g %g %g] %g (%g %g %g) [%g %g %g]\n", u?"Right":"Left", jointnames[j],
				ang[0],ang[1],ang[2],org[0],org[1],org[2], xr.hand[u].jointloc[j].radius,
				xr.hand[u].jointvel[j].angularVelocity.x,xr.hand[u].jointvel[j].angularVelocity.y,xr.hand[u].jointvel[j].angularVelocity.z,
				xr.hand[u].jointvel[j].linearVelocity.x,xr.hand[u].jointvel[j].linearVelocity.y,xr.hand[u].jointvel[j].linearVelocity.z);
		}
	}
#endif

	if (!xr.needrender)
		return false;	//xrWaitFrame not called?
	xr.needrender = false;

	res = xrBeginFrame(xr.session, NULL);
	if (XR_FAILED(res))
	{
		Con_Printf("xrBeginFrame: %s\n", XR_StringForResult(res));
		if(res == XR_ERROR_SESSION_LOST)
			XR_SessionEnded();
		else
			XR_Shutdown();
		return false;
	}
	if (xr.framestate.shouldRender)
	{
		uint32_t eyecount;
		XrViewState viewstate = {XR_TYPE_VIEW_STATE};
		XrViewLocateInfo locateinfo = {XR_TYPE_VIEW_LOCATE_INFO};
		XrView eyeview[MAX_VIEW_COUNT]={};
		for (u = 0; u < MAX_VIEW_COUNT; u++)
			eyeview[u].type = XR_TYPE_VIEW;

		locateinfo.displayTime = xr.framestate.predictedDisplayTime;
		locateinfo.space = xr.space;
		res = xrLocateViews(xr.session, &locateinfo, &viewstate, xr.viewcount, &eyecount, eyeview);
		if (XR_FAILED(res))
			Con_Printf("xrLocateViews: %s\n", XR_StringForResult(res));

		proj.layerFlags = 0;
		proj.space = xr.space;
		proj.views = projviews;
		endframeinfo.layerCount = 1;

		//set up the head position, as an average of all the eyes, the eyes, the awful knowing eyes...
		{
			float scale;
			vec3_t ang, org;
			XrPosef apose = {0};
			for (u = 0; u < xr.viewcount && u < eyecount; u++)
			{	//add em up
				apose.orientation.x += eyeview[u].pose.orientation.x;
				apose.orientation.y += eyeview[u].pose.orientation.y;
				apose.orientation.z += eyeview[u].pose.orientation.z;
				apose.orientation.w += eyeview[u].pose.orientation.w;
				apose.position.x += eyeview[u].pose.position.x;
				apose.position.y += eyeview[u].pose.position.y;
				apose.position.z += eyeview[u].pose.position.z;
			}
			//normalize them
			scale = 1 / sqrt(apose.orientation.x*apose.orientation.x+apose.orientation.y*apose.orientation.y+apose.orientation.z*apose.orientation.z+apose.orientation.w*apose.orientation.w);
			apose.orientation.x *= scale;
			apose.orientation.y *= scale;
			apose.orientation.z *= scale;
			apose.orientation.w *= scale;
			apose.position.x /= xr.viewcount;
			apose.position.y /= xr.viewcount;
			apose.position.z /= xr.viewcount;
			XR_PoseToAngOrg(&apose, ang, org);
			inputfuncs->SetHandPosition("head", org, ang, NULL, NULL);
		}

		for (u = 0; u < xr.viewcount && u < eyecount; u++)
		{
			vec4_t fovoverride;
			XrSwapchainImageWaitInfo waitinfo = {XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO};
			unsigned int imgidx = 0;
			vec3_t orientation[2];
			res = xrAcquireSwapchainImage(xr.eye[u].swapchain, NULL, &imgidx);
			if (XR_FAILED(res))
				Con_Printf("xrAcquireSwapchainImage: %s\n", XR_StringForResult(res));

			memset(&projviews[u], 0, sizeof(projviews[u]));
			projviews[u].type = XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW;
			projviews[u].pose = eyeview[u].pose;
			projviews[u].fov = eyeview[u].fov;
			projviews[u].subImage = xr.eye[u].subimage;

			XR_PoseToAngOrg(&eyeview[u].pose, orientation[0], orientation[1]);

			fovoverride[0] = eyeview[u].fov.angleLeft * (180/M_PI);
			fovoverride[1] = eyeview[u].fov.angleRight * (180/M_PI);
			fovoverride[2] = eyeview[u].fov.angleDown * (180/M_PI);
			fovoverride[3] = eyeview[u].fov.angleUp * (180/M_PI);

			waitinfo.timeout = SECONDS_TO_NANOSECONDS(0.1);
			res = xrWaitSwapchainImage(xr.eye[u].swapchain, &waitinfo);
			if (XR_FAILED(res))
				Con_Printf("xrWaitSwapchainImage: %s\n", XR_StringForResult(res));
			rendereye(&xr.eye[u].swapimages[imgidx], fovoverride, orientation);
			//GL note: the OpenXR specification says NOTHING about the application having to glFlush or glFinish.
			//	I take this to mean that the openxr runtime is responsible for setting up barriers or w/e inside ReleaseSwapchainImage.
			//VK note: the OpenXR spec does say that it needs to be color_attachment_optimal+owned by queue. which it is.
			//	I take this to mean that the openxr runtime is responsible for barriers (as it'll need to transition it to general or shader-read anyway).
			res = xrReleaseSwapchainImage(xr.eye[u].swapchain, NULL);
			if (XR_FAILED(res))
				Con_Printf("xrReleaseSwapchainImage: %s\n", XR_StringForResult(res));
		}
		proj.viewCount = u;
	}

	endframeinfo.layers = projlist;
	endframeinfo.displayTime = xr.framestate.predictedDisplayTime;
	endframeinfo.environmentBlendMode = XR_ENVIRONMENT_BLEND_MODE_OPAQUE;	//we don't do the alpha channel very well.
	res = xrEndFrame(xr.session, &endframeinfo);
	if (XR_FAILED(res))
	{
		Con_Printf("xrEndFrame: %s\n", XR_StringForResult(res));
		if (res == XR_ERROR_SESSION_LOST || res == XR_ERROR_SESSION_NOT_RUNNING || res == XR_ERROR_SWAPCHAIN_RECT_INVALID)
			XR_SessionEnded();	//something sessiony
		else //if (res == XR_ERROR_INSTANCE_LOST)
			XR_Shutdown();	//don't really know what it was, just kill everything
	}

	return xr_skipregularview->ival;
}

static plugvrfuncs_t openxr =
{
	"OpenXR",
	XR_PreInit,
	XR_Init,
	XR_SyncFrame,
	XR_Render,
	XR_Shutdown,
};

qboolean Plug_Init(void)
{
#ifdef XR_NO_PROTOTYPES
	{
		static dllhandle_t *lib;
		static dllfunction_t funcs[] = {
			#define XRFUNC(n) {(void*)&n, #n},
				XRFUNCS
			#undef XRFUNC
			{NULL}};
#ifdef _WIN32
	#define XR_LOADER_LIBNAME "openxr_loader"ARCH_DL_POSTFIX
#else
	#define XR_LOADER_LIBNAME "libopenxr_loader"ARCH_DL_POSTFIX".1"
#endif
		if (!lib)
			lib = plugfuncs->LoadDLL(XR_LOADER_LIBNAME, funcs);
		if (!lib)
		{
			Con_Printf(CON_ERROR"OpenXR: Unable to load "XR_LOADER_LIBNAME"\n");
			return false;
		}
	}
#endif

	fsfuncs = plugfuncs->GetEngineInterface(plugfsfuncs_name, sizeof(*fsfuncs));
	inputfuncs = plugfuncs->GetEngineInterface(pluginputfuncs_name, sizeof(*inputfuncs));
	plugfuncs->ExportFunction("MayUnload", XR_PluginMayUnload);
	if (plugfuncs->ExportInterface(plugvrfuncs_name, &openxr, sizeof(openxr)))
	{
		xr_enable			= cvarfuncs->GetNVFDG("xr_enable",			"1",			0,				"Controls whether to use openxr rendering or not.",									"OpenXR configuration");
		xr_debug			= cvarfuncs->GetNVFDG("xr_debug",			"0",			0,				"Controls whether to spam debug info or not.",										"OpenXR configuration");
		xr_formfactor		= cvarfuncs->GetNVFDG("xr_formfactor",		"head",			CVAR_ARCHIVE,	"Controls which VR system to try to use. Valid options are head, or hand",			"OpenXR configuration");
		xr_viewconfig		= cvarfuncs->GetNVFDG("xr_viewconfig",		"",				CVAR_ARCHIVE,	"Controls the type of view we aim for. Valid options are mono, stereo, or quad",	"OpenXR configuration");
		xr_metresize		= cvarfuncs->GetNVFDG("xr_metresize",		"26.24671916",	CVAR_ARCHIVE,	"Size of a metre in game units",													"OpenXR configuration");
		xr_skipregularview	= cvarfuncs->GetNVFDG("xr_skipregularview", "1",			CVAR_ARCHIVE,	"Skip rendering the regular view when OpenXR is active.",							"OpenXR configuration");
		xr_fingertracking	= cvarfuncs->GetNVFDG("xr_fingertracking",	"0",			0,	"Attempt to track individual finger joints.",													"OpenXR configuration");
		return true;
	}
	return false;
}