TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-02-12 19:31:41 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Improvements to openvr code

Browse source 
- Overlays are implemented (sans input for the moment)
- Fixed a problem where the movemanager was using the wrong values for hmd rotation & position
This commit is contained in:
James Urquhart 2016-05-14 23:51:04 +01:00
parent 185fde8ea4
commit da6bcbeb2b
13 changed files with 380 additions and 32 deletions
Download patch file Download diff file Expand all files Collapse all files

1
Engine/source/gfx/D3D11/gfxD3D11EnumTranslate.cpp
View file

@ -73,6 +73,7 @@ void GFXD3D11EnumTranslate::init()
GFXD3D11TextureFormat[GFXFormatD24FS8] = DXGI_FORMAT_UNKNOWN;
GFXD3D11TextureFormat[GFXFormatD16] = DXGI_FORMAT_D16_UNORM;
GFXD3D11TextureFormat[GFXFormatR8G8B8A8_SRGB] = DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
GFXD3D11TextureFormat[GFXFormatR8G8B8A8_LINEAR_FORCE] = DXGI_FORMAT_R8G8B8A8_UNORM;
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
GFXD3D11TextureFilter[GFXTextureFilterNone] = D3D11_FILTER_MIN_MAG_MIP_POINT;

12
Engine/source/gfx/D3D11/gfxD3D11TextureObject.cpp
View file

