Improvements to openvr code

- Overlays are implemented (sans input for the moment)
- Fixed a problem where the movemanager was using the wrong values for hmd rotation & position

Engine/source/gfx/D3D11/gfxD3D11EnumTranslate.cpp

@@ -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;

Engine/source/gfx/D3D11/gfxD3D11TextureObject.cpp

@@ -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;

Engine/source/gfx/D3D9/pc/gfxD3D9EnumTranslate.pc.cpp

@@ -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);
 //------------------------------------------------------------------------------
 //------------------------------------------------------------------------------

Engine/source/gfx/bitmap/gBitmap.cpp

@@ -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;

Engine/source/gfx/bitmap/loaders/bitmapPng.cpp

@@ -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

Engine/source/gfx/gfxEnums.h

@@ -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,

Engine/source/gui/core/guiOffscreenCanvas.cpp

@@ -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()

Engine/source/gui/core/guiOffscreenCanvas.h

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

Engine/source/platform/input/openVR/openVROverlay.cpp

@@ -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();
+}

Engine/source/platform/input/openVR/openVROverlay.h

@@ -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;

Engine/source/platform/input/openVR/openVRProvider.cpp

@@ -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;
+}

Engine/source/platform/input/openVR/openVRProvider.h

@@ -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

Engine/source/sim/actionMap.cpp

@@ -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 );