diff --git a/Engine/source/gfx/D3D11/gfxD3D11EnumTranslate.cpp b/Engine/source/gfx/D3D11/gfxD3D11EnumTranslate.cpp index b7a05acd4..72acdd083 100644 --- a/Engine/source/gfx/D3D11/gfxD3D11EnumTranslate.cpp +++ b/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; diff --git a/Engine/source/gfx/D3D11/gfxD3D11TextureObject.cpp b/Engine/source/gfx/D3D11/gfxD3D11TextureObject.cpp index 1c97597cc..22af430f0 100644 --- a/Engine/source/gfx/D3D11/gfxD3D11TextureObject.cpp +++ b/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; diff --git a/Engine/source/gfx/D3D9/pc/gfxD3D9EnumTranslate.pc.cpp b/Engine/source/gfx/D3D9/pc/gfxD3D9EnumTranslate.pc.cpp index a598c4999..1d51860c0 100644 --- a/Engine/source/gfx/D3D9/pc/gfxD3D9EnumTranslate.pc.cpp +++ b/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); //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ diff --git a/Engine/source/gfx/bitmap/gBitmap.cpp b/Engine/source/gfx/bitmap/gBitmap.cpp index 78454d5e3..e5ef6b407 100644 --- a/Engine/source/gfx/bitmap/gBitmap.cpp +++ b/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; diff --git a/Engine/source/gfx/bitmap/loaders/bitmapPng.cpp b/Engine/source/gfx/bitmap/loaders/bitmapPng.cpp index c0e05471c..702c5b33d 100644 --- a/Engine/source/gfx/bitmap/loaders/bitmapPng.cpp +++ b/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 diff --git a/Engine/source/gfx/gfxEnums.h b/Engine/source/gfx/gfxEnums.h index cdb61b6a4..af0e1b920 100644 --- a/Engine/source/gfx/gfxEnums.h +++ b/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, diff --git a/Engine/source/gui/core/guiOffscreenCanvas.cpp b/Engine/source/gui/core/guiOffscreenCanvas.cpp index e54479931..f3ce5c2e6 100644 --- a/Engine/source/gui/core/guiOffscreenCanvas.cpp +++ b/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() diff --git a/Engine/source/gui/core/guiOffscreenCanvas.h b/Engine/source/gui/core/guiOffscreenCanvas.h index bf7d53bef..9807f56a7 100644 --- a/Engine/source/gui/core/guiOffscreenCanvas.h +++ b/Engine/source/gui/core/guiOffscreenCanvas.h @@ -23,6 +23,7 @@ public: void onRemove(); void renderFrame(bool preRenderOnly, bool bufferSwap); + virtual void onFrameRendered(); Point2I getWindowSize(); diff --git a/Engine/source/platform/input/openVR/openVROverlay.cpp b/Engine/source/platform/input/openVR/openVROverlay.cpp index d22abbd51..24bede00b 100644 --- a/Engine/source/platform/input/openVR/openVROverlay.cpp +++ b/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(obj); + object->mOverlayTypeDirty = true; + return true; +} + +static bool setProtectedOverlayDirty(void *obj, const char *array, const char *data) +{ + OpenVROverlay *object = static_cast(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(mStagingTexture.getPointer())->getResource(), vr::API_DirectX, vr::ColorSpace_Auto }; + } +#ifdef TORQUE_OPENGL + else if (GFX->getAdapterType() == OpenGL) + { + tex = { (void*)static_cast(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(); +} \ No newline at end of file diff --git a/Engine/source/platform/input/openVR/openVROverlay.h b/Engine/source/platform/input/openVR/openVROverlay.h index 8a5a82f17..6998f3423 100644 --- a/Engine/source/platform/input/openVR/openVROverlay.h +++ b/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; diff --git a/Engine/source/platform/input/openVR/openVRProvider.cpp b/Engine/source/platform/input/openVR/openVRProvider.cpp index 8c49ef49e..c6b6f1379 100644 --- a/Engine/source/platform/input/openVR/openVRProvider.cpp +++ b/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; +} diff --git a/Engine/source/platform/input/openVR/openVRProvider.h b/Engine/source/platform/input/openVR/openVRProvider.h index 94b43fb38..76f66e784 100644 --- a/Engine/source/platform/input/openVR/openVRProvider.h +++ b/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 class VRTextureSet diff --git a/Engine/source/sim/actionMap.cpp b/Engine/source/sim/actionMap.cpp index e3db62cef..e4455d458 100644 --- a/Engine/source/sim/actionMap.cpp +++ b/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 );