@ -67,12 +67,6 @@ GFXLockedRect *GFXD3D11TextureObject::lock(U32 mipLevel /*= 0*/, RectI *inRect /
D3D11_MAPPED_SUBRESOURCE mapInfo;
/*if (!mProfile->canModify())
{
AssertFatal(false, "Tried to modify external texture");
return NULL;
}*/
if( mProfile->isRenderTarget() )
{
//AssertFatal( 0, "GFXD3D11TextureObject::lock - Need to handle mapping render targets" );
@ -186,8 +180,8 @@ bool GFXD3D11TextureObject::copyToBmp(GBitmap* bmp)
// check format limitations
// at the moment we only support RGBA for the source (other 4 byte formats should
// be easy to add though)
AssertFatal(mFormat == GFXFormatR8G8B8A8, "copyToBmp: invalid format");
if (mFormat != GFXFormatR8G8B8A8)
AssertFatal(mFormat == GFXFormatR8G8B8A8 || mFormat == GFXFormatR8G8B8A8_LINEAR_FORCE, "copyToBmp: invalid format");
if (mFormat != GFXFormatR8G8B8A8 && mFormat != GFXFormatR8G8B8A8_LINEAR_FORCE)
return false;
PROFILE_START(GFXD3D11TextureObject_copyToBmp);
@ -203,7 +197,7 @@ bool GFXD3D11TextureObject::copyToBmp(GBitmap* bmp)
const U32 sourceBytesPerPixel = 4;
U32 destBytesPerPixel = 0;
if(bmp->getFormat() == GFXFormatR8G8B8A8)
if (bmp->getFormat() == GFXFormatR8G8B8A8 || bmp->getFormat() == GFXFormatR8G8B8A8_LINEAR_FORCE)
destBytesPerPixel = 4;
else if(bmp->getFormat() == GFXFormatR8G8B8)
destBytesPerPixel = 3;

2
Engine/source/gfx/D3D9/pc/gfxD3D9EnumTranslate.pc.cpp
View file

@ -115,6 +115,8 @@ void GFXD3D9EnumTranslate::init()
GFXD3D9TextureFormat[GFXFormatD24FS8] = D3DFMT_D24FS8;
GFXD3D9TextureFormat[GFXFormatD16] = D3DFMT_D16;
GFXD3D9TextureFormat[GFXFormatR8G8B8A8_SRGB] = D3DFMT_UNKNOWN;
GFXD3D9TextureFormat[GFXFormatR8G8B8A8_LINEAR_FORCE] = D3DFMT_A8R8G8B8;
VALIDATE_LOOKUPTABLE( GFXD3D9TextureFormat, GFXFormat);
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

1
Engine/source/gfx/bitmap/gBitmap.cpp
View file

@ -293,6 +293,7 @@ void GBitmap::allocateBitmap(const U32 in_width, const U32 in_height, const bool
break;
case GFXFormatR8G8B8: mBytesPerPixel = 3;
break;
case GFXFormatR8G8B8A8_LINEAR_FORCE:
case GFXFormatR8G8B8X8:
case GFXFormatR8G8B8A8: mBytesPerPixel = 4;
break;

7
Engine/source/gfx/bitmap/loaders/bitmapPng.cpp
View file

@ -328,13 +328,14 @@ static bool _writePNG(GBitmap *bitmap, Stream &stream, U32 compressionLevel, U32
format == GFXFormatR8G8B8A8 ||
format == GFXFormatR8G8B8X8 ||
format == GFXFormatA8 ||
format == GFXFormatR5G6B5, "_writePNG: ONLY RGB bitmap writing supported at this time.");
format == GFXFormatR5G6B5 ||
format == GFXFormatR8G8B8A8_LINEAR_FORCE, "_writePNG: ONLY RGB bitmap writing supported at this time.");
if ( format != GFXFormatR8G8B8 &&
format != GFXFormatR8G8B8A8 &&
format != GFXFormatR8G8B8X8 &&
format != GFXFormatA8 &&
format != GFXFormatR5G6B5 )
format != GFXFormatR5G6B5 && format != GFXFormatR8G8B8A8_LINEAR_FORCE)
return false;
png_structp png_ptr = png_create_write_struct_2(PNG_LIBPNG_VER_STRING,
@ -381,7 +382,7 @@ static bool _writePNG(GBitmap *bitmap, Stream &stream, U32 compressionLevel, U32
NULL, // compression type
NULL); // filter type
}
else if (format == GFXFormatR8G8B8A8 || format == GFXFormatR8G8B8X8)
else if (format == GFXFormatR8G8B8A8 || format == GFXFormatR8G8B8X8 || format == GFXFormatR8G8B8A8_LINEAR_FORCE)
{
png_set_IHDR(png_ptr, info_ptr,
width, height, // the width & height

9
Engine/source/gfx/gfxEnums.h
View file

@ -192,6 +192,12 @@ enum GFXFormat
GFXFormatD24S8,
GFXFormatD24FS8,
// sRGB formats
GFXFormatR8G8B8A8_SRGB,
// Guaranteed RGBA8 (for apis which really dont like bgr)
GFXFormatR8G8B8A8_LINEAR_FORCE,
// 64 bit texture formats...
GFXFormatR16G16B16A16,// first in group...
GFXFormatR16G16B16A16F,
@ -206,9 +212,6 @@ enum GFXFormat
GFXFormatDXT4,
GFXFormatDXT5,
// sRGB formats
GFXFormatR8G8B8A8_SRGB,
GFXFormat_COUNT,
GFXFormat_8BIT = GFXFormatA8,

11
Engine/source/gui/core/guiOffscreenCanvas.cpp
View file

@ -176,7 +176,7 @@ void GuiOffscreenCanvas::renderFrame(bool preRenderOnly, bool bufferSwap /* = tr
GFX->setWorldMatrix( MatrixF::Identity );
GFX->setViewMatrix( MatrixF::Identity );
GFX->setProjectionMatrix( MatrixF::Identity );
RectI contentRect(Point2I(0,0), mTargetSize);
{
// Render active GUI Dialogs
@ -210,7 +210,7 @@ void GuiOffscreenCanvas::renderFrame(bool preRenderOnly, bool bufferSwap /* = tr
GFX->getDrawUtil()->clearBitmapModulation();
}
mTarget->resolve();
GFX->popActiveRenderTarget();
@ -219,6 +219,13 @@ void GuiOffscreenCanvas::renderFrame(bool preRenderOnly, bool bufferSwap /* = tr
// Keep track of the last time we rendered.
mLastRenderMs = Platform::getRealMilliseconds();
mTargetDirty = mDynamicTarget;
onFrameRendered();
}
void GuiOffscreenCanvas::onFrameRendered()
{
}
Point2I GuiOffscreenCanvas::getWindowSize()

1
Engine/source/gui/core/guiOffscreenCanvas.h
View file

@ -23,6 +23,7 @@ public:
void onRemove();
void renderFrame(bool preRenderOnly, bool bufferSwap);
virtual void onFrameRendered();
Point2I getWindowSize();

307
Engine/source/platform/input/openVR/openVROverlay.cpp
View file

@ -1,5 +1,18 @@
#include "platform/input/openVR/openVRProvider.h"
#include "platform/input/openVR/openVROverlay.h"
#include "gfx/D3D11/gfxD3D11Device.h"
#include "gfx/D3D11/gfxD3D11TextureObject.h"
#include "gfx/D3D11/gfxD3D11EnumTranslate.h"
#ifdef TORQUE_OPENGL
#include "gfx/gl/gfxGLDevice.h"
#include "gfx/gl/gfxGLTextureObject.h"
#include "gfx/gl/gfxGLEnumTranslate.h"
#endif
#include "postFx/postEffectCommon.h"
ImplementEnumType(OpenVROverlayType,
"Desired overlay type for OpenVROverlay. .\n\n"
"@ingroup OpenVR")
@ -7,9 +20,18 @@ ImplementEnumType(OpenVROverlayType,
{ OpenVROverlay::OVERLAYTYPE_DASHBOARD, "Dashboard" },
EndImplementEnumType;
IMPLEMENT_CONOBJECT(OpenVROverlay);
OpenVROverlay::OpenVROverlay()
{
mTransform = MatrixF(1);
mOverlayWidth = 1.5f;
mOverlayFlags = 0;
mOverlayColor = ColorF(1, 1, 1, 1);
mTrackingOrigin = vr::TrackingUniverseSeated;
mTargetFormat = GFXFormatR8G8B8A8_LINEAR_FORCE; // needed for openvr!
}
OpenVROverlay::~OpenVROverlay()
@ -17,8 +39,53 @@ OpenVROverlay::~OpenVROverlay()
}
static bool setProtectedOverlayTypeDirty(void *obj, const char *array, const char *data)
{
OpenVROverlay *object = static_cast<OpenVROverlay*>(obj);
object->mOverlayTypeDirty = true;
return true;
}
static bool setProtectedOverlayDirty(void *obj, const char *array, const char *data)
{
OpenVROverlay *object = static_cast<OpenVROverlay*>(obj);
object->mOverlayDirty = true;
return true;
}
void OpenVROverlay::initPersistFields()
{
addProtectedField("overlayType", TypeOpenVROverlayType, Offset(mOverlayType, OpenVROverlay), &setProtectedOverlayTypeDirty, &defaultProtectedGetFn,
"Type of overlay.");
addProtectedField("overlayFlags", TypeS32, Offset(mOverlayFlags, OpenVROverlay), &setProtectedOverlayDirty, &defaultProtectedGetFn,
"Flags for overlay.");
addProtectedField("overlayWidth", TypeS32, Offset(mOverlayWidth, OpenVROverlay), &setProtectedOverlayDirty, &defaultProtectedGetFn,
"Width of overlay.");
addProtectedField("overlayColor", TypeColorF, Offset(mOverlayColor, OpenVROverlay), &setProtectedOverlayDirty, &defaultProtectedGetFn,
"Backing color of overlay.");
addProtectedField("transformType", TypeOpenVROverlayTransformType, Offset(mOverlayTransformType, OpenVROverlay), &setProtectedOverlayDirty, &defaultProtectedGetFn,
"Transform type of overlay.");
addProtectedField("transformPosition", TypeMatrixPosition, Offset(mTransform, OpenVROverlay), &setProtectedOverlayDirty, &defaultProtectedGetFn,
"Position of overlay.");
addProtectedField("transformRotation", TypeMatrixRotation, Offset(mTransform, OpenVROverlay), &setProtectedOverlayDirty, &defaultProtectedGetFn,
"Rotation of overlay.");
addProtectedField("transformDeviceIndex", TypeS32, Offset(mTransformDeviceIndex, OpenVROverlay), &setProtectedOverlayDirty, &defaultProtectedGetFn,
"Rotation of overlay.");
addProtectedField("transformDeviceComponent", TypeString, Offset(mTransformDeviceComponent, OpenVROverlay), &setProtectedOverlayDirty, &defaultProtectedGetFn,
"Rotation of overlay.");
addProtectedField("inputMethod", TypeOpenVROverlayInputMethod, Offset(mTransformDeviceComponent, OpenVROverlay), &setProtectedOverlayDirty, &defaultProtectedGetFn,
"Type of input method.");
addProtectedField("mouseScale", TypePoint2F, Offset(mMouseScale, OpenVROverlay), &setProtectedOverlayDirty, &defaultProtectedGetFn,
"Scale of mouse input.");
addProtectedField("trackingOrigin", TypeOpenVRTrackingUniverseOrigin, Offset(mTrackingOrigin, OpenVROverlay), &setProtectedOverlayDirty, &defaultProtectedGetFn,
"Tracking origin.");
addProtectedField("controllerDevice", TypeS32, Offset(mControllerDeviceIndex, OpenVROverlay), &setProtectedOverlayDirty, &defaultProtectedGetFn,
"Index of controller to attach overlay to.");
Parent::initPersistFields();
}
@ -41,11 +108,49 @@ void OpenVROverlay::onRemove()
vr::VROverlay()->DestroyOverlay(mOverlayHandle);
mOverlayHandle = NULL;
}
if (mThumbOverlayHandle)
{
vr::VROverlay()->DestroyOverlay(mThumbOverlayHandle);
mThumbOverlayHandle = NULL;
}
}
void OpenVROverlay::resetOverlay()
{
vr::IVROverlay *overlay = vr::VROverlay();
if (!overlay)
return;
if (mOverlayHandle)
{
overlay->DestroyOverlay(mOverlayHandle);
mOverlayHandle = NULL;
}
if (mThumbOverlayHandle)
{
overlay->DestroyOverlay(mThumbOverlayHandle);
mThumbOverlayHandle = NULL;
}
if (mOverlayType == OpenVROverlay::OVERLAYTYPE_DASHBOARD)
{
overlay->CreateDashboardOverlay(mInternalName, mInternalName, &mOverlayHandle, &mThumbOverlayHandle);
}
else
{
overlay->CreateOverlay(mInternalName, mInternalName, &mOverlayHandle);
}
mOverlayDirty = true;
mOverlayTypeDirty = false;
// Pre-render start frame so we have a texture available
if (!mTarget)
{
renderFrame(false, false);
}
}
void OpenVROverlay::updateOverlay()
@ -53,16 +158,74 @@ void OpenVROverlay::updateOverlay()
if (mOverlayTypeDirty)
resetOverlay();
// Update params TODO
// Update params
vr::IVROverlay *overlay = vr::VROverlay();
if (!overlay || !mOverlayHandle)
return;
if (!mOverlayDirty)
return;
MatrixF vrMat(1);
vr::HmdMatrix34_t ovrMat;
vr::HmdVector2_t ovrMouseScale;
ovrMouseScale.v[0] = mMouseScale.x;
ovrMouseScale.v[1] = mMouseScale.y;
OpenVRUtil::convertTransformToOVR(mTransform, vrMat);
OpenVRUtil::convertMatrixFPlainToSteamVRAffineMatrix(vrMat, ovrMat);
MatrixF reverseMat = OpenVRUtil::convertSteamVRAffineMatrixToMatrixFPlain(ovrMat);
MatrixF finalReverseMat(1);
OpenVRUtil::convertTransformFromOVR(reverseMat, finalReverseMat);
switch (mOverlayTransformType)
{
case vr::VROverlayTransform_Absolute:
overlay->SetOverlayTransformAbsolute(mOverlayHandle, mTrackingOrigin, &ovrMat);
break;
case vr::VROverlayTransform_TrackedDeviceRelative:
overlay->SetOverlayTransformTrackedDeviceRelative(mOverlayHandle, mTransformDeviceIndex, &ovrMat);
break;
case vr::VROverlayTransform_TrackedComponent:
overlay->SetOverlayTransformTrackedDeviceComponent(mOverlayHandle, mTransformDeviceIndex, mTransformDeviceComponent.c_str());
break;
// NOTE: system not handled here - doesn't seem possible to create these
default:
break;
}
// overlay->SetOverlayColor(mOverlayHandle, mOverlayColor.red, mOverlayColor.green, mOverlayColor.blue);
overlay->SetOverlayAlpha(mOverlayHandle, mOverlayColor.alpha);
overlay->SetOverlayMouseScale(mOverlayHandle, &ovrMouseScale);
overlay->SetOverlayInputMethod(mOverlayHandle, mInputMethod);
overlay->SetOverlayWidthInMeters(mOverlayHandle, mOverlayWidth);
// NOTE: if flags in openvr change, double check this
/*for (U32 i = vr::VROverlayFlags_None; i <= vr::VROverlayFlags_ShowTouchPadScrollWheel; i++)
{
overlay->SetOverlayFlag(mOverlayHandle, (vr::VROverlayFlags)i, mOverlayFlags & (1 << i));
}*/
mOverlayDirty = false;
}
void OpenVROverlay::showOverlay()
{
updateOverlay();
if (mOverlayHandle == NULL)
return;
vr::VROverlay()->ShowOverlay(mOverlayHandle);
vr::EVROverlayError err = vr::VROverlay()->ShowOverlay(mOverlayHandle);
if (err != vr::VROverlayError_None)
{
Con::errorf("VR Overlay error!");
}
if (!mStagingTexture)
{
renderFrame(false, false);
}
}
void OpenVROverlay::hideOverlay()
@ -104,7 +267,7 @@ bool OpenVROverlay::isActiveDashboardOverlay()
return false; // TODO WHERE DID I GET THIS FROM
}
MatrixF OpenVROverlay::getTransformForOverlayCoordinates(const vr::ETrackingUniverseOrigin trackingOrigin, const Point2F &pos)
MatrixF OpenVROverlay::getTransformForOverlayCoordinates(const Point2F &pos)
{
if (mOverlayHandle == NULL)
return MatrixF::Identity;
@ -114,7 +277,7 @@ MatrixF OpenVROverlay::getTransformForOverlayCoordinates(const vr::ETrackingUniv
vec.v[1] = pos.y;
vr::HmdMatrix34_t outMat;
MatrixF outTorqueMat;
if (vr::VROverlay()->GetTransformForOverlayCoordinates(mOverlayHandle, trackingOrigin, vec, &outMat) != vr::VROverlayError_None)
if (vr::VROverlay()->GetTransformForOverlayCoordinates(mOverlayHandle, mTrackingOrigin, vec, &outMat) != vr::VROverlayError_None)
return MatrixF::Identity;
MatrixF vrMat(1);
@ -123,7 +286,7 @@ MatrixF OpenVROverlay::getTransformForOverlayCoordinates(const vr::ETrackingUniv
return outTorqueMat;
}
bool OpenVROverlay::castRay(const vr::ETrackingUniverseOrigin trackingOrigin, const Point3F &origin, const Point3F &direction, RayInfo *info)
bool OpenVROverlay::castRay(const Point3F &origin, const Point3F &direction, RayInfo *info)
{
if (mOverlayHandle == NULL)
return false;
@ -131,7 +294,7 @@ bool OpenVROverlay::castRay(const vr::ETrackingUniverseOrigin trackingOrigin, c
vr::VROverlayIntersectionParams_t params;
vr::VROverlayIntersectionResults_t result;
params.eOrigin = trackingOrigin;
params.eOrigin = mTrackingOrigin;
params.vSource.v[0] = origin.x;
params.vSource.v[1] = origin.y;
params.vSource.v[2] = origin.z;
@ -159,3 +322,135 @@ void OpenVROverlay::moveGamepadFocusToNeighbour()
}
void OpenVROverlay::handleOpenVREvents()
{
vr::VREvent_t vrEvent;
while (vr::VROverlay()->PollNextOverlayEvent(mOverlayHandle, &vrEvent, sizeof(vrEvent)))
{
InputEventInfo eventInfo;
eventInfo.deviceType = MouseDeviceType;
eventInfo.deviceInst = 0;
eventInfo.objType = SI_AXIS;
eventInfo.modifier = (InputModifiers)0;
eventInfo.ascii = 0;
switch (vrEvent.eventType)
{
case vr::VREvent_MouseMove:
{
eventInfo.objType = SI_AXIS;
eventInfo.objInst = SI_XAXIS;
eventInfo.action = SI_MAKE;
eventInfo.fValue = vrEvent.data.mouse.x;
processMouseEvent(eventInfo);
eventInfo.objType = SI_AXIS;
eventInfo.objInst = SI_YAXIS;
eventInfo.action = SI_MAKE;
eventInfo.fValue = vrEvent.data.mouse.y;
processMouseEvent(eventInfo);
}
break;
case vr::VREvent_MouseButtonDown:
{
eventInfo.objType = SI_BUTTON;
eventInfo.objInst = (InputObjectInstances)OpenVRUtil::convertOpenVRButtonToTorqueButton(vrEvent.data.mouse.button);
eventInfo.action = SI_MAKE;
eventInfo.fValue = 1.0f;
processMouseEvent(eventInfo);
}
break;
case vr::VREvent_MouseButtonUp:
{
eventInfo.objType = SI_BUTTON;
eventInfo.objInst = (InputObjectInstances)OpenVRUtil::convertOpenVRButtonToTorqueButton(vrEvent.data.mouse.button);
eventInfo.action = SI_BREAK;
eventInfo.fValue = 0.0f;
processMouseEvent(eventInfo);
}
break;
case vr::VREvent_OverlayShown:
{
markDirty();
}
break;
case vr::VREvent_Quit:
AssertFatal(false, "WTF is going on here");
break;
}
}
if (mThumbOverlayHandle != vr::k_ulOverlayHandleInvalid)
{
while (vr::VROverlay()->PollNextOverlayEvent(mThumbOverlayHandle, &vrEvent, sizeof(vrEvent)))
{
switch (vrEvent.eventType)
{
case vr::VREvent_OverlayShown:
{
markDirty();
}
break;
}
}
}
}
void OpenVROverlay::onFrameRendered()
{
vr::IVROverlay *overlay = vr::VROverlay();
if (!overlay || !mOverlayHandle)
return;
updateOverlay();
Point2I desiredSize = mTarget->getSize();
if (mStagingTexture.isNull() || mStagingTexture.getWidthHeight() != desiredSize)
{
Point2I sz = mStagingTexture.getWidthHeight();
mStagingTexture.set(desiredSize.x, desiredSize.y, mTargetFormat, &VRTextureProfile, "OpenVROverlay staging texture");
}
mTarget->resolveTo(mStagingTexture);
vr::Texture_t tex;
if (GFX->getAdapterType() == Direct3D11)
{
tex = { (void*)static_cast<GFXD3D11TextureObject*>(mStagingTexture.getPointer())->getResource(), vr::API_DirectX, vr::ColorSpace_Auto };
}
#ifdef TORQUE_OPENGL
else if (GFX->getAdapterType() == OpenGL)
{
tex = { (void*)static_cast<GFXGLTextureObject*>(mStagingTexture.getPointer())->getHandle(), vr::API_OpenGL, vr::ColorSpace_Auto };
}
#endif
else
{
return;
}
//mStagingTexture->dumpToDisk("PNG", "D:\\test.png");
vr::EVROverlayError err = overlay->SetOverlayTexture(mOverlayHandle, &tex);
if (err != vr::VROverlayError_None)
{
Con::errorf("VR: Error setting overlay texture.");
}
//Con::printf("Overlay visible ? %s", vr::VROverlay()->IsOverlayVisible(mOverlayHandle) ? "YES" : "NO");
}
DefineEngineMethod(OpenVROverlay, showOverlay, void, (), , "")
{
object->showOverlay();
}
DefineEngineMethod(OpenVROverlay, hideOverlay, void, (), , "")
{
object->hideOverlay();
}

18
Engine/source/platform/input/openVR/openVROverlay.h
View file

@ -33,6 +33,7 @@ public:
};
vr::VROverlayHandle_t mOverlayHandle;
vr::VROverlayHandle_t mThumbOverlayHandle;
// Desired OpenVR state
U32 mOverlayFlags;
@ -41,15 +42,19 @@ public:
vr::VROverlayTransformType mOverlayTransformType;
MatrixF mTransform;
vr::TrackedDeviceIndex_t mTransformDeviceIndex;
const char* mTransformDeviceComponent;
String mTransformDeviceComponent;
vr::VROverlayInputMethod mInputMethod;
Point2F mMouseScale;
MatrixF mTrackingOrigin;
vr::ETrackingUniverseOrigin mTrackingOrigin;
vr::TrackedDeviceIndex_t mControllerDeviceIndex;
GFXTexHandle mStagingTexture; ///< Texture used by openvr
ColorF mOverlayColor;
bool mOverlayTypeDirty; ///< Overlay type is dirty
bool mOverlayDirty; ///< Overlay properties are dirty
OverlayType mOverlayType;
@ -61,6 +66,8 @@ public:
static void initPersistFields();
DECLARE_CONOBJECT(OpenVROverlay);
bool onAdd();
void onRemove();
@ -76,10 +83,13 @@ public:
bool isGamepadFocussed();
bool isActiveDashboardOverlay();
MatrixF getTransformForOverlayCoordinates(const vr::ETrackingUniverseOrigin trackingOrigin, const Point2F &pos);
bool castRay(const vr::ETrackingUniverseOrigin trackingOrigin, const Point3F &origin, const Point3F &direction, RayInfo *info);
MatrixF getTransformForOverlayCoordinates(const Point2F &pos);
bool castRay(const Point3F &origin, const Point3F &direction, RayInfo *info);
void moveGamepadFocusToNeighbour();
void handleOpenVREvents();
void onFrameRendered();
};
typedef OpenVROverlay::OverlayType OpenVROverlayType;

29
Engine/source/platform/input/openVR/openVRProvider.cpp
View file

@ -22,6 +22,8 @@
#include "gfx/gl/gfxGLEnumTranslate.h"
#endif
AngAxisF gLastMoveRot; // jamesu - this is just here for temp debugging
namespace OpenVRUtil
{
void convertTransformFromOVR(const MatrixF &inRotTMat, MatrixF& outRotation)
@ -93,6 +95,19 @@ namespace OpenVRUtil
outMat.m[2][3] = row2.w;
}
U32 convertOpenVRButtonToTorqueButton(uint32_t vrButton)
{
switch (vrButton)
{
case vr::VRMouseButton_Left:
return KEY_BUTTON0;
case vr::VRMouseButton_Right:
return KEY_BUTTON1;
case vr::VRMouseButton_Middle:
return KEY_BUTTON2;
}
}
vr::VRTextureBounds_t TorqueRectToBounds(const RectI &rect, const Point2I &widthHeight)
{
@ -343,7 +358,7 @@ OpenVRProvider::OpenVRProvider() :
INPUTMGR->registerDevice(this);
dMemset(&mLUID, '\0', sizeof(mLUID));
mTrackingSpace = vr::TrackingUniverseStanding;
mTrackingSpace = vr::TrackingUniverseSeated;
}
OpenVRProvider::~OpenVRProvider()
@ -896,11 +911,16 @@ void OpenVRProvider::updateTrackedPoses()
{
mValidPoseCount++;
MatrixF mat = OpenVRUtil::convertSteamVRAffineMatrixToMatrixFPlain(mTrackedDevicePose[nDevice].mDeviceToAbsoluteTracking);
mat.inverse();
if (nDevice == vr::k_unTrackedDeviceIndex_Hmd)
{
mHMDRenderState.mHMDPose = mat;
// jaeesu - store the last rotation for temp debugging
MatrixF torqueMat(1);
OpenVRUtil::convertTransformFromOVR(mat, torqueMat);
gLastMoveRot = AngAxisF(torqueMat);
//Con::printf("gLastMoveRot = %f,%f,%f,%f", gLastMoveRot.axis.x, gLastMoveRot.axis.y, gLastMoveRot.axis.z, gLastMoveRot.angle);
mHMDRenderState.mHMDPose.inverse();
}
vr::TrackedDevicePose_t &outPose = mTrackedDevicePose[nDevice];
@ -1119,3 +1139,8 @@ DefineEngineStaticMethod(OpenVR, resetSensors, void, (), ,
}
// Overlay stuff
DefineEngineFunction(OpenVRIsCompiledIn, bool, (), , "")
{
return true;
}

9
Engine/source/platform/input/openVR/openVRProvider.h
View file

@ -30,7 +30,14 @@ typedef vr::ETrackingUniverseOrigin OpenVRTrackingUniverseOrigin;
typedef vr::EOverlayDirection OpenVROverlayDirection;
typedef vr::EVRState OpenVRState;
DefineEnumType(OpenVROverlayInputMethod);
DefineEnumType(OpenVROverlayTransformType);
DefineEnumType(OpenVRGamepadTextInputMode);
DefineEnumType(OpenVRGamepadTextInputLineMode);
DefineEnumType(OpenVRTrackingResult);
DefineEnumType(OpenVRTrackingUniverseOrigin);
DefineEnumType(OpenVROverlayDirection);
DefineEnumType(OpenVRState);
namespace OpenVRUtil
{
@ -45,6 +52,8 @@ namespace OpenVRUtil
/// Converts a MatrixF to a vr::HmdMatrix34_t
void convertMatrixFPlainToSteamVRAffineMatrix(const MatrixF &inMat, vr::HmdMatrix34_t &outMat);
U32 convertOpenVRButtonToTorqueButton(uint32_t vrButton);
};
template<int TEXSIZE> class VRTextureSet

5
Engine/source/sim/actionMap.cpp
View file

@ -1450,9 +1450,8 @@ bool ActionMap::processAction(const InputEventInfo* pEvent)
}
else
{
// Handle rotation (QuatF)
QuatF quat(pEvent->fValue, pEvent->fValue2, pEvent->fValue3, pEvent->fValue4);
AngAxisF aa(quat);
// Handle rotation (AngAxisF)
AngAxisF aa(Point3F(pEvent->fValue, pEvent->fValue2, pEvent->fValue3), pEvent->fValue4);
aa.axis.normalize();
argv[1] = Con::getFloatArg( aa.axis.x );
argv[2] = Con::getFloatArg( aa.axis.y );