From 212ac36cc1d1293c26e175154280d3e2bb0cfff7 Mon Sep 17 00:00:00 2001 From: James Urquhart Date: Tue, 12 Jul 2016 23:30:11 +0100 Subject: [PATCH] Tidy up indentation in openvr changes --- .../T3D/gameBase/extended/extendedMove.cpp | 36 +- Engine/source/T3D/gameBase/gameConnection.cpp | 30 +- Engine/source/T3D/player.cpp | 74 +- Engine/source/gfx/D3D11/gfxD3D11Device.cpp | 743 +++++----- Engine/source/gfx/D3D11/gfxD3D11Target.cpp | 46 +- Engine/source/gfx/gfxAdapter.h | 4 +- Engine/source/gfx/gfxDevice.cpp | 4 +- Engine/source/gfx/gfxDevice.h | 14 +- Engine/source/gfx/gfxDrawUtil.cpp | 2 +- Engine/source/gfx/gfxFontRenderBatcher.cpp | 2 +- Engine/source/gfx/gfxInit.cpp | 60 +- Engine/source/gfx/gfxInit.h | 8 +- Engine/source/gfx/gfxTextureProfile.h | 6 +- Engine/source/gfx/sim/debugDraw.cpp | 108 +- Engine/source/gfx/sim/debugDraw.h | 4 +- Engine/source/gui/3d/guiTSControl.cpp | 72 +- .../platform/input/oculusVR/oculusVRDevice.h | 4 +- .../input/oculusVR/oculusVRHMDDevice.cpp | 556 ++++---- .../input/oculusVR/oculusVRHMDDevice.h | 18 +- .../platform/input/openVR/openVROverlay.cpp | 128 +- .../platform/input/openVR/openVROverlay.h | 10 +- .../platform/input/openVR/openVRProvider.cpp | 828 +++++------ .../platform/input/openVR/openVRProvider.h | 192 +-- .../input/openVR/openVRTrackedObject.cpp | 1228 ++++++++--------- .../input/openVR/openVRTrackedObject.h | 166 +-- 25 files changed, 2171 insertions(+), 2172 deletions(-) diff --git a/Engine/source/T3D/gameBase/extended/extendedMove.cpp b/Engine/source/T3D/gameBase/extended/extendedMove.cpp index a11dfc6eb..849706cd1 100644 --- a/Engine/source/T3D/gameBase/extended/extendedMove.cpp +++ b/Engine/source/T3D/gameBase/extended/extendedMove.cpp @@ -36,17 +36,17 @@ void ExtendedMoveManager::init() dSprintf(varName, sizeof(varName), "mvPosX%d", i); Con::addVariable(varName, TypeF32, &mPosX[i], "X position of controller in millimeters. Only 13 bits are networked.\n" - "@ingroup Game"); + "@ingroup Game"); dSprintf(varName, sizeof(varName), "mvPosY%d", i); Con::addVariable(varName, TypeF32, &mPosY[i], "Y position of controller in millimeters. Only 13 bits are networked.\n" - "@ingroup Game"); + "@ingroup Game"); dSprintf(varName, sizeof(varName), "mvPosZ%d", i); Con::addVariable(varName, TypeF32, &mPosZ[i], "Z position of controller in millimeters. Only 13 bits are networked.\n" - "@ingroup Game"); + "@ingroup Game"); dSprintf(varName, sizeof(varName), "mvRotIsEuler%d", i); Con::addVariable(varName, TypeBool, &mRotIsEuler[i], @@ -55,33 +55,33 @@ void ExtendedMoveManager::init() "(a vector and angle). When true, the given rotation is a three component " "Euler angle. When using Euler angles, the $mvRotA component of the ExtendedMove " "is ignored for this set of rotations.\n" - "@ingroup Game"); + "@ingroup Game"); dSprintf(varName, sizeof(varName), "mvRotX%d", i); Con::addVariable(varName, TypeF32, &mRotAX[i], "X rotation vector component of controller.\n" - "@ingroup Game"); + "@ingroup Game"); dSprintf(varName, sizeof(varName), "mvRotY%d", i); Con::addVariable(varName, TypeF32, &mRotAY[i], "Y rotation vector component of controller.\n" - "@ingroup Game"); + "@ingroup Game"); dSprintf(varName, sizeof(varName), "mvRotZ%d", i); Con::addVariable(varName, TypeF32, &mRotAZ[i], "Z rotation vector component of controller.\n" - "@ingroup Game"); + "@ingroup Game"); dSprintf(varName, sizeof(varName), "mvRotA%d", i); Con::addVariable(varName, TypeF32, &mRotAA[i], "Angle rotation (in degrees) component of controller.\n" - "@ingroup Game"); + "@ingroup Game"); } Con::addVariable("mvPosScale", TypeF32, &mPosScale, - "@brief Indicates the scale to be given to mvPos values.\n\n" - "" - "@ingroup Game"); + "@brief Indicates the scale to be given to mvPos values.\n\n" + "" + "@ingroup Game"); } const ExtendedMove NullExtendedMove; @@ -293,7 +293,7 @@ void ExtendedMove::clamp() crotW[i] = CLAMPROT(rotW[i] / M_2PI_F); } - #ifdef DEBUG_CONTROLLER_MOVE + #ifdef DEBUG_CONTROLLER_MOVE if (i == 1) { F32 x, y, z, a; @@ -302,14 +302,14 @@ void ExtendedMove::clamp() z = UNCLAMPPOS(crotZ[i]); a = UNCLAMPROT(crotW[i]) * M_2PI_F; - Con::printf("INPUT POS == %f,%f,%f", ExtendedMoveManager::mPosX[i], ExtendedMoveManager::mPosY[i], ExtendedMoveManager::mPosZ[i]); + Con::printf("INPUT POS == %f,%f,%f", ExtendedMoveManager::mPosX[i], ExtendedMoveManager::mPosY[i], ExtendedMoveManager::mPosZ[i]); Con::printf("rot %f,%f,%f,%f clamped to %f,%f,%f,%f", rotX[i], rotY[i], rotZ[i], rotW[i], x,y,z,a); - x = UNCLAMPPOS(cposX[i]) * ExtendedMoveManager::mPosScale; - y = UNCLAMPPOS(cposX[i]) * ExtendedMoveManager::mPosScale; - z = UNCLAMPPOS(cposX[i]) * ExtendedMoveManager::mPosScale; - Con::printf("pos %f,%f,%f clamped to %f,%f,%f", posX[i], posY[i], posZ[i], x, y, z); + x = UNCLAMPPOS(cposX[i]) * ExtendedMoveManager::mPosScale; + y = UNCLAMPPOS(cposX[i]) * ExtendedMoveManager::mPosScale; + z = UNCLAMPPOS(cposX[i]) * ExtendedMoveManager::mPosScale; + Con::printf("pos %f,%f,%f clamped to %f,%f,%f", posX[i], posY[i], posZ[i], x, y, z); } - #endif + #endif } // Perform the standard Move clamp diff --git a/Engine/source/T3D/gameBase/gameConnection.cpp b/Engine/source/T3D/gameBase/gameConnection.cpp index f1b081f38..08125c261 100644 --- a/Engine/source/T3D/gameBase/gameConnection.cpp +++ b/Engine/source/T3D/gameBase/gameConnection.cpp @@ -469,8 +469,8 @@ bool GameConnection::readConnectRequest(BitStream *stream, const char **errorStr for(U32 i = 0; i < mConnectArgc+3; i++) { - connectArgv[i].value = &connectArgvValue[i]; - connectArgvValue[i].init(); + connectArgv[i].value = &connectArgvValue[i]; + connectArgvValue[i].init(); } for(U32 i = 0; i < mConnectArgc; i++) @@ -683,20 +683,20 @@ bool GameConnection::getControlCameraTransform(F32 dt, MatrixF* mat) bool GameConnection::getControlCameraHeadTransform(IDisplayDevice *display, MatrixF *transform) { - GameBase* obj = getCameraObject(); - if (!obj) - return false; + GameBase* obj = getCameraObject(); + if (!obj) + return false; - GameBase* cObj = obj; - while ((cObj = cObj->getControlObject()) != 0) - { - if (cObj->useObjsEyePoint()) - obj = cObj; - } + GameBase* cObj = obj; + while ((cObj = cObj->getControlObject()) != 0) + { + if (cObj->useObjsEyePoint()) + obj = cObj; + } - obj->getEyeCameraTransform(display, -1, transform); + obj->getEyeCameraTransform(display, -1, transform); - return true; + return true; } bool GameConnection::getControlCameraEyeTransforms(IDisplayDevice *display, MatrixF *transforms) @@ -914,8 +914,8 @@ void GameConnection::onRemove() // clientgroup and what not (this is so that we can disconnect from a local server // without needing to destroy and recreate the server before we can connect to it // again). - // Safe-delete as we don't know whether the server connection is currently being - // worked on. + // Safe-delete as we don't know whether the server connection is currently being + // worked on. getRemoteConnection()->safeDeleteObject(); setRemoteConnectionObject(NULL); } diff --git a/Engine/source/T3D/player.cpp b/Engine/source/T3D/player.cpp index c2cd7360f..db6a2ca42 100644 --- a/Engine/source/T3D/player.cpp +++ b/Engine/source/T3D/player.cpp @@ -1783,7 +1783,7 @@ void Player::onRemove() mWorkingQueryBox.minExtents.set(-1e9f, -1e9f, -1e9f); mWorkingQueryBox.maxExtents.set(-1e9f, -1e9f, -1e9f); - SAFE_DELETE( mPhysicsRep ); + SAFE_DELETE( mPhysicsRep ); Parent::onRemove(); } @@ -2505,12 +2505,12 @@ void Player::updateMove(const Move* move) #ifdef TORQUE_OPENVR if (mControllers[0]) { - mControllers[0]->processTick(move); + mControllers[0]->processTick(move); } if (mControllers[1]) { - mControllers[1]->processTick(move); + mControllers[1]->processTick(move); } #endif @@ -3337,9 +3337,9 @@ bool Player::canCrouch() if ( mDataBlock->actionList[PlayerData::CrouchRootAnim].sequence == -1 ) return false; - // We are already in this pose, so don't test it again... - if ( mPose == CrouchPose ) - return true; + // We are already in this pose, so don't test it again... + if ( mPose == CrouchPose ) + return true; // Do standard Torque physics test here! if ( !mPhysicsRep ) @@ -3389,8 +3389,8 @@ bool Player::canStand() return false; // We are already in this pose, so don't test it again... - if ( mPose == StandPose ) - return true; + if ( mPose == StandPose ) + return true; // Do standard Torque physics test here! if ( !mPhysicsRep ) @@ -3453,9 +3453,9 @@ bool Player::canProne() if ( !mPhysicsRep ) return true; - // We are already in this pose, so don't test it again... - if ( mPose == PronePose ) - return true; + // We are already in this pose, so don't test it again... + if ( mPose == PronePose ) + return true; return mPhysicsRep->testSpacials( getPosition(), mDataBlock->proneBoxSize ); } @@ -3652,7 +3652,7 @@ MatrixF * Player::Death::fallToGround(F32 dt, const Point3F& loc, F32 curZ, F32 normal.normalize(); mat.set(EulerF (0.0f, 0.0f, curZ)); mat.mulV(upY, & ahead); - mCross(ahead, normal, &sideVec); + mCross(ahead, normal, &sideVec); sideVec.normalize(); mCross(normal, sideVec, &ahead); @@ -5846,7 +5846,7 @@ F32 Player::getSpeed() const void Player::setVelocity(const VectorF& vel) { - AssertFatal( !mIsNaN( vel ), "Player::setVelocity() - The velocity is NaN!" ); + AssertFatal( !mIsNaN( vel ), "Player::setVelocity() - The velocity is NaN!" ); mVelocity = vel; setMaskBits(MoveMask); @@ -5854,7 +5854,7 @@ void Player::setVelocity(const VectorF& vel) void Player::applyImpulse(const Point3F&,const VectorF& vec) { - AssertFatal( !mIsNaN( vec ), "Player::applyImpulse() - The vector is NaN!" ); + AssertFatal( !mIsNaN( vec ), "Player::applyImpulse() - The vector is NaN!" ); // Players ignore angular velocity VectorF vel; @@ -6202,7 +6202,7 @@ U32 Player::packUpdate(NetConnection *con, U32 mask, BitStream *stream) stream->writeFlag(mSwimming); stream->writeFlag(mJetting); stream->writeInt(mPose, NumPoseBits); - + stream->writeInt(mState,NumStateBits); if (stream->writeFlag(mState == RecoverState)) stream->writeInt(mRecoverTicks,PlayerData::RecoverDelayBits); @@ -6303,7 +6303,7 @@ void Player::unpackUpdate(NetConnection *con, BitStream *stream) mSwimming = stream->readFlag(); mJetting = stream->readFlag(); mPose = (Pose)(stream->readInt(NumPoseBits)); - + ActionState actionState = (ActionState)stream->readInt(NumStateBits); if (stream->readFlag()) { mRecoverTicks = stream->readInt(PlayerData::RecoverDelayBits); @@ -7174,34 +7174,34 @@ void Player::renderConvex( ObjectRenderInst *ri, SceneRenderState *state, BaseMa #ifdef TORQUE_OPENVR void Player::setControllers(Vector controllerList) { - mControllers[0] = controllerList.size() > 0 ? controllerList[0] : NULL; - mControllers[1] = controllerList.size() > 1 ? controllerList[1] : NULL; + mControllers[0] = controllerList.size() > 0 ? controllerList[0] : NULL; + mControllers[1] = controllerList.size() > 1 ? controllerList[1] : NULL; } ConsoleMethod(Player, setVRControllers, void, 4, 4, "") { - OpenVRTrackedObject *controllerL, *controllerR; - Vector list; + OpenVRTrackedObject *controllerL, *controllerR; + Vector list; - if (Sim::findObject(argv[2], controllerL)) - { - list.push_back(controllerL); - } - else - { - list.push_back(NULL); - } + if (Sim::findObject(argv[2], controllerL)) + { + list.push_back(controllerL); + } + else + { + list.push_back(NULL); + } - if (Sim::findObject(argv[3], controllerR)) - { - list.push_back(controllerR); - } - else - { - list.push_back(NULL); - } + if (Sim::findObject(argv[3], controllerR)) + { + list.push_back(controllerR); + } + else + { + list.push_back(NULL); + } - object->setControllers(list); + object->setControllers(list); } #endif diff --git a/Engine/source/gfx/D3D11/gfxD3D11Device.cpp b/Engine/source/gfx/D3D11/gfxD3D11Device.cpp index 49a3835af..2881e1f48 100644 --- a/Engine/source/gfx/D3D11/gfxD3D11Device.cpp +++ b/Engine/source/gfx/D3D11/gfxD3D11Device.cpp @@ -119,77 +119,77 @@ void GFXD3D11Device::enumerateAdapters(Vector &adapterList) for(U32 adapterIndex = 0; DXGIFactory->EnumAdapters1(adapterIndex, &EnumAdapter) != DXGI_ERROR_NOT_FOUND; ++adapterIndex) { - GFXAdapter *toAdd = new GFXAdapter; - toAdd->mType = Direct3D11; - toAdd->mIndex = adapterIndex; - toAdd->mCreateDeviceInstanceDelegate = mCreateDeviceInstance; + GFXAdapter *toAdd = new GFXAdapter; + toAdd->mType = Direct3D11; + toAdd->mIndex = adapterIndex; + toAdd->mCreateDeviceInstanceDelegate = mCreateDeviceInstance; - toAdd->mShaderModel = 5.0f; - DXGI_ADAPTER_DESC1 desc; - EnumAdapter->GetDesc1(&desc); + toAdd->mShaderModel = 5.0f; + DXGI_ADAPTER_DESC1 desc; + EnumAdapter->GetDesc1(&desc); - // LUID identifies adapter for oculus rift - dMemcpy(&toAdd->mLUID, &desc.AdapterLuid, sizeof(toAdd->mLUID)); + // LUID identifies adapter for oculus rift + dMemcpy(&toAdd->mLUID, &desc.AdapterLuid, sizeof(toAdd->mLUID)); - size_t size=wcslen(desc.Description); - char *str = new char[size+1]; + size_t size=wcslen(desc.Description); + char *str = new char[size+1]; - wcstombs(str, desc.Description,size); - str[size]='\0'; - String Description=str; + wcstombs(str, desc.Description,size); + str[size]='\0'; + String Description=str; SAFE_DELETE_ARRAY(str); - dStrncpy(toAdd->mName, Description.c_str(), GFXAdapter::MaxAdapterNameLen); - dStrncat(toAdd->mName, " (D3D11)", GFXAdapter::MaxAdapterNameLen); + dStrncpy(toAdd->mName, Description.c_str(), GFXAdapter::MaxAdapterNameLen); + dStrncat(toAdd->mName, " (D3D11)", GFXAdapter::MaxAdapterNameLen); - IDXGIOutput* pOutput = NULL; - HRESULT hr; + IDXGIOutput* pOutput = NULL; + HRESULT hr; - hr = EnumAdapter->EnumOutputs(adapterIndex, &pOutput); + hr = EnumAdapter->EnumOutputs(adapterIndex, &pOutput); - if(hr == DXGI_ERROR_NOT_FOUND) - { + if(hr == DXGI_ERROR_NOT_FOUND) + { SAFE_RELEASE(EnumAdapter); - break; - } + break; + } - if(FAILED(hr)) - AssertFatal(false, "GFXD3D11Device::enumerateAdapters -> EnumOutputs call failure"); + if(FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::enumerateAdapters -> EnumOutputs call failure"); - UINT numModes = 0; - DXGI_MODE_DESC* displayModes = NULL; - DXGI_FORMAT format = DXGI_FORMAT_B8G8R8A8_UNORM; + UINT numModes = 0; + DXGI_MODE_DESC* displayModes = NULL; + DXGI_FORMAT format = DXGI_FORMAT_B8G8R8A8_UNORM; - // Get the number of elements - hr = pOutput->GetDisplayModeList(format, 0, &numModes, NULL); + // Get the number of elements + hr = pOutput->GetDisplayModeList(format, 0, &numModes, NULL); - if(FAILED(hr)) - AssertFatal(false, "GFXD3D11Device::enumerateAdapters -> GetDisplayModeList call failure"); + if(FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::enumerateAdapters -> GetDisplayModeList call failure"); - displayModes = new DXGI_MODE_DESC[numModes]; + displayModes = new DXGI_MODE_DESC[numModes]; - // Get the list - hr = pOutput->GetDisplayModeList(format, 0, &numModes, displayModes); + // Get the list + hr = pOutput->GetDisplayModeList(format, 0, &numModes, displayModes); - if(FAILED(hr)) - AssertFatal(false, "GFXD3D11Device::enumerateAdapters -> GetDisplayModeList call failure"); + if(FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::enumerateAdapters -> GetDisplayModeList call failure"); - for(U32 numMode = 0; numMode < numModes; ++numMode) - { - GFXVideoMode vmAdd; + for(U32 numMode = 0; numMode < numModes; ++numMode) + { + GFXVideoMode vmAdd; - vmAdd.fullScreen = true; - vmAdd.bitDepth = 32; - vmAdd.refreshRate = displayModes[numMode].RefreshRate.Numerator / displayModes[numMode].RefreshRate.Denominator; - vmAdd.resolution.x = displayModes[numMode].Width; - vmAdd.resolution.y = displayModes[numMode].Height; - toAdd->mAvailableModes.push_back(vmAdd); - } + vmAdd.fullScreen = true; + vmAdd.bitDepth = 32; + vmAdd.refreshRate = displayModes[numMode].RefreshRate.Numerator / displayModes[numMode].RefreshRate.Denominator; + vmAdd.resolution.x = displayModes[numMode].Width; + vmAdd.resolution.y = displayModes[numMode].Height; + toAdd->mAvailableModes.push_back(vmAdd); + } - delete[] displayModes; + delete[] displayModes; SAFE_RELEASE(pOutput); SAFE_RELEASE(EnumAdapter); - adapterList.push_back(toAdd); + adapterList.push_back(toAdd); } SAFE_RELEASE(DXGIFactory); @@ -210,50 +210,50 @@ void GFXD3D11Device::enumerateVideoModes() for(U32 adapterIndex = 0; DXGIFactory->EnumAdapters1(adapterIndex, &EnumAdapter) != DXGI_ERROR_NOT_FOUND; ++adapterIndex) { - IDXGIOutput* pOutput = NULL; + IDXGIOutput* pOutput = NULL; - hr = EnumAdapter->EnumOutputs(adapterIndex, &pOutput); + hr = EnumAdapter->EnumOutputs(adapterIndex, &pOutput); - if(hr == DXGI_ERROR_NOT_FOUND) - { + if(hr == DXGI_ERROR_NOT_FOUND) + { SAFE_RELEASE(EnumAdapter); - break; - } + break; + } - if(FAILED(hr)) - AssertFatal(false, "GFXD3D11Device::enumerateVideoModes -> EnumOutputs call failure"); + if(FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::enumerateVideoModes -> EnumOutputs call failure"); - UINT numModes = 0; - DXGI_MODE_DESC* displayModes = NULL; - DXGI_FORMAT format = GFXD3D11TextureFormat[GFXFormatR8G8B8A8]; + UINT numModes = 0; + DXGI_MODE_DESC* displayModes = NULL; + DXGI_FORMAT format = GFXD3D11TextureFormat[GFXFormatR8G8B8A8]; - // Get the number of elements - hr = pOutput->GetDisplayModeList(format, 0, &numModes, NULL); + // Get the number of elements + hr = pOutput->GetDisplayModeList(format, 0, &numModes, NULL); - if(FAILED(hr)) - AssertFatal(false, "GFXD3D11Device::enumerateVideoModes -> GetDisplayModeList call failure"); + if(FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::enumerateVideoModes -> GetDisplayModeList call failure"); - displayModes = new DXGI_MODE_DESC[numModes]; + displayModes = new DXGI_MODE_DESC[numModes]; - // Get the list - hr = pOutput->GetDisplayModeList(format, 0, &numModes, displayModes); + // Get the list + hr = pOutput->GetDisplayModeList(format, 0, &numModes, displayModes); - if(FAILED(hr)) - AssertFatal(false, "GFXD3D11Device::enumerateVideoModes -> GetDisplayModeList call failure"); + if(FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::enumerateVideoModes -> GetDisplayModeList call failure"); - for(U32 numMode = 0; numMode < numModes; ++numMode) - { - GFXVideoMode toAdd; + for(U32 numMode = 0; numMode < numModes; ++numMode) + { + GFXVideoMode toAdd; - toAdd.fullScreen = false; - toAdd.bitDepth = 32; - toAdd.refreshRate = displayModes[numMode].RefreshRate.Numerator / displayModes[numMode].RefreshRate.Denominator; - toAdd.resolution.x = displayModes[numMode].Width; - toAdd.resolution.y = displayModes[numMode].Height; - mVideoModes.push_back(toAdd); - } + toAdd.fullScreen = false; + toAdd.bitDepth = 32; + toAdd.refreshRate = displayModes[numMode].RefreshRate.Numerator / displayModes[numMode].RefreshRate.Denominator; + toAdd.resolution.x = displayModes[numMode].Width; + toAdd.resolution.y = displayModes[numMode].Height; + mVideoModes.push_back(toAdd); + } - delete[] displayModes; + delete[] displayModes; SAFE_RELEASE(pOutput); SAFE_RELEASE(EnumAdapter); } @@ -263,7 +263,7 @@ void GFXD3D11Device::enumerateVideoModes() IDXGISwapChain* GFXD3D11Device::getSwapChain() { - return mSwapChain; + return mSwapChain; } void GFXD3D11Device::init(const GFXVideoMode &mode, PlatformWindow *window) @@ -285,19 +285,19 @@ void GFXD3D11Device::init(const GFXVideoMode &mode, PlatformWindow *window) // create a device, device context and swap chain using the information in the d3dpp struct HRESULT hres = D3D11CreateDeviceAndSwapChain(NULL, driverType, - NULL, - createDeviceFlags, - NULL, - 0, - D3D11_SDK_VERSION, - &d3dpp, - &mSwapChain, - &mD3DDevice, - &deviceFeature, - &mD3DDeviceContext); + NULL, + createDeviceFlags, + NULL, + 0, + D3D11_SDK_VERSION, + &d3dpp, + &mSwapChain, + &mD3DDevice, + &deviceFeature, + &mD3DDeviceContext); - if(FAILED(hres)) - { + if(FAILED(hres)) + { #ifdef TORQUE_DEBUG //try again without debug device layer enabled createDeviceFlags &= ~D3D11_CREATE_DEVICE_DEBUG; @@ -315,9 +315,9 @@ void GFXD3D11Device::init(const GFXVideoMode &mode, PlatformWindow *window) Con::warnf("GFXD3D11Device::init - Debug layers not detected!"); mDebugLayers = false; #else - AssertFatal(false, "GFXD3D11Device::init - D3D11CreateDeviceAndSwapChain failed!"); + AssertFatal(false, "GFXD3D11Device::init - D3D11CreateDeviceAndSwapChain failed!"); #endif - } + } //set the fullscreen state here if we need to if(mode.fullScreen) @@ -329,79 +329,79 @@ void GFXD3D11Device::init(const GFXVideoMode &mode, PlatformWindow *window) } } - mTextureManager = new GFXD3D11TextureManager(); + mTextureManager = new GFXD3D11TextureManager(); - // Now reacquire all the resources we trashed earlier - reacquireDefaultPoolResources(); + // Now reacquire all the resources we trashed earlier + reacquireDefaultPoolResources(); //TODO implement feature levels? - if (deviceFeature >= D3D_FEATURE_LEVEL_11_0) - mPixVersion = 5.0f; - else - AssertFatal(false, "GFXD3D11Device::init - We don't support anything below feature level 11."); + if (deviceFeature >= D3D_FEATURE_LEVEL_11_0) + mPixVersion = 5.0f; + else + AssertFatal(false, "GFXD3D11Device::init - We don't support anything below feature level 11."); - D3D11_QUERY_DESC queryDesc; + D3D11_QUERY_DESC queryDesc; queryDesc.Query = D3D11_QUERY_OCCLUSION; queryDesc.MiscFlags = 0; - ID3D11Query *testQuery = NULL; + ID3D11Query *testQuery = NULL; - // detect occlusion query support - if (SUCCEEDED(mD3DDevice->CreateQuery(&queryDesc, &testQuery))) mOcclusionQuerySupported = true; + // detect occlusion query support + if (SUCCEEDED(mD3DDevice->CreateQuery(&queryDesc, &testQuery))) mOcclusionQuerySupported = true; SAFE_RELEASE(testQuery); - Con::printf("Hardware occlusion query detected: %s", mOcclusionQuerySupported ? "Yes" : "No"); + Con::printf("Hardware occlusion query detected: %s", mOcclusionQuerySupported ? "Yes" : "No"); - mCardProfiler = new GFXD3D11CardProfiler(); - mCardProfiler->init(); + mCardProfiler = new GFXD3D11CardProfiler(); + mCardProfiler->init(); - D3D11_TEXTURE2D_DESC desc; - desc.BindFlags = D3D11_BIND_DEPTH_STENCIL; - desc.CPUAccessFlags = 0; - desc.Format = GFXD3D11TextureFormat[GFXFormatD24S8]; - desc.MipLevels = 1; - desc.ArraySize = 1; - desc.Usage = D3D11_USAGE_DEFAULT; - desc.Width = mode.resolution.x; - desc.Height = mode.resolution.y; - desc.SampleDesc.Count =1; - desc.SampleDesc.Quality =0; - desc.MiscFlags = 0; + D3D11_TEXTURE2D_DESC desc; + desc.BindFlags = D3D11_BIND_DEPTH_STENCIL; + desc.CPUAccessFlags = 0; + desc.Format = GFXD3D11TextureFormat[GFXFormatD24S8]; + desc.MipLevels = 1; + desc.ArraySize = 1; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.Width = mode.resolution.x; + desc.Height = mode.resolution.y; + desc.SampleDesc.Count =1; + desc.SampleDesc.Quality =0; + desc.MiscFlags = 0; - HRESULT hr = mD3DDevice->CreateTexture2D(&desc, NULL, &mDeviceDepthStencil); - if(FAILED(hr)) - { - AssertFatal(false, "GFXD3D11Device::init - couldn't create device's depth-stencil surface."); - } + HRESULT hr = mD3DDevice->CreateTexture2D(&desc, NULL, &mDeviceDepthStencil); + if(FAILED(hr)) + { + AssertFatal(false, "GFXD3D11Device::init - couldn't create device's depth-stencil surface."); + } - D3D11_DEPTH_STENCIL_VIEW_DESC depthDesc; - depthDesc.Format = GFXD3D11TextureFormat[GFXFormatD24S8]; - depthDesc.Flags =0 ; - depthDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; - depthDesc.Texture2D.MipSlice = 0; + D3D11_DEPTH_STENCIL_VIEW_DESC depthDesc; + depthDesc.Format = GFXD3D11TextureFormat[GFXFormatD24S8]; + depthDesc.Flags =0 ; + depthDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; + depthDesc.Texture2D.MipSlice = 0; - hr = mD3DDevice->CreateDepthStencilView(mDeviceDepthStencil, &depthDesc, &mDeviceDepthStencilView); + hr = mD3DDevice->CreateDepthStencilView(mDeviceDepthStencil, &depthDesc, &mDeviceDepthStencilView); - if(FAILED(hr)) - { - AssertFatal(false, "GFXD3D11Device::init - couldn't create depth stencil view"); - } + if(FAILED(hr)) + { + AssertFatal(false, "GFXD3D11Device::init - couldn't create depth stencil view"); + } - hr = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&mDeviceBackbuffer); - if(FAILED(hr)) - AssertFatal(false, "GFXD3D11Device::init - coudln't retrieve backbuffer ref"); + hr = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&mDeviceBackbuffer); + if(FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::init - coudln't retrieve backbuffer ref"); - //create back buffer view - D3D11_RENDER_TARGET_VIEW_DESC RTDesc; + //create back buffer view + D3D11_RENDER_TARGET_VIEW_DESC RTDesc; - RTDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; - RTDesc.Texture2D.MipSlice = 0; - RTDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; + RTDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; + RTDesc.Texture2D.MipSlice = 0; + RTDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; - hr = mD3DDevice->CreateRenderTargetView(mDeviceBackbuffer, &RTDesc, &mDeviceBackBufferView); + hr = mD3DDevice->CreateRenderTargetView(mDeviceBackbuffer, &RTDesc, &mDeviceBackBufferView); - if(FAILED(hr)) - AssertFatal(false, "GFXD3D11Device::init - couldn't create back buffer target view"); + if(FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::init - couldn't create back buffer target view"); #ifdef TORQUE_DEBUG String backBufferName = "MainBackBuffer"; @@ -419,8 +419,8 @@ void GFXD3D11Device::init(const GFXVideoMode &mode, PlatformWindow *window) gScreenShot = new ScreenShotD3D11; - mInitialized = true; - deviceInited(); + mInitialized = true; + deviceInited(); } // Supress any debug layer messages we don't want to see @@ -489,28 +489,28 @@ GFXTextureTarget* GFXD3D11Device::allocRenderToTextureTarget() void GFXD3D11Device::reset(DXGI_SWAP_CHAIN_DESC &d3dpp) { - if (!mD3DDevice) - return; + if (!mD3DDevice) + return; - mInitialized = false; + mInitialized = false; - // Clean up some commonly dangling state. This helps prevents issues with - // items that are destroyed by the texture manager callbacks and recreated - // later, but still left bound. - setVertexBuffer(NULL); - setPrimitiveBuffer(NULL); - for (S32 i = 0; iClearState(); + mD3DDeviceContext->ClearState(); - DXGI_MODE_DESC displayModes; - displayModes.Format = d3dpp.BufferDesc.Format; - displayModes.Height = d3dpp.BufferDesc.Height; - displayModes.Width = d3dpp.BufferDesc.Width; - displayModes.RefreshRate = d3dpp.BufferDesc.RefreshRate; - displayModes.Scaling = d3dpp.BufferDesc.Scaling; - displayModes.ScanlineOrdering = d3dpp.BufferDesc.ScanlineOrdering; + DXGI_MODE_DESC displayModes; + displayModes.Format = d3dpp.BufferDesc.Format; + displayModes.Height = d3dpp.BufferDesc.Height; + displayModes.Width = d3dpp.BufferDesc.Width; + displayModes.RefreshRate = d3dpp.BufferDesc.RefreshRate; + displayModes.Scaling = d3dpp.BufferDesc.Scaling; + displayModes.ScanlineOrdering = d3dpp.BufferDesc.ScanlineOrdering; HRESULT hr; if (!d3dpp.Windowed) @@ -523,79 +523,79 @@ void GFXD3D11Device::reset(DXGI_SWAP_CHAIN_DESC &d3dpp) } } - // First release all the stuff we allocated from D3DPOOL_DEFAULT - releaseDefaultPoolResources(); + // First release all the stuff we allocated from D3DPOOL_DEFAULT + releaseDefaultPoolResources(); - //release the backbuffer, depthstencil, and their views - SAFE_RELEASE(mDeviceBackBufferView); - SAFE_RELEASE(mDeviceBackbuffer); - SAFE_RELEASE(mDeviceDepthStencilView); - SAFE_RELEASE(mDeviceDepthStencil); + //release the backbuffer, depthstencil, and their views + SAFE_RELEASE(mDeviceBackBufferView); + SAFE_RELEASE(mDeviceBackbuffer); + SAFE_RELEASE(mDeviceDepthStencilView); + SAFE_RELEASE(mDeviceDepthStencil); hr = mSwapChain->ResizeBuffers(d3dpp.BufferCount, d3dpp.BufferDesc.Width, d3dpp.BufferDesc.Height, d3dpp.BufferDesc.Format, d3dpp.Windowed ? 0 : DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH); - if (FAILED(hr)) - { - AssertFatal(false, "D3D11Device::reset - failed to resize back buffer!"); - } + if (FAILED(hr)) + { + AssertFatal(false, "D3D11Device::reset - failed to resize back buffer!"); + } - //recreate backbuffer view. depth stencil view and texture - D3D11_TEXTURE2D_DESC desc; - desc.BindFlags = D3D11_BIND_DEPTH_STENCIL; - desc.CPUAccessFlags = 0; - desc.Format = GFXD3D11TextureFormat[GFXFormatD24S8]; - desc.MipLevels = 1; - desc.ArraySize = 1; - desc.Usage = D3D11_USAGE_DEFAULT; - desc.Width = d3dpp.BufferDesc.Width; - desc.Height = d3dpp.BufferDesc.Height; - desc.SampleDesc.Count = 1; - desc.SampleDesc.Quality = 0; - desc.MiscFlags = 0; + //recreate backbuffer view. depth stencil view and texture + D3D11_TEXTURE2D_DESC desc; + desc.BindFlags = D3D11_BIND_DEPTH_STENCIL; + desc.CPUAccessFlags = 0; + desc.Format = GFXD3D11TextureFormat[GFXFormatD24S8]; + desc.MipLevels = 1; + desc.ArraySize = 1; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.Width = d3dpp.BufferDesc.Width; + desc.Height = d3dpp.BufferDesc.Height; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.MiscFlags = 0; - hr = mD3DDevice->CreateTexture2D(&desc, NULL, &mDeviceDepthStencil); - if (FAILED(hr)) - { - AssertFatal(false, "GFXD3D11Device::reset - couldn't create device's depth-stencil surface."); - } + hr = mD3DDevice->CreateTexture2D(&desc, NULL, &mDeviceDepthStencil); + if (FAILED(hr)) + { + AssertFatal(false, "GFXD3D11Device::reset - couldn't create device's depth-stencil surface."); + } - D3D11_DEPTH_STENCIL_VIEW_DESC depthDesc; - depthDesc.Format = GFXD3D11TextureFormat[GFXFormatD24S8]; - depthDesc.Flags = 0; - depthDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; - depthDesc.Texture2D.MipSlice = 0; + D3D11_DEPTH_STENCIL_VIEW_DESC depthDesc; + depthDesc.Format = GFXD3D11TextureFormat[GFXFormatD24S8]; + depthDesc.Flags = 0; + depthDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; + depthDesc.Texture2D.MipSlice = 0; - hr = mD3DDevice->CreateDepthStencilView(mDeviceDepthStencil, &depthDesc, &mDeviceDepthStencilView); + hr = mD3DDevice->CreateDepthStencilView(mDeviceDepthStencil, &depthDesc, &mDeviceDepthStencilView); - if (FAILED(hr)) - { - AssertFatal(false, "GFXD3D11Device::reset - couldn't create depth stencil view"); - } + if (FAILED(hr)) + { + AssertFatal(false, "GFXD3D11Device::reset - couldn't create depth stencil view"); + } - hr = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&mDeviceBackbuffer); - if (FAILED(hr)) - AssertFatal(false, "GFXD3D11Device::reset - coudln't retrieve backbuffer ref"); + hr = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&mDeviceBackbuffer); + if (FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::reset - coudln't retrieve backbuffer ref"); - //create back buffer view - D3D11_RENDER_TARGET_VIEW_DESC RTDesc; + //create back buffer view + D3D11_RENDER_TARGET_VIEW_DESC RTDesc; - RTDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; - RTDesc.Texture2D.MipSlice = 0; - RTDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; + RTDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; + RTDesc.Texture2D.MipSlice = 0; + RTDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; - hr = mD3DDevice->CreateRenderTargetView(mDeviceBackbuffer, &RTDesc, &mDeviceBackBufferView); + hr = mD3DDevice->CreateRenderTargetView(mDeviceBackbuffer, &RTDesc, &mDeviceBackBufferView); - if (FAILED(hr)) - AssertFatal(false, "GFXD3D11Device::reset - couldn't create back buffer target view"); + if (FAILED(hr)) + AssertFatal(false, "GFXD3D11Device::reset - couldn't create back buffer target view"); mD3DDeviceContext->OMSetRenderTargets(1, &mDeviceBackBufferView, mDeviceDepthStencilView); - hr = mSwapChain->SetFullscreenState(!d3dpp.Windowed, NULL); + hr = mSwapChain->SetFullscreenState(!d3dpp.Windowed, NULL); - if (FAILED(hr)) - { + if (FAILED(hr)) + { AssertFatal(false, "D3D11Device::reset - failed to change screen states!"); - } + } //Microsoft recommend this, see DXGI documentation if (!d3dpp.Windowed) @@ -610,13 +610,13 @@ void GFXD3D11Device::reset(DXGI_SWAP_CHAIN_DESC &d3dpp) } } - mInitialized = true; + mInitialized = true; - // Now re aquire all the resources we trashed earlier - reacquireDefaultPoolResources(); + // Now re aquire all the resources we trashed earlier + reacquireDefaultPoolResources(); - // Mark everything dirty and flush to card, for sanity. - updateStates(true); + // Mark everything dirty and flush to card, for sanity. + updateStates(true); } class GFXPCD3D11RegisterDevice @@ -899,20 +899,20 @@ void GFXD3D11Device::_updateRenderTargets() mRTDirty = false; } - if (mViewportDirty) - { - D3D11_VIEWPORT viewport; + if (mViewportDirty) + { + D3D11_VIEWPORT viewport; - viewport.TopLeftX = mViewport.point.x; - viewport.TopLeftY = mViewport.point.y; - viewport.Width = mViewport.extent.x; - viewport.Height = mViewport.extent.y; - viewport.MinDepth = 0.0f; - viewport.MaxDepth = 1.0f; + viewport.TopLeftX = mViewport.point.x; + viewport.TopLeftY = mViewport.point.y; + viewport.Width = mViewport.extent.x; + viewport.Height = mViewport.extent.y; + viewport.MinDepth = 0.0f; + viewport.MaxDepth = 1.0f; - mD3DDeviceContext->RSSetViewports(1, &viewport); + mD3DDeviceContext->RSSetViewports(1, &viewport); - mViewportDirty = false; + mViewportDirty = false; } } @@ -970,35 +970,35 @@ void GFXD3D11Device::releaseDefaultPoolResources() void GFXD3D11Device::reacquireDefaultPoolResources() { - // Now do the dynamic index buffers - if( mDynamicPB == NULL ) - mDynamicPB = new GFXD3D11PrimitiveBuffer(this, 0, 0, GFXBufferTypeDynamic); + // Now do the dynamic index buffers + if( mDynamicPB == NULL ) + mDynamicPB = new GFXD3D11PrimitiveBuffer(this, 0, 0, GFXBufferTypeDynamic); - D3D11_BUFFER_DESC desc; - desc.ByteWidth = sizeof(U16) * MAX_DYNAMIC_INDICES; - desc.Usage = D3D11_USAGE_DYNAMIC; - desc.BindFlags = D3D11_BIND_INDEX_BUFFER; - desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; - desc.MiscFlags = 0; - desc.StructureByteStride = 0; + D3D11_BUFFER_DESC desc; + desc.ByteWidth = sizeof(U16) * MAX_DYNAMIC_INDICES; + desc.Usage = D3D11_USAGE_DYNAMIC; + desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; - HRESULT hr = D3D11DEVICE->CreateBuffer(&desc, NULL, &mDynamicPB->ib); + HRESULT hr = D3D11DEVICE->CreateBuffer(&desc, NULL, &mDynamicPB->ib); - if(FAILED(hr)) - { - AssertFatal(false, "Failed to allocate dynamic IB"); - } + if(FAILED(hr)) + { + AssertFatal(false, "Failed to allocate dynamic IB"); + } - // Walk the resource list and zombify everything. - GFXResource *walk = mResourceListHead; - while(walk) - { - walk->resurrect(); - walk = walk->getNextResource(); - } + // Walk the resource list and zombify everything. + GFXResource *walk = mResourceListHead; + while(walk) + { + walk->resurrect(); + walk = walk->getNextResource(); + } - if(mTextureManager) - mTextureManager->resurrect(); + if(mTextureManager) + mTextureManager->resurrect(); } GFXD3D11VertexBuffer* GFXD3D11Device::findVBPool( const GFXVertexFormat *vertexFormat, U32 vertsNeeded ) @@ -1014,40 +1014,40 @@ GFXD3D11VertexBuffer* GFXD3D11Device::findVBPool( const GFXVertexFormat *vertexF GFXD3D11VertexBuffer * GFXD3D11Device::createVBPool( const GFXVertexFormat *vertexFormat, U32 vertSize ) { - PROFILE_SCOPE( GFXD3D11Device_createVBPool ); + PROFILE_SCOPE( GFXD3D11Device_createVBPool ); - // this is a bit funky, but it will avoid problems with (lack of) copy constructors - // with a push_back() situation - mVolatileVBList.increment(); - StrongRefPtr newBuff; - mVolatileVBList.last() = new GFXD3D11VertexBuffer(); - newBuff = mVolatileVBList.last(); + // this is a bit funky, but it will avoid problems with (lack of) copy constructors + // with a push_back() situation + mVolatileVBList.increment(); + StrongRefPtr newBuff; + mVolatileVBList.last() = new GFXD3D11VertexBuffer(); + newBuff = mVolatileVBList.last(); - newBuff->mNumVerts = 0; - newBuff->mBufferType = GFXBufferTypeVolatile; - newBuff->mVertexFormat.copy( *vertexFormat ); - newBuff->mVertexSize = vertSize; - newBuff->mDevice = this; + newBuff->mNumVerts = 0; + newBuff->mBufferType = GFXBufferTypeVolatile; + newBuff->mVertexFormat.copy( *vertexFormat ); + newBuff->mVertexSize = vertSize; + newBuff->mDevice = this; - // Requesting it will allocate it. - vertexFormat->getDecl(); + // Requesting it will allocate it. + vertexFormat->getDecl(); - D3D11_BUFFER_DESC desc; - desc.ByteWidth = vertSize * MAX_DYNAMIC_VERTS; - desc.Usage = D3D11_USAGE_DYNAMIC; - desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; - desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; - desc.MiscFlags = 0; - desc.StructureByteStride = 0; + D3D11_BUFFER_DESC desc; + desc.ByteWidth = vertSize * MAX_DYNAMIC_VERTS; + desc.Usage = D3D11_USAGE_DYNAMIC; + desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; - HRESULT hr = D3D11DEVICE->CreateBuffer(&desc, NULL, &newBuff->vb); + HRESULT hr = D3D11DEVICE->CreateBuffer(&desc, NULL, &newBuff->vb); - if(FAILED(hr)) - { - AssertFatal(false, "Failed to allocate dynamic VB"); - } + if(FAILED(hr)) + { + AssertFatal(false, "Failed to allocate dynamic VB"); + } - return newBuff; + return newBuff; } //----------------------------------------------------------------------------- @@ -1103,30 +1103,30 @@ void GFXD3D11Device::setClipRect( const RectI &inRect ) void GFXD3D11Device::setVertexStream( U32 stream, GFXVertexBuffer *buffer ) { - GFXD3D11VertexBuffer *d3dBuffer = static_cast( buffer ); + GFXD3D11VertexBuffer *d3dBuffer = static_cast( buffer ); - if ( stream == 0 ) - { - // Set the volatile buffer which is used to - // offset the start index when doing draw calls. - if ( d3dBuffer && d3dBuffer->mVolatileStart > 0 ) - mVolatileVB = d3dBuffer; - else - mVolatileVB = NULL; - } + if ( stream == 0 ) + { + // Set the volatile buffer which is used to + // offset the start index when doing draw calls. + if ( d3dBuffer && d3dBuffer->mVolatileStart > 0 ) + mVolatileVB = d3dBuffer; + else + mVolatileVB = NULL; + } - // NOTE: We do not use the stream offset here for stream 0 - // as that feature is *supposedly* not as well supported as - // using the start index in drawPrimitive. - // - // If we can verify that this is not the case then we should - // start using this method exclusively for all streams. + // NOTE: We do not use the stream offset here for stream 0 + // as that feature is *supposedly* not as well supported as + // using the start index in drawPrimitive. + // + // If we can verify that this is not the case then we should + // start using this method exclusively for all streams. - U32 strides[1] = { d3dBuffer ? d3dBuffer->mVertexSize : 0 }; - U32 offset = d3dBuffer && stream != 0 ? d3dBuffer->mVolatileStart * d3dBuffer->mVertexSize : 0; - ID3D11Buffer* buff = d3dBuffer ? d3dBuffer->vb : NULL; + U32 strides[1] = { d3dBuffer ? d3dBuffer->mVertexSize : 0 }; + U32 offset = d3dBuffer && stream != 0 ? d3dBuffer->mVolatileStart * d3dBuffer->mVertexSize : 0; + ID3D11Buffer* buff = d3dBuffer ? d3dBuffer->vb : NULL; - getDeviceContext()->IASetVertexBuffers(stream, 1, &buff, strides, &offset); + getDeviceContext()->IASetVertexBuffers(stream, 1, &buff, strides, &offset); } void GFXD3D11Device::setVertexStreamFrequency( U32 stream, U32 frequency ) @@ -1179,7 +1179,7 @@ void GFXD3D11Device::drawPrimitive( GFXPrimitiveType primType, U32 vertexStart, setShaderConstBufferInternal(mCurrentShaderConstBuffer); if ( mVolatileVB ) - vertexStart += mVolatileVB->mVolatileStart; + vertexStart += mVolatileVB->mVolatileStart; mD3DDeviceContext->IASetPrimitiveTopology(GFXD3D11PrimType[primType]); @@ -1243,23 +1243,23 @@ void GFXD3D11Device::setShader(GFXShader *shader, bool force) { if(shader) { - GFXD3D11Shader *d3dShader = static_cast(shader); + GFXD3D11Shader *d3dShader = static_cast(shader); if (d3dShader->mPixShader != mLastPixShader || force) - { - mD3DDeviceContext->PSSetShader( d3dShader->mPixShader, NULL, 0); - mLastPixShader = d3dShader->mPixShader; - } + { + mD3DDeviceContext->PSSetShader( d3dShader->mPixShader, NULL, 0); + mLastPixShader = d3dShader->mPixShader; + } if (d3dShader->mVertShader != mLastVertShader || force) - { - mD3DDeviceContext->VSSetShader( d3dShader->mVertShader, NULL, 0); - mLastVertShader = d3dShader->mVertShader; - } + { + mD3DDeviceContext->VSSetShader( d3dShader->mVertShader, NULL, 0); + mLastVertShader = d3dShader->mVertShader; + } } else { - setupGenericShaders(); + setupGenericShaders(); } } @@ -1286,7 +1286,7 @@ GFXPrimitiveBuffer * GFXD3D11Device::allocPrimitiveBuffer(U32 numIndices, U32 nu case GFXBufferTypeDynamic: case GFXBufferTypeVolatile: - usage = D3D11_USAGE_DYNAMIC; + usage = D3D11_USAGE_DYNAMIC; break; } @@ -1304,24 +1304,24 @@ GFXPrimitiveBuffer * GFXD3D11Device::allocPrimitiveBuffer(U32 numIndices, U32 nu } else { - // Otherwise, get it as a seperate buffer... - D3D11_BUFFER_DESC desc; - desc.ByteWidth = sizeof(U16) * numIndices; - desc.Usage = usage; - if(bufferType == GFXBufferTypeDynamic) - desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; // We never allow reading from a primitive buffer. - else - desc.CPUAccessFlags = 0; - desc.BindFlags = D3D11_BIND_INDEX_BUFFER; - desc.MiscFlags = 0; - desc.StructureByteStride = 0; + // Otherwise, get it as a seperate buffer... + D3D11_BUFFER_DESC desc; + desc.ByteWidth = sizeof(U16) * numIndices; + desc.Usage = usage; + if(bufferType == GFXBufferTypeDynamic) + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; // We never allow reading from a primitive buffer. + else + desc.CPUAccessFlags = 0; + desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; - HRESULT hr = D3D11DEVICE->CreateBuffer(&desc, NULL, &res->ib); + HRESULT hr = D3D11DEVICE->CreateBuffer(&desc, NULL, &res->ib); - if(FAILED(hr)) - { - AssertFatal(false, "Failed to allocate an index buffer."); - } + if(FAILED(hr)) + { + AssertFatal(false, "Failed to allocate an index buffer."); + } } if (data) @@ -1365,7 +1365,7 @@ GFXVertexBuffer * GFXD3D11Device::allocVertexBuffer(U32 numVerts, const GFXVerte case GFXBufferTypeDynamic: case GFXBufferTypeVolatile: - usage = D3D11_USAGE_DYNAMIC; + usage = D3D11_USAGE_DYNAMIC; break; } @@ -1380,27 +1380,27 @@ GFXVertexBuffer * GFXD3D11Device::allocVertexBuffer(U32 numVerts, const GFXVerte } else { - // Requesting it will allocate it. - vertexFormat->getDecl(); //-ALEX disabled to postpone until after shader is actually set... + // Requesting it will allocate it. + vertexFormat->getDecl(); //-ALEX disabled to postpone until after shader is actually set... - // Get a new buffer... - D3D11_BUFFER_DESC desc; - desc.ByteWidth = vertSize * numVerts; - desc.Usage = usage; - desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; - if(bufferType == GFXBufferTypeDynamic) - desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; // We never allow reading from a vertex buffer. - else - desc.CPUAccessFlags = 0; - desc.MiscFlags = 0; - desc.StructureByteStride = 0; + // Get a new buffer... + D3D11_BUFFER_DESC desc; + desc.ByteWidth = vertSize * numVerts; + desc.Usage = usage; + desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + if(bufferType == GFXBufferTypeDynamic) + desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; // We never allow reading from a vertex buffer. + else + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + desc.StructureByteStride = 0; - HRESULT hr = D3D11DEVICE->CreateBuffer(&desc, NULL, &res->vb); + HRESULT hr = D3D11DEVICE->CreateBuffer(&desc, NULL, &res->vb); - if(FAILED(hr)) - { - AssertFatal(false, "Failed to allocate VB"); - } + if(FAILED(hr)) + { + AssertFatal(false, "Failed to allocate VB"); + } } res->mNumVerts = numVerts; @@ -1597,7 +1597,6 @@ GFXVertexDecl* GFXD3D11Device::allocVertexDecl( const GFXVertexFormat *vertexFor S32 elemIndex = 0; for (S32 i = 0; i < elemCount; i++, elemIndex++) - { const GFXVertexElement &element = vertexFormat->getElement(elemIndex); @@ -1690,9 +1689,9 @@ void GFXD3D11Device::setTextureInternal( U32 textureUnit, const GFXTextureObject { if( texture == NULL ) { - ID3D11ShaderResourceView *pView = NULL; - mD3DDeviceContext->PSSetShaderResources(textureUnit, 1, &pView); - return; + ID3D11ShaderResourceView *pView = NULL; + mD3DDeviceContext->PSSetShaderResources(textureUnit, 1, &pView); + return; } GFXD3D11TextureObject *tex = (GFXD3D11TextureObject*)(texture); @@ -1704,23 +1703,23 @@ GFXFence *GFXD3D11Device::createFence() // Figure out what fence type we should be making if we don't know if( mCreateFenceType == -1 ) { - D3D11_QUERY_DESC desc; - desc.MiscFlags = 0; - desc.Query = D3D11_QUERY_EVENT; + D3D11_QUERY_DESC desc; + desc.MiscFlags = 0; + desc.Query = D3D11_QUERY_EVENT; - ID3D11Query *testQuery = NULL; + ID3D11Query *testQuery = NULL; - HRESULT hRes = mD3DDevice->CreateQuery(&desc, &testQuery); + HRESULT hRes = mD3DDevice->CreateQuery(&desc, &testQuery); - if(FAILED(hRes)) - { - mCreateFenceType = true; - } + if(FAILED(hRes)) + { + mCreateFenceType = true; + } - else - { - mCreateFenceType = false; - } + else + { + mCreateFenceType = false; + } SAFE_RELEASE(testQuery); } diff --git a/Engine/source/gfx/D3D11/gfxD3D11Target.cpp b/Engine/source/gfx/D3D11/gfxD3D11Target.cpp index 9c21fa4d3..2260ff841 100644 --- a/Engine/source/gfx/D3D11/gfxD3D11Target.cpp +++ b/Engine/source/gfx/D3D11/gfxD3D11Target.cpp @@ -97,9 +97,9 @@ void GFXD3D11TextureTarget::attachTexture( RenderSlot slot, GFXTextureObject *te if( tex == GFXTextureTarget::sDefaultDepthStencil ) { mTargets[slot] = D3D11->mDeviceDepthStencil; - mTargetViews[slot] = D3D11->mDeviceDepthStencilView; - mTargets[slot]->AddRef(); - mTargetViews[slot]->AddRef(); + mTargetViews[slot] = D3D11->mDeviceDepthStencilView; + mTargets[slot]->AddRef(); + mTargetViews[slot]->AddRef(); } else { @@ -110,14 +110,14 @@ void GFXD3D11TextureTarget::attachTexture( RenderSlot slot, GFXTextureObject *te // Grab the surface level. if( slot == DepthStencil ) - { + { mTargets[slot] = d3dto->getSurface(); if ( mTargets[slot] ) mTargets[slot]->AddRef(); - mTargetViews[slot] = d3dto->getDSView(); - if( mTargetViews[slot]) - mTargetViews[slot]->AddRef(); + mTargetViews[slot] = d3dto->getDSView(); + if( mTargetViews[slot]) + mTargetViews[slot]->AddRef(); } else @@ -126,12 +126,12 @@ void GFXD3D11TextureTarget::attachTexture( RenderSlot slot, GFXTextureObject *te // if the surface that it needs to render to is different than the mip level // in the actual texture. This will happen with MSAA. if( d3dto->getSurface() == NULL ) - { + { - mTargets[slot] = d3dto->get2DTex(); - mTargets[slot]->AddRef(); - mTargetViews[slot] = d3dto->getRTView(); - mTargetViews[slot]->AddRef(); + mTargets[slot] = d3dto->get2DTex(); + mTargets[slot]->AddRef(); + mTargetViews[slot] = d3dto->getRTView(); + mTargetViews[slot]->AddRef(); } else { @@ -164,11 +164,11 @@ void GFXD3D11TextureTarget::attachTexture( RenderSlot slot, GFXTextureObject *te S32 format = sd.Format; - if (format == DXGI_FORMAT_R8G8B8A8_TYPELESS || format == DXGI_FORMAT_B8G8R8A8_TYPELESS) - { - mTargetFormat = GFXFormatR8G8B8A8; - return; - } + if (format == DXGI_FORMAT_R8G8B8A8_TYPELESS || format == DXGI_FORMAT_B8G8R8A8_TYPELESS) + { + mTargetFormat = GFXFormatR8G8B8A8; + return; + } GFXREVERSE_LOOKUP( GFXD3D11TextureFormat, GFXFormat, format ); mTargetFormat = (GFXFormat)format; @@ -283,7 +283,7 @@ void GFXD3D11TextureTarget::resolve() if (mResolveTargets[i]) { D3D11_TEXTURE2D_DESC desc; - mTargets[i]->GetDesc(&desc); + mTargets[i]->GetDesc(&desc); D3D11DEVICECONTEXT->CopySubresourceRegion(mResolveTargets[i]->get2DTex(), 0, 0, 0, 0, mTargets[i], 0, NULL); } } @@ -407,10 +407,10 @@ void GFXD3D11WindowTarget::activate() void GFXD3D11WindowTarget::resolveTo(GFXTextureObject *tex) { - GFXDEBUGEVENT_SCOPE(GFXPCD3D11WindowTarget_resolveTo, ColorI::RED); + GFXDEBUGEVENT_SCOPE(GFXPCD3D11WindowTarget_resolveTo, ColorI::RED); - D3D11_TEXTURE2D_DESC desc; - ID3D11Texture2D* surf = ((GFXD3D11TextureObject*)(tex))->get2DTex(); - surf->GetDesc(&desc); - D3D11DEVICECONTEXT->ResolveSubresource(surf, 0, D3D11->mDeviceBackbuffer, 0, desc.Format); + D3D11_TEXTURE2D_DESC desc; + ID3D11Texture2D* surf = ((GFXD3D11TextureObject*)(tex))->get2DTex(); + surf->GetDesc(&desc); + D3D11DEVICECONTEXT->ResolveSubresource(surf, 0, D3D11->mDeviceBackbuffer, 0, desc.Format); } \ No newline at end of file diff --git a/Engine/source/gfx/gfxAdapter.h b/Engine/source/gfx/gfxAdapter.h index 221cc4ef3..a7988e910 100644 --- a/Engine/source/gfx/gfxAdapter.h +++ b/Engine/source/gfx/gfxAdapter.h @@ -37,8 +37,8 @@ struct GFXAdapterLUID { - unsigned long LowPart; - long HighPart; + unsigned long LowPart; + long HighPart; }; struct GFXAdapter diff --git a/Engine/source/gfx/gfxDevice.cpp b/Engine/source/gfx/gfxDevice.cpp index 5dcb0bb40..0ee217854 100644 --- a/Engine/source/gfx/gfxDevice.cpp +++ b/Engine/source/gfx/gfxDevice.cpp @@ -160,8 +160,8 @@ GFXDevice::GFXDevice() // misc mAllowRender = true; mCurrentRenderStyle = RS_Standard; - mCurrentStereoTarget = -1; - mStereoHeadTransform = MatrixF(1); + mCurrentStereoTarget = -1; + mStereoHeadTransform = MatrixF(1); mCanCurrentlyRender = false; mInitialized = false; diff --git a/Engine/source/gfx/gfxDevice.h b/Engine/source/gfx/gfxDevice.h index 5aec5ad8e..ef3bbce13 100644 --- a/Engine/source/gfx/gfxDevice.h +++ b/Engine/source/gfx/gfxDevice.h @@ -219,11 +219,11 @@ public: /// The device has started rendering a frame's field (such as for side-by-side rendering) deStartOfField, - /// left stereo frame has been rendered - deLeftStereoFrameRendered, + /// left stereo frame has been rendered + deLeftStereoFrameRendered, - /// right stereo frame has been rendered - deRightStereoFrameRendered, + /// right stereo frame has been rendered + deRightStereoFrameRendered, /// The device is about to finish rendering a frame's field deEndOfField, @@ -254,7 +254,7 @@ public: { RS_Standard = 0, RS_StereoSideBySide = (1<<0), // Render into current Render Target side-by-side - RS_StereoSeparate = (1<<1) // Render in two separate passes (then combined by vr compositor) + RS_StereoSeparate = (1<<1) // Render in two separate passes (then combined by vr compositor) }; enum GFXDeviceLimits @@ -409,7 +409,7 @@ public: setViewport(mStereoViewports[eyeId]); } - mCurrentStereoTarget = eyeId; + mCurrentStereoTarget = eyeId; } GFXCardProfiler* getCardProfiler() const { return mCardProfiler; } @@ -481,7 +481,7 @@ public: /// Returns the first format from the list which meets all /// the criteria of the texture profile and query options. virtual GFXFormat selectSupportedFormat(GFXTextureProfile *profile, - const Vector &formats, bool texture, bool mustblend, bool mustfilter) = 0; + const Vector &formats, bool texture, bool mustblend, bool mustfilter) = 0; /// @} diff --git a/Engine/source/gfx/gfxDrawUtil.cpp b/Engine/source/gfx/gfxDrawUtil.cpp index d68b05e55..3dfe28a3e 100644 --- a/Engine/source/gfx/gfxDrawUtil.cpp +++ b/Engine/source/gfx/gfxDrawUtil.cpp @@ -61,7 +61,7 @@ void GFXDrawUtil::_setupStateBlocks() bitmapStretchSR.setZReadWrite(false); bitmapStretchSR.setBlend(true, GFXBlendSrcAlpha, GFXBlendInvSrcAlpha); bitmapStretchSR.samplersDefined = true; - bitmapStretchSR.setColorWrites(true, true, true, false); + bitmapStretchSR.setColorWrites(true, true, true, false); // NOTE: comment this out if alpha write is needed // Linear: Create wrap SB bitmapStretchSR.samplers[0] = GFXSamplerStateDesc::getWrapLinear(); diff --git a/Engine/source/gfx/gfxFontRenderBatcher.cpp b/Engine/source/gfx/gfxFontRenderBatcher.cpp index 84551506b..fd4cb11cb 100644 --- a/Engine/source/gfx/gfxFontRenderBatcher.cpp +++ b/Engine/source/gfx/gfxFontRenderBatcher.cpp @@ -51,7 +51,7 @@ FontRenderBatcher::FontRenderBatcher() : mStorage(8096) // so it may have to change. -bramage f.samplers[0].textureColorOp = GFXTOPAdd; - f.setColorWrites(true, true, true, false); + f.setColorWrites(true, true, true, false); // NOTE: comment this out if alpha write is needed mFontSB = GFX->createStateBlock(f); } } diff --git a/Engine/source/gfx/gfxInit.cpp b/Engine/source/gfx/gfxInit.cpp index 9d0cf36ac..be4389f73 100644 --- a/Engine/source/gfx/gfxInit.cpp +++ b/Engine/source/gfx/gfxInit.cpp @@ -200,18 +200,18 @@ GFXAdapter* GFXInit::getAdapterOfType( GFXAdapterType type, const char* outputDe GFXAdapter* GFXInit::getAdapterOfType(GFXAdapterType type, S32 outputDeviceIndex) { - for (U32 i = 0; i < smAdapters.size(); i++) - { - if (smAdapters[i]->mType == type) - { - if (smAdapters[i]->mIndex == outputDeviceIndex) - { - return smAdapters[i]; - } - } - } + for (U32 i = 0; i < smAdapters.size(); i++) + { + if (smAdapters[i]->mType == type) + { + if (smAdapters[i]->mIndex == outputDeviceIndex) + { + return smAdapters[i]; + } + } + } - return NULL; + return NULL; } GFXAdapter* GFXInit::chooseAdapter( GFXAdapterType type, const char* outputDevice) @@ -237,23 +237,23 @@ GFXAdapter* GFXInit::chooseAdapter( GFXAdapterType type, const char* outputDevic GFXAdapter* GFXInit::chooseAdapter(GFXAdapterType type, S32 outputDeviceIndex) { - GFXAdapter* adapter = GFXInit::getAdapterOfType(type, outputDeviceIndex); + GFXAdapter* adapter = GFXInit::getAdapterOfType(type, outputDeviceIndex); - if (!adapter && type != OpenGL) - { - Con::errorf("The requested renderer, %s, doesn't seem to be available." - " Trying the default, OpenGL.", getAdapterNameFromType(type)); - adapter = GFXInit::getAdapterOfType(OpenGL, outputDeviceIndex); - } + if (!adapter && type != OpenGL) + { + Con::errorf("The requested renderer, %s, doesn't seem to be available." + " Trying the default, OpenGL.", getAdapterNameFromType(type)); + adapter = GFXInit::getAdapterOfType(OpenGL, outputDeviceIndex); + } - if (!adapter) - { - Con::errorf("The OpenGL renderer doesn't seem to be available. Trying the GFXNulDevice."); - adapter = GFXInit::getAdapterOfType(NullDevice, 0); - } + if (!adapter) + { + Con::errorf("The OpenGL renderer doesn't seem to be available. Trying the GFXNulDevice."); + adapter = GFXInit::getAdapterOfType(NullDevice, 0); + } - AssertFatal(adapter, "There is no rendering device available whatsoever."); - return adapter; + AssertFatal(adapter, "There is no rendering device available whatsoever."); + return adapter; } const char* GFXInit::getAdapterNameFromType(GFXAdapterType type) @@ -304,11 +304,11 @@ GFXAdapter *GFXInit::getBestAdapterChoice() } else { - S32 adapterIdx = dAtoi(adapterDevice.c_str()); - if (adapterIdx == -1) - adapter = chooseAdapter(adapterType, outputDevice.c_str()); - else - adapter = chooseAdapter(adapterType, adapterIdx); + S32 adapterIdx = dAtoi(adapterDevice.c_str()); + if (adapterIdx == -1) + adapter = chooseAdapter(adapterType, outputDevice.c_str()); + else + adapter = chooseAdapter(adapterType, adapterIdx); } // Did they have one? Return it. diff --git a/Engine/source/gfx/gfxInit.h b/Engine/source/gfx/gfxInit.h index 73cdbba02..4152d9ce9 100644 --- a/Engine/source/gfx/gfxInit.h +++ b/Engine/source/gfx/gfxInit.h @@ -74,16 +74,16 @@ public: /// This method never returns NULL. static GFXAdapter *chooseAdapter( GFXAdapterType type, const char* outputDevice); - /// Override which chooses an adapter based on an index instead - static GFXAdapter *chooseAdapter( GFXAdapterType type, S32 outputDeviceIndex ); + /// Override which chooses an adapter based on an index instead + static GFXAdapter *chooseAdapter( GFXAdapterType type, S32 outputDeviceIndex ); /// Gets the first adapter of the requested type (and on the requested output device) /// from the list of enumerated adapters. Should only call this after a call to /// enumerateAdapters. static GFXAdapter *getAdapterOfType( GFXAdapterType type, const char* outputDevice ); - /// Override which gets an adapter based on an index instead - static GFXAdapter *getAdapterOfType( GFXAdapterType type, S32 outputDeviceIndex ); + /// Override which gets an adapter based on an index instead + static GFXAdapter *getAdapterOfType( GFXAdapterType type, S32 outputDeviceIndex ); /// Converts a GFXAdapterType to a string name. Useful for writing out prefs static const char *getAdapterNameFromType( GFXAdapterType type ); diff --git a/Engine/source/gfx/gfxTextureProfile.h b/Engine/source/gfx/gfxTextureProfile.h index d4840cd26..270a41947 100644 --- a/Engine/source/gfx/gfxTextureProfile.h +++ b/Engine/source/gfx/gfxTextureProfile.h @@ -102,8 +102,8 @@ public: /// This is mainly a depth buffer optimization. NoDiscard = BIT(10), - /// Texture is managed by another process, thus should not be modified - NoModify = BIT(11) + /// Texture is managed by another process, thus should not be modified + NoModify = BIT(11) }; @@ -167,7 +167,7 @@ public: inline bool noMip() const { return testFlag(NoMipmap); } inline bool isPooled() const { return testFlag(Pooled); } inline bool canDiscard() const { return !testFlag(NoDiscard); } - inline bool canModify() const { return !testFlag(NoModify); } + inline bool canModify() const { return !testFlag(NoModify); } private: /// These constants control the packing for the profile; if you add flags, types, or diff --git a/Engine/source/gfx/sim/debugDraw.cpp b/Engine/source/gfx/sim/debugDraw.cpp index 8a591fc26..cfa6bf47e 100644 --- a/Engine/source/gfx/sim/debugDraw.cpp +++ b/Engine/source/gfx/sim/debugDraw.cpp @@ -141,73 +141,73 @@ void DebugDrawer::setupStateBlocks() void DebugDrawer::drawBoxOutline(const Point3F &a, const Point3F &b, const ColorF &color) { - Point3F point0(a.x, a.y, a.z); - Point3F point1(a.x, b.y, a.z); - Point3F point2(b.x, b.y, a.z); - Point3F point3(b.x, a.y, a.z); + Point3F point0(a.x, a.y, a.z); + Point3F point1(a.x, b.y, a.z); + Point3F point2(b.x, b.y, a.z); + Point3F point3(b.x, a.y, a.z); - Point3F point4(a.x, a.y, b.z); - Point3F point5(a.x, b.y, b.z); - Point3F point6(b.x, b.y, b.z); - Point3F point7(b.x, a.y, b.z); + Point3F point4(a.x, a.y, b.z); + Point3F point5(a.x, b.y, b.z); + Point3F point6(b.x, b.y, b.z); + Point3F point7(b.x, a.y, b.z); - // Draw one plane - drawLine(point0, point1, color); - drawLine(point1, point2, color); - drawLine(point2, point3, color); - drawLine(point3, point0, color); + // Draw one plane + drawLine(point0, point1, color); + drawLine(point1, point2, color); + drawLine(point2, point3, color); + drawLine(point3, point0, color); - // Draw the other plane - drawLine(point4, point5, color); - drawLine(point5, point6, color); - drawLine(point6, point7, color); - drawLine(point7, point4, color); + // Draw the other plane + drawLine(point4, point5, color); + drawLine(point5, point6, color); + drawLine(point6, point7, color); + drawLine(point7, point4, color); - // Draw the connecting corners - drawLine(point0, point4, color); - drawLine(point1, point5, color); - drawLine(point2, point6, color); - drawLine(point3, point7, color); + // Draw the connecting corners + drawLine(point0, point4, color); + drawLine(point1, point5, color); + drawLine(point2, point6, color); + drawLine(point3, point7, color); } void DebugDrawer::drawTransformedBoxOutline(const Point3F &a, const Point3F &b, const ColorF &color, const MatrixF& transform) { - Point3F point0(a.x, a.y, a.z); - Point3F point1(a.x, b.y, a.z); - Point3F point2(b.x, b.y, a.z); - Point3F point3(b.x, a.y, a.z); + Point3F point0(a.x, a.y, a.z); + Point3F point1(a.x, b.y, a.z); + Point3F point2(b.x, b.y, a.z); + Point3F point3(b.x, a.y, a.z); - Point3F point4(a.x, a.y, b.z); - Point3F point5(a.x, b.y, b.z); - Point3F point6(b.x, b.y, b.z); - Point3F point7(b.x, a.y, b.z); + Point3F point4(a.x, a.y, b.z); + Point3F point5(a.x, b.y, b.z); + Point3F point6(b.x, b.y, b.z); + Point3F point7(b.x, a.y, b.z); - transform.mulP(point0); - transform.mulP(point1); - transform.mulP(point2); - transform.mulP(point3); - transform.mulP(point4); - transform.mulP(point5); - transform.mulP(point6); - transform.mulP(point7); + transform.mulP(point0); + transform.mulP(point1); + transform.mulP(point2); + transform.mulP(point3); + transform.mulP(point4); + transform.mulP(point5); + transform.mulP(point6); + transform.mulP(point7); - // Draw one plane - drawLine(point0, point1, color); - drawLine(point1, point2, color); - drawLine(point2, point3, color); - drawLine(point3, point0, color); + // Draw one plane + drawLine(point0, point1, color); + drawLine(point1, point2, color); + drawLine(point2, point3, color); + drawLine(point3, point0, color); - // Draw the other plane - drawLine(point4, point5, color); - drawLine(point5, point6, color); - drawLine(point6, point7, color); - drawLine(point7, point4, color); + // Draw the other plane + drawLine(point4, point5, color); + drawLine(point5, point6, color); + drawLine(point6, point7, color); + drawLine(point7, point4, color); - // Draw the connecting corners - drawLine(point0, point4, color); - drawLine(point1, point5, color); - drawLine(point2, point6, color); - drawLine(point3, point7, color); + // Draw the connecting corners + drawLine(point0, point4, color); + drawLine(point1, point5, color); + drawLine(point2, point6, color); + drawLine(point3, point7, color); } void DebugDrawer::render(bool clear) diff --git a/Engine/source/gfx/sim/debugDraw.h b/Engine/source/gfx/sim/debugDraw.h index ddaba1164..8c0118c10 100644 --- a/Engine/source/gfx/sim/debugDraw.h +++ b/Engine/source/gfx/sim/debugDraw.h @@ -126,7 +126,7 @@ public: void drawTransformedBoxOutline(const Point3F &a, const Point3F &b, const ColorF &color, const MatrixF& transform); void drawBox(const Point3F &a, const Point3F &b, const ColorF &color = ColorF(1.0f,1.0f,1.0f)); - void drawLine(const Point3F &a, const Point3F &b, const ColorF &color = ColorF(1.0f,1.0f,1.0f)); + void drawLine(const Point3F &a, const Point3F &b, const ColorF &color = ColorF(1.0f,1.0f,1.0f)); void drawTri(const Point3F &a, const Point3F &b, const Point3F &c, const ColorF &color = ColorF(1.0f,1.0f,1.0f)); void drawText(const Point3F& pos, const String& text, const ColorF &color = ColorF(1.0f,1.0f,1.0f)); void drawCapsule(const Point3F &a, const F32 &radius, const F32 &height, const ColorF &color = ColorF(1.0f, 1.0f, 1.0f)); @@ -181,7 +181,7 @@ private: DirectionLine, OutlinedText, Capsule, - } type; ///< Type of the primitive. The meanings of a,b,c are determined by this. + } type; ///< Type of the primitive. The meanings of a,b,c are determined by this. SimTime dieTime; ///< Time at which we should remove this from the list. bool useZ; ///< If true, do z-checks for this primitive. diff --git a/Engine/source/gui/3d/guiTSControl.cpp b/Engine/source/gui/3d/guiTSControl.cpp index 36ae70338..e66ace994 100644 --- a/Engine/source/gui/3d/guiTSControl.cpp +++ b/Engine/source/gui/3d/guiTSControl.cpp @@ -64,9 +64,9 @@ Vector GuiTSCtrl::smAwakeTSCtrls; ImplementEnumType( GuiTSRenderStyles, "Style of rendering for a GuiTSCtrl.\n\n" "@ingroup Gui3D" ) - { GuiTSCtrl::RenderStyleStandard, "standard" }, - { GuiTSCtrl::RenderStyleStereoSideBySide, "stereo side by side" }, - { GuiTSCtrl::RenderStyleStereoSeparate, "stereo separate" }, + { GuiTSCtrl::RenderStyleStandard, "standard" }, + { GuiTSCtrl::RenderStyleStereoSideBySide, "stereo side by side" }, + { GuiTSCtrl::RenderStyleStereoSeparate, "stereo separate" }, EndImplementEnumType; //----------------------------------------------------------------------------- @@ -199,9 +199,9 @@ void GuiTSCtrl::initPersistFields() void GuiTSCtrl::consoleInit() { Con::addVariable("$TSControl::frameCount", TypeS32, &smFrameCount, "The number of frames that have been rendered since this control was created.\n" - "@ingroup Rendering\n"); + "@ingroup Rendering\n"); Con::addVariable("$TSControl::useLatestDisplayTransform", TypeBool, &smUseLatestDisplayTransform, "Use the latest view transform when rendering stereo instead of the one calculated by the last move.\n" - "@ingroup Rendering\n"); + "@ingroup Rendering\n"); } //----------------------------------------------------------------------------- @@ -371,15 +371,15 @@ void GuiTSCtrl::_internalRender(RectI guiViewport, RectI renderViewport, Frustum if (mReflectPriority > 0) { - // Get the total reflection priority. - F32 totalPriority = 0; - for (U32 i = 0; i < smAwakeTSCtrls.size(); i++) - if (smAwakeTSCtrls[i]->isVisible()) - totalPriority += smAwakeTSCtrls[i]->mReflectPriority; + // Get the total reflection priority. + F32 totalPriority = 0; + for (U32 i = 0; i < smAwakeTSCtrls.size(); i++) + if (smAwakeTSCtrls[i]->isVisible()) + totalPriority += smAwakeTSCtrls[i]->mReflectPriority; - REFLECTMGR->update(mReflectPriority / totalPriority, - renderSize, - mLastCameraQuery); + REFLECTMGR->update(mReflectPriority / totalPriority, + renderSize, + mLastCameraQuery); } GFX->setActiveRenderTarget(origTarget); @@ -431,22 +431,22 @@ void GuiTSCtrl::_internalRender(RectI guiViewport, RectI renderViewport, Frustum DebugDrawer* debugDraw = DebugDrawer::get(); if (mRenderStyle == RenderStyleStereoSideBySide && debugDraw->willDraw()) { - // For SBS we need to render over each viewport - Frustum frustum; + // For SBS we need to render over each viewport + Frustum frustum; - GFX->setViewport(mLastCameraQuery.stereoViewports[0]); - MathUtils::makeFovPortFrustum(&frustum, mLastCameraQuery.ortho, mLastCameraQuery.nearPlane, mLastCameraQuery.farPlane, mLastCameraQuery.fovPort[0]); - GFX->setFrustum(frustum); - debugDraw->render(false); + GFX->setViewport(mLastCameraQuery.stereoViewports[0]); + MathUtils::makeFovPortFrustum(&frustum, mLastCameraQuery.ortho, mLastCameraQuery.nearPlane, mLastCameraQuery.farPlane, mLastCameraQuery.fovPort[0]); + GFX->setFrustum(frustum); + debugDraw->render(false); - GFX->setViewport(mLastCameraQuery.stereoViewports[1]); - MathUtils::makeFovPortFrustum(&frustum, mLastCameraQuery.ortho, mLastCameraQuery.nearPlane, mLastCameraQuery.farPlane, mLastCameraQuery.fovPort[1]); - GFX->setFrustum(frustum); - debugDraw->render(); + GFX->setViewport(mLastCameraQuery.stereoViewports[1]); + MathUtils::makeFovPortFrustum(&frustum, mLastCameraQuery.ortho, mLastCameraQuery.nearPlane, mLastCameraQuery.farPlane, mLastCameraQuery.fovPort[1]); + GFX->setFrustum(frustum); + debugDraw->render(); } else { - debugDraw->render(); + debugDraw->render(); } saver.restore(); @@ -637,23 +637,23 @@ void GuiTSCtrl::onRender(Point2I offset, const RectI &updateRect) MathUtils::makeFovPortFrustum(&frustum, mLastCameraQuery.ortho, mLastCameraQuery.nearPlane, mLastCameraQuery.farPlane, mLastCameraQuery.fovPort[0]); mLastCameraQuery.cameraMatrix = myTransforms[0]; frustum.update(); - GFX->activateStereoTarget(0); - mLastCameraQuery.currentEye = 0; - GFX->beginField(); - _internalRender(RectI(Point2I(0, 0), mLastCameraQuery.stereoTargets[0]->getSize()), RectI(Point2I(0, 0), mLastCameraQuery.stereoTargets[0]->getSize()), frustum); + GFX->activateStereoTarget(0); + mLastCameraQuery.currentEye = 0; + GFX->beginField(); + _internalRender(RectI(Point2I(0, 0), mLastCameraQuery.stereoTargets[0]->getSize()), RectI(Point2I(0, 0), mLastCameraQuery.stereoTargets[0]->getSize()), frustum); GFX->getDeviceEventSignal().trigger(GFXDevice::deLeftStereoFrameRendered); - GFX->endField(); + GFX->endField(); // Right - GFX->activateStereoTarget(1); - mLastCameraQuery.currentEye = 1; + GFX->activateStereoTarget(1); + mLastCameraQuery.currentEye = 1; MathUtils::makeFovPortFrustum(&frustum, mLastCameraQuery.ortho, mLastCameraQuery.nearPlane, mLastCameraQuery.farPlane, mLastCameraQuery.fovPort[1]); mLastCameraQuery.cameraMatrix = myTransforms[1]; - frustum.update(); - GFX->beginField(); - _internalRender(RectI(Point2I(0, 0), mLastCameraQuery.stereoTargets[1]->getSize()), RectI(Point2I(0, 0), mLastCameraQuery.stereoTargets[0]->getSize()), frustum); - GFX->getDeviceEventSignal().trigger(GFXDevice::deRightStereoFrameRendered); - GFX->endField(); + frustum.update(); + GFX->beginField(); + _internalRender(RectI(Point2I(0, 0), mLastCameraQuery.stereoTargets[1]->getSize()), RectI(Point2I(0, 0), mLastCameraQuery.stereoTargets[0]->getSize()), frustum); + GFX->getDeviceEventSignal().trigger(GFXDevice::deRightStereoFrameRendered); + GFX->endField(); mLastCameraQuery.cameraMatrix = origMatrix; diff --git a/Engine/source/platform/input/oculusVR/oculusVRDevice.h b/Engine/source/platform/input/oculusVR/oculusVRDevice.h index 603737391..10223b9fc 100644 --- a/Engine/source/platform/input/oculusVR/oculusVRDevice.h +++ b/Engine/source/platform/input/oculusVR/oculusVRDevice.h @@ -83,8 +83,8 @@ protected: /// Which HMD is the active one U32 mActiveDeviceId; - /// Device id we need to use to hook up with oculus - ovrGraphicsLuid mLuid; + /// Device id we need to use to hook up with oculus + ovrGraphicsLuid mLuid; protected: void cleanUp(); diff --git a/Engine/source/platform/input/oculusVR/oculusVRHMDDevice.cpp b/Engine/source/platform/input/oculusVR/oculusVRHMDDevice.cpp index ceccfe4c1..473749320 100644 --- a/Engine/source/platform/input/oculusVR/oculusVRHMDDevice.cpp +++ b/Engine/source/platform/input/oculusVR/oculusVRHMDDevice.cpp @@ -46,10 +46,10 @@ struct OculusTexture { - virtual void AdvanceToNextTexture() = 0; + virtual void AdvanceToNextTexture() = 0; - virtual ~OculusTexture() { - } + virtual ~OculusTexture() { + } }; //------------------------------------------------------------ @@ -57,105 +57,105 @@ struct OculusTexture // needed for D3D11 rendering. struct D3D11OculusTexture : public OculusTexture { - ovrHmd hmd; - ovrSwapTextureSet * TextureSet; - static const int TextureCount = 2; - GFXTexHandle TexRtv[TextureCount]; - GFXDevice *Owner; + ovrHmd hmd; + ovrSwapTextureSet * TextureSet; + static const int TextureCount = 2; + GFXTexHandle TexRtv[TextureCount]; + GFXDevice *Owner; - D3D11OculusTexture(GFXDevice* owner) : - hmd(nullptr), - TextureSet(nullptr), - Owner(owner) - { - TexRtv[0] = TexRtv[1] = nullptr; - } + D3D11OculusTexture(GFXDevice* owner) : + hmd(nullptr), + TextureSet(nullptr), + Owner(owner) + { + TexRtv[0] = TexRtv[1] = nullptr; + } - bool Init(ovrHmd _hmd, int sizeW, int sizeH) - { - hmd = _hmd; + bool Init(ovrHmd _hmd, int sizeW, int sizeH) + { + hmd = _hmd; - D3D11_TEXTURE2D_DESC dsDesc; - dsDesc.Width = sizeW; - dsDesc.Height = sizeH; - dsDesc.MipLevels = 1; - dsDesc.ArraySize = 1; - dsDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;// DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; - dsDesc.SampleDesc.Count = 1; // No multi-sampling allowed - dsDesc.SampleDesc.Quality = 0; - dsDesc.Usage = D3D11_USAGE_DEFAULT; - dsDesc.CPUAccessFlags = 0; - dsDesc.MiscFlags = 0; - dsDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET; + D3D11_TEXTURE2D_DESC dsDesc; + dsDesc.Width = sizeW; + dsDesc.Height = sizeH; + dsDesc.MipLevels = 1; + dsDesc.ArraySize = 1; + dsDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;// DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; + dsDesc.SampleDesc.Count = 1; // No multi-sampling allowed + dsDesc.SampleDesc.Quality = 0; + dsDesc.Usage = D3D11_USAGE_DEFAULT; + dsDesc.CPUAccessFlags = 0; + dsDesc.MiscFlags = 0; + dsDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET; - GFXD3D11Device* device = static_cast(GFX); - ovrResult result = ovr_CreateSwapTextureSetD3D11(hmd, device->mD3DDevice, &dsDesc, ovrSwapTextureSetD3D11_Typeless, &TextureSet); - if (!OVR_SUCCESS(result)) - return false; + GFXD3D11Device* device = static_cast(GFX); + ovrResult result = ovr_CreateSwapTextureSetD3D11(hmd, device->mD3DDevice, &dsDesc, ovrSwapTextureSetD3D11_Typeless, &TextureSet); + if (!OVR_SUCCESS(result)) + return false; - AssertFatal(TextureSet->TextureCount == TextureCount, "TextureCount mismatch."); + AssertFatal(TextureSet->TextureCount == TextureCount, "TextureCount mismatch."); - for (int i = 0; i < TextureCount; ++i) - { - ovrD3D11Texture* tex = (ovrD3D11Texture*)&TextureSet->Textures[i]; - D3D11_RENDER_TARGET_VIEW_DESC rtvd = {}; - rtvd.Format = DXGI_FORMAT_B8G8R8A8_UNORM;// DXGI_FORMAT_R8G8B8A8_UNORM; - rtvd.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; + for (int i = 0; i < TextureCount; ++i) + { + ovrD3D11Texture* tex = (ovrD3D11Texture*)&TextureSet->Textures[i]; + D3D11_RENDER_TARGET_VIEW_DESC rtvd = {}; + rtvd.Format = DXGI_FORMAT_B8G8R8A8_UNORM;// DXGI_FORMAT_R8G8B8A8_UNORM; + rtvd.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; - GFXD3D11TextureObject* object = new GFXD3D11TextureObject(GFX, &VRTextureProfile); - object->registerResourceWithDevice(GFX); - *(object->getSRViewPtr()) = tex->D3D11.pSRView; - *(object->get2DTexPtr()) = tex->D3D11.pTexture; - device->mD3DDevice->CreateRenderTargetView(tex->D3D11.pTexture, &rtvd, object->getRTViewPtr()); + GFXD3D11TextureObject* object = new GFXD3D11TextureObject(GFX, &VRTextureProfile); + object->registerResourceWithDevice(GFX); + *(object->getSRViewPtr()) = tex->D3D11.pSRView; + *(object->get2DTexPtr()) = tex->D3D11.pTexture; + device->mD3DDevice->CreateRenderTargetView(tex->D3D11.pTexture, &rtvd, object->getRTViewPtr()); - // Add refs for texture release later on - if (object->getSRView()) object->getSRView()->AddRef(); - //object->getRTView()->AddRef(); - if (object->get2DTex()) object->get2DTex()->AddRef(); - object->isManaged = true; + // Add refs for texture release later on + if (object->getSRView()) object->getSRView()->AddRef(); + //object->getRTView()->AddRef(); + if (object->get2DTex()) object->get2DTex()->AddRef(); + object->isManaged = true; - // Get the actual size of the texture... - D3D11_TEXTURE2D_DESC probeDesc; - ZeroMemory(&probeDesc, sizeof(D3D11_TEXTURE2D_DESC)); - object->get2DTex()->GetDesc(&probeDesc); + // Get the actual size of the texture... + D3D11_TEXTURE2D_DESC probeDesc; + ZeroMemory(&probeDesc, sizeof(D3D11_TEXTURE2D_DESC)); + object->get2DTex()->GetDesc(&probeDesc); - object->mTextureSize.set(probeDesc.Width, probeDesc.Height, 0); - object->mBitmapSize = object->mTextureSize; - int fmt = probeDesc.Format; + object->mTextureSize.set(probeDesc.Width, probeDesc.Height, 0); + object->mBitmapSize = object->mTextureSize; + int fmt = probeDesc.Format; - if (fmt == DXGI_FORMAT_R8G8B8A8_TYPELESS || fmt == DXGI_FORMAT_B8G8R8A8_TYPELESS) - { - object->mFormat = GFXFormatR8G8B8A8; // usual case - } - else - { - // TODO: improve this. this can be very bad. - GFXREVERSE_LOOKUP(GFXD3D11TextureFormat, GFXFormat, fmt); - object->mFormat = (GFXFormat)fmt; - } - TexRtv[i] = object; - } + if (fmt == DXGI_FORMAT_R8G8B8A8_TYPELESS || fmt == DXGI_FORMAT_B8G8R8A8_TYPELESS) + { + object->mFormat = GFXFormatR8G8B8A8; // usual case + } + else + { + // TODO: improve this. this can be very bad. + GFXREVERSE_LOOKUP(GFXD3D11TextureFormat, GFXFormat, fmt); + object->mFormat = (GFXFormat)fmt; + } + TexRtv[i] = object; + } - return true; - } + return true; + } - ~D3D11OculusTexture() - { - for (int i = 0; i < TextureCount; ++i) - { - SAFE_DELETE(TexRtv[i]); - } - if (TextureSet) - { - ovr_DestroySwapTextureSet(hmd, TextureSet); - } - } + ~D3D11OculusTexture() + { + for (int i = 0; i < TextureCount; ++i) + { + SAFE_DELETE(TexRtv[i]); + } + if (TextureSet) + { + ovr_DestroySwapTextureSet(hmd, TextureSet); + } + } - void AdvanceToNextTexture() - { - TextureSet->CurrentIndex = (TextureSet->CurrentIndex + 1) % TextureSet->TextureCount; - } + void AdvanceToNextTexture() + { + TextureSet->CurrentIndex = (TextureSet->CurrentIndex + 1) % TextureSet->TextureCount; + } }; @@ -176,7 +176,7 @@ OculusVRHMDDevice::OculusVRHMDDevice() mConnection = NULL; mSensor = NULL; mActionCodeIndex = 0; - mTextureSwapSet = NULL; + mTextureSwapSet = NULL; } OculusVRHMDDevice::~OculusVRHMDDevice() @@ -212,35 +212,35 @@ void OculusVRHMDDevice::set(ovrHmd hmd, ovrGraphicsLuid luid, U32 actionCodeInde mDevice = hmd; - ovrHmdDesc desc = ovr_GetHmdDesc(hmd); - int caps = ovr_GetTrackingCaps(hmd); + ovrHmdDesc desc = ovr_GetHmdDesc(hmd); + int caps = ovr_GetTrackingCaps(hmd); mSupportedCaps = desc.AvailableHmdCaps; - mCurrentCaps = mSupportedCaps; - - mTimewarp = true; + mCurrentCaps = mSupportedCaps; + + mTimewarp = true; // DeviceInfo mProductName = desc.ProductName; mManufacturer = desc.Manufacturer; mVersion = desc.FirmwareMajor; - // - Vector adapterList; - GFXD3D11Device::enumerateAdapters(adapterList); + // + Vector adapterList; + GFXD3D11Device::enumerateAdapters(adapterList); - dMemcpy(&mLuid, &luid, sizeof(mLuid)); - mDisplayId = -1; + dMemcpy(&mLuid, &luid, sizeof(mLuid)); + mDisplayId = -1; - for (U32 i = 0, sz = adapterList.size(); i < sz; i++) - { - GFXAdapter* adapter = adapterList[i]; - if (dMemcmp(&adapter->mLUID, &mLuid, sizeof(mLuid)) == 0) - { - mDisplayId = adapter->mIndex; - mDisplayDeviceType = "D3D11"; // TOFIX this - } - } + for (U32 i = 0, sz = adapterList.size(); i < sz; i++) + { + GFXAdapter* adapter = adapterList[i]; + if (dMemcmp(&adapter->mLUID, &mLuid, sizeof(mLuid)) == 0) + { + mDisplayId = adapter->mIndex; + mDisplayDeviceType = "D3D11"; // TOFIX this + } + } mResolution.x = desc.Resolution.w; mResolution.y = desc.Resolution.h; @@ -256,7 +256,7 @@ void OculusVRHMDDevice::set(ovrHmd hmd, ovrGraphicsLuid luid, U32 actionCodeInde mSensor = new OculusVRSensorDevice(); mSensor->set(mDevice, mActionCodeIndex); - mDebugMirrorTexture = NULL; + mDebugMirrorTexture = NULL; updateCaps(); } @@ -274,15 +274,15 @@ void OculusVRHMDDevice::setOptimalDisplaySize(GuiCanvas *canvas) PlatformWindow *window = canvas->getPlatformWindow(); GFXTarget *target = window->getGFXTarget(); - Point2I requiredSize(0, 0); + Point2I requiredSize(0, 0); - ovrHmdDesc desc = ovr_GetHmdDesc(mDevice); - ovrSizei leftSize = ovr_GetFovTextureSize(mDevice, ovrEye_Left, desc.DefaultEyeFov[0], mCurrentPixelDensity); - ovrSizei rightSize = ovr_GetFovTextureSize(mDevice, ovrEye_Right, desc.DefaultEyeFov[1], mCurrentPixelDensity); + ovrHmdDesc desc = ovr_GetHmdDesc(mDevice); + ovrSizei leftSize = ovr_GetFovTextureSize(mDevice, ovrEye_Left, desc.DefaultEyeFov[0], mCurrentPixelDensity); + ovrSizei rightSize = ovr_GetFovTextureSize(mDevice, ovrEye_Right, desc.DefaultEyeFov[1], mCurrentPixelDensity); - requiredSize.x = leftSize.w + rightSize.h; - requiredSize.y = mMax(leftSize.h, rightSize.h); - + requiredSize.x = leftSize.w + rightSize.h; + requiredSize.y = mMax(leftSize.h, rightSize.h); + if (target && target->getSize() != requiredSize) { GFXVideoMode newMode; @@ -302,7 +302,7 @@ bool OculusVRHMDDevice::isDisplayingWarning() if (!mIsValid || !mDevice) return false; - return false;/* + return false;/* ovrHSWDisplayState displayState; ovrHmd_GetHSWDisplayState(mDevice, &displayState); @@ -326,145 +326,145 @@ GFXTexHandle OculusVRHMDDevice::getPreviewTexture() bool OculusVRHMDDevice::setupTargets() { - // Create eye render buffers - ID3D11RenderTargetView * eyeRenderTexRtv[2]; - ovrLayerEyeFov ld = { { ovrLayerType_EyeFov } }; - mRenderLayer = ld; + // Create eye render buffers + ID3D11RenderTargetView * eyeRenderTexRtv[2]; + ovrLayerEyeFov ld = { { ovrLayerType_EyeFov } }; + mRenderLayer = ld; - GFXD3D11Device* device = static_cast(GFX); + GFXD3D11Device* device = static_cast(GFX); - ovrHmdDesc desc = ovr_GetHmdDesc(mDevice); - for (int i = 0; i < 2; i++) - { - mRenderLayer.Fov[i] = desc.DefaultEyeFov[i]; - mRenderLayer.Viewport[i].Size = ovr_GetFovTextureSize(mDevice, (ovrEyeType)i, mRenderLayer.Fov[i], mCurrentPixelDensity); - mEyeRenderDesc[i] = ovr_GetRenderDesc(mDevice, (ovrEyeType_)(ovrEye_Left+i), mRenderLayer.Fov[i]); - } + ovrHmdDesc desc = ovr_GetHmdDesc(mDevice); + for (int i = 0; i < 2; i++) + { + mRenderLayer.Fov[i] = desc.DefaultEyeFov[i]; + mRenderLayer.Viewport[i].Size = ovr_GetFovTextureSize(mDevice, (ovrEyeType)i, mRenderLayer.Fov[i], mCurrentPixelDensity); + mEyeRenderDesc[i] = ovr_GetRenderDesc(mDevice, (ovrEyeType_)(ovrEye_Left+i), mRenderLayer.Fov[i]); + } - ovrSizei recommendedEyeTargetSize[2]; - recommendedEyeTargetSize[0] = mRenderLayer.Viewport[0].Size; - recommendedEyeTargetSize[1] = mRenderLayer.Viewport[1].Size; + ovrSizei recommendedEyeTargetSize[2]; + recommendedEyeTargetSize[0] = mRenderLayer.Viewport[0].Size; + recommendedEyeTargetSize[1] = mRenderLayer.Viewport[1].Size; - if (mTextureSwapSet) - { - delete mTextureSwapSet; - mTextureSwapSet = NULL; - } + if (mTextureSwapSet) + { + delete mTextureSwapSet; + mTextureSwapSet = NULL; + } - // Calculate render target size - if (mDesiredRenderingMode == GFXDevice::RS_StereoSideBySide) - { - // Setup a single texture, side-by-side viewports - Point2I rtSize( - recommendedEyeTargetSize[0].w + recommendedEyeTargetSize[1].w, - recommendedEyeTargetSize[0].h > recommendedEyeTargetSize[1].h ? recommendedEyeTargetSize[0].h : recommendedEyeTargetSize[1].h - ); + // Calculate render target size + if (mDesiredRenderingMode == GFXDevice::RS_StereoSideBySide) + { + // Setup a single texture, side-by-side viewports + Point2I rtSize( + recommendedEyeTargetSize[0].w + recommendedEyeTargetSize[1].w, + recommendedEyeTargetSize[0].h > recommendedEyeTargetSize[1].h ? recommendedEyeTargetSize[0].h : recommendedEyeTargetSize[1].h + ); - GFXFormat targetFormat = GFX->getActiveRenderTarget()->getFormat(); - mRTFormat = targetFormat; + GFXFormat targetFormat = GFX->getActiveRenderTarget()->getFormat(); + mRTFormat = targetFormat; - rtSize = generateRenderTarget(mStereoRT, mStereoDepthTexture, rtSize); + rtSize = generateRenderTarget(mStereoRT, mStereoDepthTexture, rtSize); - // Generate the swap texture we need to store the final image - D3D11OculusTexture* tex = new D3D11OculusTexture(GFX); - if (tex->Init(mDevice, rtSize.x, rtSize.y)) - { - mTextureSwapSet = tex; - } + // Generate the swap texture we need to store the final image + D3D11OculusTexture* tex = new D3D11OculusTexture(GFX); + if (tex->Init(mDevice, rtSize.x, rtSize.y)) + { + mTextureSwapSet = tex; + } - mRenderLayer.ColorTexture[0] = tex->TextureSet; - mRenderLayer.ColorTexture[1] = tex->TextureSet; + mRenderLayer.ColorTexture[0] = tex->TextureSet; + mRenderLayer.ColorTexture[1] = tex->TextureSet; - mRenderLayer.Viewport[0].Pos.x = 0; - mRenderLayer.Viewport[0].Pos.y = 0; - mRenderLayer.Viewport[1].Pos.x = (rtSize.x + 1) / 2; - mRenderLayer.Viewport[1].Pos.y = 0; + mRenderLayer.Viewport[0].Pos.x = 0; + mRenderLayer.Viewport[0].Pos.y = 0; + mRenderLayer.Viewport[1].Pos.x = (rtSize.x + 1) / 2; + mRenderLayer.Viewport[1].Pos.y = 0; - // Left - mEyeRT[0] = mStereoRT; - mEyeViewport[0] = RectI(Point2I(mRenderLayer.Viewport[0].Pos.x, mRenderLayer.Viewport[0].Pos.y), Point2I(mRenderLayer.Viewport[0].Size.w, mRenderLayer.Viewport[0].Size.h)); + // Left + mEyeRT[0] = mStereoRT; + mEyeViewport[0] = RectI(Point2I(mRenderLayer.Viewport[0].Pos.x, mRenderLayer.Viewport[0].Pos.y), Point2I(mRenderLayer.Viewport[0].Size.w, mRenderLayer.Viewport[0].Size.h)); - // Right - mEyeRT[1] = mStereoRT; - mEyeViewport[1] = RectI(Point2I(mRenderLayer.Viewport[1].Pos.x, mRenderLayer.Viewport[1].Pos.y), Point2I(mRenderLayer.Viewport[1].Size.w, mRenderLayer.Viewport[1].Size.h)); + // Right + mEyeRT[1] = mStereoRT; + mEyeViewport[1] = RectI(Point2I(mRenderLayer.Viewport[1].Pos.x, mRenderLayer.Viewport[1].Pos.y), Point2I(mRenderLayer.Viewport[1].Size.w, mRenderLayer.Viewport[1].Size.h)); - GFXD3D11Device* device = static_cast(GFX); + GFXD3D11Device* device = static_cast(GFX); - D3D11_TEXTURE2D_DESC dsDesc; - dsDesc.Width = rtSize.x; - dsDesc.Height = rtSize.y; - dsDesc.MipLevels = 1; - dsDesc.ArraySize = 1; - dsDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;// DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; - dsDesc.SampleDesc.Count = 1; - dsDesc.SampleDesc.Quality = 0; - dsDesc.Usage = D3D11_USAGE_DEFAULT; - dsDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE; - dsDesc.CPUAccessFlags = 0; - dsDesc.MiscFlags = 0; + D3D11_TEXTURE2D_DESC dsDesc; + dsDesc.Width = rtSize.x; + dsDesc.Height = rtSize.y; + dsDesc.MipLevels = 1; + dsDesc.ArraySize = 1; + dsDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;// DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; + dsDesc.SampleDesc.Count = 1; + dsDesc.SampleDesc.Quality = 0; + dsDesc.Usage = D3D11_USAGE_DEFAULT; + dsDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE; + dsDesc.CPUAccessFlags = 0; + dsDesc.MiscFlags = 0; - // Create typeless when we are rendering as non-sRGB since we will override the texture format in the RTV - bool reinterpretSrgbAsLinear = true; - unsigned compositorTextureFlags = 0; - if (reinterpretSrgbAsLinear) - compositorTextureFlags |= ovrSwapTextureSetD3D11_Typeless; + // Create typeless when we are rendering as non-sRGB since we will override the texture format in the RTV + bool reinterpretSrgbAsLinear = true; + unsigned compositorTextureFlags = 0; + if (reinterpretSrgbAsLinear) + compositorTextureFlags |= ovrSwapTextureSetD3D11_Typeless; - ovrResult result = ovr_CreateMirrorTextureD3D11(mDevice, device->mD3DDevice, &dsDesc, compositorTextureFlags, &mDebugMirrorTexture); - - if (result == ovrError_DisplayLost || !mDebugMirrorTexture) - { - AssertFatal(false, "Something went wrong"); - return NULL; - } + ovrResult result = ovr_CreateMirrorTextureD3D11(mDevice, device->mD3DDevice, &dsDesc, compositorTextureFlags, &mDebugMirrorTexture); + + if (result == ovrError_DisplayLost || !mDebugMirrorTexture) + { + AssertFatal(false, "Something went wrong"); + return NULL; + } - // Create texture handle so we can render it in-game - ovrD3D11Texture* mirror_tex = (ovrD3D11Texture*)mDebugMirrorTexture; - D3D11_RENDER_TARGET_VIEW_DESC rtvd = {}; - rtvd.Format = DXGI_FORMAT_B8G8R8A8_UNORM;// DXGI_FORMAT_R8G8B8A8_UNORM; - rtvd.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; + // Create texture handle so we can render it in-game + ovrD3D11Texture* mirror_tex = (ovrD3D11Texture*)mDebugMirrorTexture; + D3D11_RENDER_TARGET_VIEW_DESC rtvd = {}; + rtvd.Format = DXGI_FORMAT_B8G8R8A8_UNORM;// DXGI_FORMAT_R8G8B8A8_UNORM; + rtvd.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; - GFXD3D11TextureObject* object = new GFXD3D11TextureObject(GFX, &VRTextureProfile); - object->registerResourceWithDevice(GFX); - *(object->getSRViewPtr()) = mirror_tex->D3D11.pSRView; - *(object->get2DTexPtr()) = mirror_tex->D3D11.pTexture; - device->mD3DDevice->CreateRenderTargetView(mirror_tex->D3D11.pTexture, &rtvd, object->getRTViewPtr()); + GFXD3D11TextureObject* object = new GFXD3D11TextureObject(GFX, &VRTextureProfile); + object->registerResourceWithDevice(GFX); + *(object->getSRViewPtr()) = mirror_tex->D3D11.pSRView; + *(object->get2DTexPtr()) = mirror_tex->D3D11.pTexture; + device->mD3DDevice->CreateRenderTargetView(mirror_tex->D3D11.pTexture, &rtvd, object->getRTViewPtr()); - // Add refs for texture release later on - if (object->getSRView()) object->getSRView()->AddRef(); - //object->getRTView()->AddRef(); - if (object->get2DTex()) object->get2DTex()->AddRef(); - object->isManaged = true; + // Add refs for texture release later on + if (object->getSRView()) object->getSRView()->AddRef(); + //object->getRTView()->AddRef(); + if (object->get2DTex()) object->get2DTex()->AddRef(); + object->isManaged = true; - // Get the actual size of the texture... - D3D11_TEXTURE2D_DESC probeDesc; - ZeroMemory(&probeDesc, sizeof(D3D11_TEXTURE2D_DESC)); - object->get2DTex()->GetDesc(&probeDesc); + // Get the actual size of the texture... + D3D11_TEXTURE2D_DESC probeDesc; + ZeroMemory(&probeDesc, sizeof(D3D11_TEXTURE2D_DESC)); + object->get2DTex()->GetDesc(&probeDesc); - object->mTextureSize.set(probeDesc.Width, probeDesc.Height, 0); - object->mBitmapSize = object->mTextureSize; - int fmt = probeDesc.Format; + object->mTextureSize.set(probeDesc.Width, probeDesc.Height, 0); + object->mBitmapSize = object->mTextureSize; + int fmt = probeDesc.Format; - if (fmt == DXGI_FORMAT_R8G8B8A8_TYPELESS || fmt == DXGI_FORMAT_B8G8R8A8_TYPELESS) - { - object->mFormat = GFXFormatR8G8B8A8; // usual case - } - else - { - // TODO: improve this. this can be very bad. - GFXREVERSE_LOOKUP(GFXD3D11TextureFormat, GFXFormat, fmt); - object->mFormat = (GFXFormat)fmt; - } - - mDebugMirrorTextureHandle = object; - } - else - { - // No rendering, abort! - return false; - } + if (fmt == DXGI_FORMAT_R8G8B8A8_TYPELESS || fmt == DXGI_FORMAT_B8G8R8A8_TYPELESS) + { + object->mFormat = GFXFormatR8G8B8A8; // usual case + } + else + { + // TODO: improve this. this can be very bad. + GFXREVERSE_LOOKUP(GFXD3D11TextureFormat, GFXFormat, fmt); + object->mFormat = (GFXFormat)fmt; + } + + mDebugMirrorTextureHandle = object; + } + else + { + // No rendering, abort! + return false; + } - return true; + return true; } String OculusVRHMDDevice::dumpMetrics() @@ -510,17 +510,17 @@ void OculusVRHMDDevice::updateRenderInfo() PlatformWindow *window = mDrawCanvas->getPlatformWindow(); - ovrHmdDesc desc = ovr_GetHmdDesc(mDevice); + ovrHmdDesc desc = ovr_GetHmdDesc(mDevice); // Update window size if it's incorrect Point2I backbufferSize = mDrawCanvas->getBounds().extent; - // Finally setup! - if (!setupTargets()) - { - onDeviceDestroy(); - return; - } + // Finally setup! + if (!setupTargets()) + { + onDeviceDestroy(); + return; + } mRenderConfigurationDirty = false; } @@ -583,12 +583,12 @@ void OculusVRHMDDevice::clearRenderTargets() mEyeRT[0] = NULL; mEyeRT[1] = NULL; - if (mDebugMirrorTexture) - { - ovr_DestroyMirrorTexture(mDevice, mDebugMirrorTexture); - mDebugMirrorTexture = NULL; - mDebugMirrorTextureHandle = NULL; - } + if (mDebugMirrorTexture) + { + ovr_DestroyMirrorTexture(mDevice, mDebugMirrorTexture); + mDebugMirrorTexture = NULL; + mDebugMirrorTextureHandle = NULL; + } } void OculusVRHMDDevice::updateCaps() @@ -609,21 +609,21 @@ void OculusVRHMDDevice::onStartFrame() sInFrame = true; ovrVector3f hmdToEyeViewOffset[2] = { mEyeRenderDesc[0].HmdToEyeViewOffset, mEyeRenderDesc[1].HmdToEyeViewOffset }; - ovrTrackingState hmdState = ovr_GetTrackingState(mDevice, 0, ovrTrue); - ovr_CalcEyePoses(hmdState.HeadPose.ThePose, hmdToEyeViewOffset, mRenderLayer.RenderPose); + ovrTrackingState hmdState = ovr_GetTrackingState(mDevice, 0, ovrTrue); + ovr_CalcEyePoses(hmdState.HeadPose.ThePose, hmdToEyeViewOffset, mRenderLayer.RenderPose); for (U32 i=0; i<2; i++) { - mRenderLayer.RenderPose[i].Position.x *= OculusVRDevice::smPositionTrackingScale; - mRenderLayer.RenderPose[i].Position.y *= OculusVRDevice::smPositionTrackingScale; - mRenderLayer.RenderPose[i].Position.z *= OculusVRDevice::smPositionTrackingScale; + mRenderLayer.RenderPose[i].Position.x *= OculusVRDevice::smPositionTrackingScale; + mRenderLayer.RenderPose[i].Position.y *= OculusVRDevice::smPositionTrackingScale; + mRenderLayer.RenderPose[i].Position.z *= OculusVRDevice::smPositionTrackingScale; } - mRenderLayer.SensorSampleTime = ovr_GetTimeInSeconds(); + mRenderLayer.SensorSampleTime = ovr_GetTimeInSeconds(); - // Set current dest texture on stereo render target - D3D11OculusTexture* texSwap = (D3D11OculusTexture*)mTextureSwapSet; - mStereoRT->attachTexture(GFXTextureTarget::Color0, texSwap->TexRtv[texSwap->TextureSet->CurrentIndex]); + // Set current dest texture on stereo render target + D3D11OculusTexture* texSwap = (D3D11OculusTexture*)mTextureSwapSet; + mStereoRT->attachTexture(GFXTextureTarget::Color0, texSwap->TexRtv[texSwap->TextureSet->CurrentIndex]); sInFrame = false; mFrameReady = true; @@ -639,32 +639,32 @@ void OculusVRHMDDevice::onEndFrame() GFXD3D11Device *d3d11GFX = dynamic_cast(GFX); - ovrViewScaleDesc viewScaleDesc; - ovrVector3f hmdToEyeViewOffset[2] = { mEyeRenderDesc[0].HmdToEyeViewOffset, mEyeRenderDesc[1].HmdToEyeViewOffset }; - viewScaleDesc.HmdSpaceToWorldScaleInMeters = 1.0f; - viewScaleDesc.HmdToEyeViewOffset[0] = hmdToEyeViewOffset[0]; - viewScaleDesc.HmdToEyeViewOffset[1] = hmdToEyeViewOffset[1]; + ovrViewScaleDesc viewScaleDesc; + ovrVector3f hmdToEyeViewOffset[2] = { mEyeRenderDesc[0].HmdToEyeViewOffset, mEyeRenderDesc[1].HmdToEyeViewOffset }; + viewScaleDesc.HmdSpaceToWorldScaleInMeters = 1.0f; + viewScaleDesc.HmdToEyeViewOffset[0] = hmdToEyeViewOffset[0]; + viewScaleDesc.HmdToEyeViewOffset[1] = hmdToEyeViewOffset[1]; - ovrLayerDirect ld = { { ovrLayerType_Direct } }; - mDebugRenderLayer = ld; + ovrLayerDirect ld = { { ovrLayerType_Direct } }; + mDebugRenderLayer = ld; - mDebugRenderLayer.ColorTexture[0] = mRenderLayer.ColorTexture[0]; - mDebugRenderLayer.ColorTexture[1] = mRenderLayer.ColorTexture[1]; - mDebugRenderLayer.Viewport[0] = mRenderLayer.Viewport[0]; - mDebugRenderLayer.Viewport[1] = mRenderLayer.Viewport[1]; + mDebugRenderLayer.ColorTexture[0] = mRenderLayer.ColorTexture[0]; + mDebugRenderLayer.ColorTexture[1] = mRenderLayer.ColorTexture[1]; + mDebugRenderLayer.Viewport[0] = mRenderLayer.Viewport[0]; + mDebugRenderLayer.Viewport[1] = mRenderLayer.Viewport[1]; - // TODO: use ovrViewScaleDesc - ovrLayerHeader* layers = &mRenderLayer.Header; - ovrResult result = ovr_SubmitFrame(mDevice, 0, &viewScaleDesc, &layers, 1); - mTextureSwapSet->AdvanceToNextTexture(); + // TODO: use ovrViewScaleDesc + ovrLayerHeader* layers = &mRenderLayer.Header; + ovrResult result = ovr_SubmitFrame(mDevice, 0, &viewScaleDesc, &layers, 1); + mTextureSwapSet->AdvanceToNextTexture(); - if (OVR_SUCCESS(result)) - { - int woo = 1; - } + if (OVR_SUCCESS(result)) + { + int woo = 1; + } - // TODO: render preview in display? + // TODO: render preview in display? mFrameReady = false; } @@ -700,11 +700,11 @@ void OculusVRHMDDevice::onDeviceDestroy() mEyeRT[1]->zombify(); } - if (mTextureSwapSet) - { - delete mTextureSwapSet; - mTextureSwapSet = NULL; - } + if (mTextureSwapSet) + { + delete mTextureSwapSet; + mTextureSwapSet = NULL; + } mStereoRT = NULL; mStereoDepthTexture = NULL; diff --git a/Engine/source/platform/input/oculusVR/oculusVRHMDDevice.h b/Engine/source/platform/input/oculusVR/oculusVRHMDDevice.h index c2e1b5f4e..6a78778b3 100644 --- a/Engine/source/platform/input/oculusVR/oculusVRHMDDevice.h +++ b/Engine/source/platform/input/oculusVR/oculusVRHMDDevice.h @@ -102,7 +102,7 @@ protected: OculusVRSensorDevice *mSensor; U32 mActionCodeIndex; - ovrGraphicsLuid mLuid; + ovrGraphicsLuid mLuid; protected: void updateRenderInfo(); @@ -126,7 +126,7 @@ public: U32 getVersion() const { return mVersion; } // Windows display device name used in EnumDisplaySettings/CreateDC - const char* getDisplayDeviceType () const { return mDisplayDeviceType.c_str(); } + const char* getDisplayDeviceType () const { return mDisplayDeviceType.c_str(); } // MacOS display ID S32 getDisplayDeviceId() const { return mDisplayId; } @@ -190,7 +190,7 @@ public: String dumpMetrics(); // Stereo RT - GFXTexHandle mDebugStereoTexture; + GFXTexHandle mDebugStereoTexture; GFXTexHandle mStereoDepthTexture; GFXTextureTargetRef mStereoRT; @@ -204,12 +204,12 @@ public: F32 smDesiredPixelDensity; ovrTrackingState mLastTrackingState; - OculusTexture* mTextureSwapSet; - ovrLayerEyeFov mRenderLayer; - ovrLayerDirect mDebugRenderLayer; - ovrViewScaleDesc mScaleDesc; - ovrTexture* mDebugMirrorTexture; - GFXTexHandle mDebugMirrorTextureHandle; + OculusTexture* mTextureSwapSet; + ovrLayerEyeFov mRenderLayer; + ovrLayerDirect mDebugRenderLayer; + ovrViewScaleDesc mScaleDesc; + ovrTexture* mDebugMirrorTexture; + GFXTexHandle mDebugMirrorTextureHandle; GFXDevice::GFXDeviceRenderStyles mDesiredRenderingMode; diff --git a/Engine/source/platform/input/openVR/openVROverlay.cpp b/Engine/source/platform/input/openVR/openVROverlay.cpp index 6f4487181..b8f0ecf02 100644 --- a/Engine/source/platform/input/openVR/openVROverlay.cpp +++ b/Engine/source/platform/input/openVR/openVROverlay.cpp @@ -102,10 +102,10 @@ bool OpenVROverlay::onAdd() mOverlayTypeDirty = true; mOverlayDirty = true; - if (OPENVR) - { - OPENVR->registerOverlay(this); - } + if (OPENVR) + { + OPENVR->registerOverlay(this); + } return true; } @@ -127,10 +127,10 @@ void OpenVROverlay::onRemove() mThumbOverlayHandle = NULL; } - if (ManagedSingleton::instanceOrNull()) - { - OPENVR->unregisterOverlay(this); - } + if (ManagedSingleton::instanceOrNull()) + { + OPENVR->unregisterOverlay(this); + } } void OpenVROverlay::resetOverlay() @@ -233,14 +233,14 @@ void OpenVROverlay::showOverlay() if (mOverlayHandle == NULL) return; - if (mOverlayType != OVERLAYTYPE_DASHBOARD) - { - vr::EVROverlayError err = vr::VROverlay()->ShowOverlay(mOverlayHandle); - if (err != vr::VROverlayError_None) - { - Con::errorf("VR Overlay error!"); - } - } + if (mOverlayType != OVERLAYTYPE_DASHBOARD) + { + vr::EVROverlayError err = vr::VROverlay()->ShowOverlay(mOverlayHandle); + if (err != vr::VROverlayError_None) + { + Con::errorf("VR Overlay error!"); + } + } if (!mStagingTexture) { @@ -253,10 +253,10 @@ void OpenVROverlay::hideOverlay() if (mOverlayHandle == NULL) return; - if (mOverlayType != OVERLAYTYPE_DASHBOARD) - { - vr::VROverlay()->HideOverlay(mOverlayHandle); - } + if (mOverlayType != OVERLAYTYPE_DASHBOARD) + { + vr::VROverlay()->HideOverlay(mOverlayHandle); + } } @@ -317,8 +317,8 @@ bool OpenVROverlay::castRay(const Point3F &origin, const Point3F &direction, Ray vr::VROverlayIntersectionParams_t params; vr::VROverlayIntersectionResults_t result; - Point3F ovrOrigin = OpenVRUtil::convertPointToOVR(origin); - Point3F ovrDirection = OpenVRUtil::convertPointToOVR(direction); + Point3F ovrOrigin = OpenVRUtil::convertPointToOVR(origin); + Point3F ovrDirection = OpenVRUtil::convertPointToOVR(direction); params.eOrigin = mTrackingOrigin; params.vSource.v[0] = ovrOrigin.x; @@ -350,17 +350,17 @@ void OpenVROverlay::moveGamepadFocusToNeighbour() void OpenVROverlay::handleOpenVREvents() { - if (mManualMouseHandling) - { - // tell OpenVR to make some events for us - for (vr::TrackedDeviceIndex_t unDeviceId = 1; unDeviceId < vr::k_unControllerStateAxisCount; unDeviceId++) - { - if (vr::VROverlay()->HandleControllerOverlayInteractionAsMouse(mOverlayHandle, unDeviceId)) - { - break; - } - } - } + if (mManualMouseHandling) + { + // tell OpenVR to make some events for us + for (vr::TrackedDeviceIndex_t unDeviceId = 1; unDeviceId < vr::k_unControllerStateAxisCount; unDeviceId++) + { + if (vr::VROverlay()->HandleControllerOverlayInteractionAsMouse(mOverlayHandle, unDeviceId)) + { + break; + } + } + } vr::VREvent_t vrEvent; @@ -373,13 +373,13 @@ void OpenVROverlay::handleOpenVREvents() eventInfo.modifier = (InputModifiers)0; eventInfo.ascii = 0; - //Con::printf("Overlay event %i", vrEvent.eventType); + //Con::printf("Overlay event %i", vrEvent.eventType); switch (vrEvent.eventType) { case vr::VREvent_MouseMove: { - //Con::printf("mousemove %f,%f", vrEvent.data.mouse.x, vrEvent.data.mouse.y); + //Con::printf("mousemove %f,%f", vrEvent.data.mouse.x, vrEvent.data.mouse.y); eventInfo.objType = SI_AXIS; eventInfo.objInst = SI_XAXIS; eventInfo.action = SI_MAKE; @@ -424,11 +424,11 @@ void OpenVROverlay::handleOpenVREvents() AssertFatal(false, "WTF is going on here"); break; - case vr::VREvent_KeyboardCharInput: - case vr::VREvent_KeyboardDone: - updateTextControl((GuiControl*)vrEvent.data.keyboard.uUserValue); - break; - } + case vr::VREvent_KeyboardCharInput: + case vr::VREvent_KeyboardDone: + updateTextControl((GuiControl*)vrEvent.data.keyboard.uUserValue); + break; + } } @@ -450,16 +450,16 @@ void OpenVROverlay::handleOpenVREvents() void OpenVROverlay::updateTextControl(GuiControl* ctrl) { - if (!ctrl) - return; + if (!ctrl) + return; - GuiTextCtrl* textCtrl = dynamic_cast(ctrl); - if (textCtrl) - { - char text[GuiTextCtrl::MAX_STRING_LENGTH]; - vr::VROverlay()->GetKeyboardText(text, GuiTextCtrl::MAX_STRING_LENGTH); - textCtrl->setText(text); - } + GuiTextCtrl* textCtrl = dynamic_cast(ctrl); + if (textCtrl) + { + char text[GuiTextCtrl::MAX_STRING_LENGTH]; + vr::VROverlay()->GetKeyboardText(text, GuiTextCtrl::MAX_STRING_LENGTH); + textCtrl->setText(text); + } } void OpenVROverlay::onFrameRendered() @@ -508,27 +508,27 @@ void OpenVROverlay::onFrameRendered() void OpenVROverlay::enableKeyboardTranslation() { - vr::IVROverlay *overlay = vr::VROverlay(); - if (!overlay || !mOverlayHandle) - return; + vr::IVROverlay *overlay = vr::VROverlay(); + if (!overlay || !mOverlayHandle) + return; - GuiTextEditCtrl* ctrl = dynamic_cast(getFirstResponder()); - if (ctrl) - { - vr::EGamepadTextInputMode inputMode = ctrl->isPasswordText() ? vr::k_EGamepadTextInputModePassword : vr::k_EGamepadTextInputModeNormal; - char text[GuiTextCtrl::MAX_STRING_LENGTH + 1]; - ctrl->getText(text); - overlay->ShowKeyboardForOverlay(mOverlayHandle, inputMode, vr::k_EGamepadTextInputLineModeSingleLine, ctrl->getTooltip().c_str(), GuiTextCtrl::MAX_STRING_LENGTH, text, false, (uint64_t)ctrl); - } + GuiTextEditCtrl* ctrl = dynamic_cast(getFirstResponder()); + if (ctrl) + { + vr::EGamepadTextInputMode inputMode = ctrl->isPasswordText() ? vr::k_EGamepadTextInputModePassword : vr::k_EGamepadTextInputModeNormal; + char text[GuiTextCtrl::MAX_STRING_LENGTH + 1]; + ctrl->getText(text); + overlay->ShowKeyboardForOverlay(mOverlayHandle, inputMode, vr::k_EGamepadTextInputLineModeSingleLine, ctrl->getTooltip().c_str(), GuiTextCtrl::MAX_STRING_LENGTH, text, false, (uint64_t)ctrl); + } } void OpenVROverlay::disableKeyboardTranslation() { - vr::IVROverlay *overlay = vr::VROverlay(); - if (!overlay || !mOverlayHandle) - return; + vr::IVROverlay *overlay = vr::VROverlay(); + if (!overlay || !mOverlayHandle) + return; - overlay->HideKeyboard(); + overlay->HideKeyboard(); } void OpenVROverlay::setNativeAcceleratorsEnabled(bool enabled) diff --git a/Engine/source/platform/input/openVR/openVROverlay.h b/Engine/source/platform/input/openVR/openVROverlay.h index faee66b83..f4ffc6d87 100644 --- a/Engine/source/platform/input/openVR/openVROverlay.h +++ b/Engine/source/platform/input/openVR/openVROverlay.h @@ -57,7 +57,7 @@ public: bool mOverlayTypeDirty; ///< Overlay type is dirty bool mOverlayDirty; ///< Overlay properties are dirty - bool mManualMouseHandling; + bool mManualMouseHandling; OverlayType mOverlayType; // @@ -90,12 +90,12 @@ public: void moveGamepadFocusToNeighbour(); void handleOpenVREvents(); - void updateTextControl(GuiControl* ctrl); + void updateTextControl(GuiControl* ctrl); void onFrameRendered(); - virtual void enableKeyboardTranslation(); - virtual void disableKeyboardTranslation(); - virtual void setNativeAcceleratorsEnabled(bool enabled); + virtual void enableKeyboardTranslation(); + virtual void disableKeyboardTranslation(); + virtual void setNativeAcceleratorsEnabled(bool enabled); }; typedef OpenVROverlay::OverlayType OpenVROverlayType; diff --git a/Engine/source/platform/input/openVR/openVRProvider.cpp b/Engine/source/platform/input/openVR/openVRProvider.cpp index e217cb96a..b60fd007d 100644 --- a/Engine/source/platform/input/openVR/openVRProvider.cpp +++ b/Engine/source/platform/input/openVR/openVRProvider.cpp @@ -33,8 +33,8 @@ struct OpenVRLoadedTexture { - vr::TextureID_t texId; - NamedTexTarget texTarget; + vr::TextureID_t texId; + NamedTexTarget texTarget; }; AngAxisF gLastMoveRot; // jamesu - this is just here for temp debugging @@ -142,15 +142,15 @@ namespace OpenVRUtil String GetTrackedDeviceString(vr::IVRSystem *pHmd, vr::TrackedDeviceIndex_t unDevice, vr::TrackedDeviceProperty prop, vr::TrackedPropertyError *peError = NULL) { - uint32_t unRequiredBufferLen = pHmd->GetStringTrackedDeviceProperty(unDevice, prop, NULL, 0, peError); - if (unRequiredBufferLen == 0) - return ""; + uint32_t unRequiredBufferLen = pHmd->GetStringTrackedDeviceProperty(unDevice, prop, NULL, 0, peError); + if (unRequiredBufferLen == 0) + return ""; - char *pchBuffer = new char[unRequiredBufferLen]; - unRequiredBufferLen = pHmd->GetStringTrackedDeviceProperty(unDevice, prop, pchBuffer, unRequiredBufferLen, peError); - String sResult = pchBuffer; - delete[] pchBuffer; - return sResult; + char *pchBuffer = new char[unRequiredBufferLen]; + unRequiredBufferLen = pHmd->GetStringTrackedDeviceProperty(unDevice, prop, pchBuffer, unRequiredBufferLen, peError); + String sResult = pchBuffer; + delete[] pchBuffer; + return sResult; } } @@ -159,94 +159,94 @@ namespace OpenVRUtil bool OpenVRRenderModel::init(const vr::RenderModel_t & vrModel, StringTableEntry materialName) { - SAFE_DELETE(mMaterialInstance); - mMaterialInstance = MATMGR->createMatInstance(materialName, getGFXVertexFormat< VertexType >()); - if (!mMaterialInstance) - return false; + SAFE_DELETE(mMaterialInstance); + mMaterialInstance = MATMGR->createMatInstance(materialName, getGFXVertexFormat< VertexType >()); + if (!mMaterialInstance) + return false; - mLocalBox = Box3F::Invalid; + mLocalBox = Box3F::Invalid; - // Prepare primitives - U16 *indPtr = NULL; - GFXPrimitive *primPtr = NULL; - mPrimitiveBuffer.set(GFX, vrModel.unTriangleCount * 3, 1, GFXBufferTypeStatic, "OpenVR Controller buffer"); + // Prepare primitives + U16 *indPtr = NULL; + GFXPrimitive *primPtr = NULL; + mPrimitiveBuffer.set(GFX, vrModel.unTriangleCount * 3, 1, GFXBufferTypeStatic, "OpenVR Controller buffer"); - mPrimitiveBuffer.lock(&indPtr, &primPtr); - if (!indPtr || !primPtr) - return false; + mPrimitiveBuffer.lock(&indPtr, &primPtr); + if (!indPtr || !primPtr) + return false; - primPtr->minIndex = 0; - primPtr->numPrimitives = vrModel.unTriangleCount; - primPtr->numVertices = vrModel.unVertexCount; - primPtr->startIndex = 0; - primPtr->startVertex = 0; - primPtr->type = GFXTriangleList; + primPtr->minIndex = 0; + primPtr->numPrimitives = vrModel.unTriangleCount; + primPtr->numVertices = vrModel.unVertexCount; + primPtr->startIndex = 0; + primPtr->startVertex = 0; + primPtr->type = GFXTriangleList; - //dMemcpy(indPtr, vrModel.rIndexData, sizeof(U16) * vrModel.unTriangleCount * 3); + //dMemcpy(indPtr, vrModel.rIndexData, sizeof(U16) * vrModel.unTriangleCount * 3); - for (U32 i = 0; i < vrModel.unTriangleCount; i++) - { - const U32 idx = i * 3; - indPtr[idx + 0] = vrModel.rIndexData[idx + 2]; - indPtr[idx + 1] = vrModel.rIndexData[idx + 1]; - indPtr[idx + 2] = vrModel.rIndexData[idx + 0]; - } + for (U32 i = 0; i < vrModel.unTriangleCount; i++) + { + const U32 idx = i * 3; + indPtr[idx + 0] = vrModel.rIndexData[idx + 2]; + indPtr[idx + 1] = vrModel.rIndexData[idx + 1]; + indPtr[idx + 2] = vrModel.rIndexData[idx + 0]; + } - mPrimitiveBuffer.unlock(); + mPrimitiveBuffer.unlock(); - // Prepare verts - mVertexBuffer.set(GFX, vrModel.unVertexCount, GFXBufferTypeStatic); - VertexType *vertPtr = mVertexBuffer.lock(); - if (!vertPtr) - return false; + // Prepare verts + mVertexBuffer.set(GFX, vrModel.unVertexCount, GFXBufferTypeStatic); + VertexType *vertPtr = mVertexBuffer.lock(); + if (!vertPtr) + return false; - // Convert to torque coordinate system - for (U32 i = 0; i < vrModel.unVertexCount; i++) - { - const vr::RenderModel_Vertex_t &vert = vrModel.rVertexData[i]; - vertPtr->point = OpenVRUtil::convertPointFromOVR(vert.vPosition); - vertPtr->point.x = -vertPtr->point.x; - vertPtr->point.y = -vertPtr->point.y; - vertPtr->point.z = -vertPtr->point.z; - vertPtr->normal = OpenVRUtil::convertPointFromOVR(vert.vNormal); - vertPtr->normal.x = -vertPtr->normal.x; - vertPtr->normal.y = -vertPtr->normal.y; - vertPtr->normal.z = -vertPtr->normal.z; - vertPtr->texCoord = Point2F(vert.rfTextureCoord[0], vert.rfTextureCoord[1]); - vertPtr++; - } + // Convert to torque coordinate system + for (U32 i = 0; i < vrModel.unVertexCount; i++) + { + const vr::RenderModel_Vertex_t &vert = vrModel.rVertexData[i]; + vertPtr->point = OpenVRUtil::convertPointFromOVR(vert.vPosition); + vertPtr->point.x = -vertPtr->point.x; + vertPtr->point.y = -vertPtr->point.y; + vertPtr->point.z = -vertPtr->point.z; + vertPtr->normal = OpenVRUtil::convertPointFromOVR(vert.vNormal); + vertPtr->normal.x = -vertPtr->normal.x; + vertPtr->normal.y = -vertPtr->normal.y; + vertPtr->normal.z = -vertPtr->normal.z; + vertPtr->texCoord = Point2F(vert.rfTextureCoord[0], vert.rfTextureCoord[1]); + vertPtr++; + } - mVertexBuffer.unlock(); + mVertexBuffer.unlock(); - for (U32 i = 0, sz = vrModel.unVertexCount; i < sz; i++) - { - Point3F pos = Point3F(vrModel.rVertexData[i].vPosition.v[0], vrModel.rVertexData[i].vPosition.v[1], vrModel.rVertexData[i].vPosition.v[2]); - mLocalBox.extend(pos); - } + for (U32 i = 0, sz = vrModel.unVertexCount; i < sz; i++) + { + Point3F pos = Point3F(vrModel.rVertexData[i].vPosition.v[0], vrModel.rVertexData[i].vPosition.v[1], vrModel.rVertexData[i].vPosition.v[2]); + mLocalBox.extend(pos); + } - return true; + return true; } void OpenVRRenderModel::draw(SceneRenderState *state, MeshRenderInst* renderInstance) { - renderInstance->type = RenderPassManager::RIT_Mesh; - renderInstance->matInst = state->getOverrideMaterial(mMaterialInstance); - if (!renderInstance->matInst) - return; + renderInstance->type = RenderPassManager::RIT_Mesh; + renderInstance->matInst = state->getOverrideMaterial(mMaterialInstance); + if (!renderInstance->matInst) + return; - renderInstance->vertBuff = &mVertexBuffer; - renderInstance->primBuff = &mPrimitiveBuffer; - renderInstance->prim = NULL; - renderInstance->primBuffIndex = 0; + renderInstance->vertBuff = &mVertexBuffer; + renderInstance->primBuff = &mPrimitiveBuffer; + renderInstance->prim = NULL; + renderInstance->primBuffIndex = 0; - if (renderInstance->matInst->getMaterial()->isTranslucent()) - { - renderInstance->type = RenderPassManager::RIT_Translucent; - renderInstance->translucentSort = true; - } + if (renderInstance->matInst->getMaterial()->isTranslucent()) + { + renderInstance->type = RenderPassManager::RIT_Translucent; + renderInstance->translucentSort = true; + } - renderInstance->defaultKey = renderInstance->matInst->getStateHint(); - renderInstance->defaultKey2 = (uintptr_t)renderInstance->vertBuff; + renderInstance->defaultKey = renderInstance->matInst->getStateHint(); + renderInstance->defaultKey2 = (uintptr_t)renderInstance->vertBuff; } //------------------------------------------------------------ @@ -334,8 +334,8 @@ ImplementEnumType(OpenVRState, EndImplementEnumType; ImplementEnumType(OpenVRTrackedDeviceClass, - "Types of devices which are tracked .\n\n" - "@ingroup OpenVR") + "Types of devices which are tracked .\n\n" + "@ingroup OpenVR") { vr::TrackedDeviceClass_Invalid, "Invalid" }, { vr::TrackedDeviceClass_HMD, "HMD" }, { vr::TrackedDeviceClass_Controller, "Controller" }, @@ -572,27 +572,27 @@ bool OpenVRProvider::enable() HRESULT hr = CreateDXGIFactory1(__uuidof(IDXGIFactory1), reinterpret_cast(&DXGIFactory)); if (FAILED(hr)) - AssertFatal(false, "OpenVRProvider::enable -> CreateDXGIFactory1 call failure"); + AssertFatal(false, "OpenVRProvider::enable -> CreateDXGIFactory1 call failure"); hr = DXGIFactory->EnumAdapters(AdapterIdx, &EnumAdapter); if (FAILED(hr)) { - Con::warnf("VR: HMD device has an invalid adapter."); + Con::warnf("VR: HMD device has an invalid adapter."); } else { - DXGI_ADAPTER_DESC desc; - hr = EnumAdapter->GetDesc(&desc); - if (FAILED(hr)) - { - Con::warnf("VR: HMD device has an invalid adapter."); - } - else - { - dMemcpy(&mLUID, &desc.AdapterLuid, sizeof(mLUID)); - } - SAFE_RELEASE(EnumAdapter); + DXGI_ADAPTER_DESC desc; + hr = EnumAdapter->GetDesc(&desc); + if (FAILED(hr)) + { + Con::warnf("VR: HMD device has an invalid adapter."); + } + else + { + dMemcpy(&mLUID, &desc.AdapterLuid, sizeof(mLUID)); + } + SAFE_RELEASE(EnumAdapter); } SAFE_RELEASE(DXGIFactory); @@ -712,14 +712,14 @@ void OpenVRProvider::buildInputCodeTable() bool OpenVRProvider::process() { if (!mHMD) - return true; + return true; if (!vr::VRCompositor()) - return true; + return true; if (smRotateYawWithMoveActions) { - smHMDmvYaw += MoveManager::mRightAction - MoveManager::mLeftAction + MoveManager::mXAxis_L; + smHMDmvYaw += MoveManager::mRightAction - MoveManager::mLeftAction + MoveManager::mXAxis_L; } // Update HMD rotation offset @@ -745,11 +745,11 @@ bool OpenVRProvider::process() processVREvent(event); } - // process overlay events - for (U32 i = 0; i < mOverlays.size(); i++) - { - mOverlays[i]->handleOpenVREvents(); - } + // process overlay events + for (U32 i = 0; i < mOverlays.size(); i++) + { + mOverlays[i]->handleOpenVREvents(); + } // Process SteamVR controller state for (vr::TrackedDeviceIndex_t unDevice = 0; unDevice < vr::k_unMaxTrackedDeviceCount; unDevice++) @@ -757,7 +757,7 @@ bool OpenVRProvider::process() vr::VRControllerState_t state; if (mHMD->GetControllerState(unDevice, &state)) { - mCurrentControllerState[unDevice] = state; + mCurrentControllerState[unDevice] = state; } } @@ -792,52 +792,52 @@ void OpenVRTransformToRotPos(MatrixF mat, QuatF &outRot, Point3F &outPos) void OpenVRTransformToRotPosMat(MatrixF mat, QuatF &outRot, Point3F &outPos, MatrixF &outMat) { - // Directly set the rotation and position from the eye transforms - MatrixF torqueMat(1); - OpenVRUtil::convertTransformFromOVR(mat, torqueMat); + // Directly set the rotation and position from the eye transforms + MatrixF torqueMat(1); + OpenVRUtil::convertTransformFromOVR(mat, torqueMat); - Point3F pos = torqueMat.getPosition(); - outRot = QuatF(torqueMat); - outPos = pos; - outRot.mulP(pos, &outPos); // jamesu - position needs to be multiplied by rotation in this case - outMat = torqueMat; + Point3F pos = torqueMat.getPosition(); + outRot = QuatF(torqueMat); + outPos = pos; + outRot.mulP(pos, &outPos); // jamesu - position needs to be multiplied by rotation in this case + outMat = torqueMat; } void OpenVRProvider::getFrameEyePose(IDevicePose *pose, S32 eyeId) const { AssertFatal(eyeId >= -1 && eyeId < 2, "Out of bounds eye"); - if (eyeId == -1) - { - // NOTE: this is codename for "head" - MatrixF mat = mHMDRenderState.mHMDPose; // same order as in the openvr example + if (eyeId == -1) + { + // NOTE: this is codename for "head" + MatrixF mat = mHMDRenderState.mHMDPose; // same order as in the openvr example #ifdef DEBUG_DISPLAY_POSE - pose->originalMatrix = mat; - OpenVRTransformToRotPosMat(mat, pose->orientation, pose->position, pose->actualMatrix); + pose->originalMatrix = mat; + OpenVRTransformToRotPosMat(mat, pose->orientation, pose->position, pose->actualMatrix); #else - OpenVRTransformToRotPos(mat, pose->orientation, pose->position); + OpenVRTransformToRotPos(mat, pose->orientation, pose->position); #endif - pose->velocity = Point3F(0); - pose->angularVelocity = Point3F(0); - } - else - { - MatrixF mat = mHMDRenderState.mEyePose[eyeId] * mHMDRenderState.mHMDPose; // same order as in the openvr example - //mat = mHMDRenderState.mHMDPose * mHMDRenderState.mEyePose[eyeId]; // same order as in the openvr example + pose->velocity = Point3F(0); + pose->angularVelocity = Point3F(0); + } + else + { + MatrixF mat = mHMDRenderState.mEyePose[eyeId] * mHMDRenderState.mHMDPose; // same order as in the openvr example + //mat = mHMDRenderState.mHMDPose * mHMDRenderState.mEyePose[eyeId]; // same order as in the openvr example #ifdef DEBUG_DISPLAY_POSE - pose->originalMatrix = mat; - OpenVRTransformToRotPosMat(mat, pose->orientation, pose->position, pose->actualMatrix); + pose->originalMatrix = mat; + OpenVRTransformToRotPosMat(mat, pose->orientation, pose->position, pose->actualMatrix); #else - OpenVRTransformToRotPos(mat, pose->orientation, pose->position); + OpenVRTransformToRotPos(mat, pose->orientation, pose->position); #endif - pose->velocity = Point3F(0); - pose->angularVelocity = Point3F(0); - } + pose->velocity = Point3F(0); + pose->angularVelocity = Point3F(0); + } } bool OpenVRProvider::providesEyeOffsets() const @@ -978,8 +978,8 @@ void OpenVRProvider::onEyeRendered(U32 index) } else if (GFX->getAdapterType() == Direct3D9) { - //vr::Texture_t eyeTexture = { (void*)static_cast(mHMDRenderState.mStereoRenderTextures[index].getPointer())->get2DTex(), vr::API_DirectX, vr::ColorSpace_Gamma }; - //err = vr::VRCompositor()->Submit((vr::EVREye)(vr::Eye_Left + index), &eyeTexture); + //vr::Texture_t eyeTexture = { (void*)static_cast(mHMDRenderState.mStereoRenderTextures[index].getPointer())->get2DTex(), vr::API_DirectX, vr::ColorSpace_Gamma }; + //err = vr::VRCompositor()->Submit((vr::EVREye)(vr::Eye_Left + index), &eyeTexture); } #ifdef TORQUE_OPENGL else if (GFX->getAdapterType() == OpenGL) @@ -1066,23 +1066,23 @@ bool OpenVRProvider::_handleDeviceEvent(GFXDevice::GFXDeviceEventType evt) S32 OpenVRProvider::getDisplayDeviceId() const { #if defined(TORQUE_OS_WIN64) || defined(TORQUE_OS_WIN32) - if (GFX && GFX->getAdapterType() == Direct3D11) - { - Vector adapterList; - GFXD3D11Device::enumerateAdapters(adapterList); + if (GFX && GFX->getAdapterType() == Direct3D11) + { + Vector adapterList; + GFXD3D11Device::enumerateAdapters(adapterList); - for (U32 i = 0, sz = adapterList.size(); i < sz; i++) - { - GFXAdapter* adapter = adapterList[i]; - if (dMemcmp(&adapter->mLUID, &mLUID, sizeof(mLUID)) == 0) - { - return adapter->mIndex; - } - } - } + for (U32 i = 0, sz = adapterList.size(); i < sz; i++) + { + GFXAdapter* adapter = adapterList[i]; + if (dMemcmp(&adapter->mLUID, &mLUID, sizeof(mLUID)) == 0) + { + return adapter->mIndex; + } + } + } #endif - return -1; + return -1; } void OpenVRProvider::processVREvent(const vr::VREvent_t & evt) @@ -1091,8 +1091,8 @@ void OpenVRProvider::processVREvent(const vr::VREvent_t & evt) switch (evt.eventType) { case vr::VREvent_InputFocusCaptured: - //Con::executef() - break; + //Con::executef() + break; case vr::VREvent_TrackedDeviceActivated: { // Setup render model @@ -1145,7 +1145,7 @@ void OpenVRProvider::updateTrackedPoses() { mHMDRenderState.mHMDPose = mat; - /* + /* MatrixF rotOffset(1); EulerF localRot(-smHMDRotOffset.x, -smHMDRotOffset.z, smHMDRotOffset.y); @@ -1155,7 +1155,7 @@ void OpenVRProvider::updateTrackedPoses() QuatF(localRot).setMatrix(&rotOffset); rotOffset.inverse(); mHMDRenderState.mHMDPose = mat = rotOffset * mHMDRenderState.mHMDPose; - */ + */ // jamesu - store the last rotation for temp debugging MatrixF torqueMat(1); @@ -1169,8 +1169,8 @@ void OpenVRProvider::updateTrackedPoses() OpenVRTransformToRotPos(mat, inPose.orientation, inPose.position); #ifdef DEBUG_DISPLAY_POSE - OpenVRUtil::convertTransformFromOVR(mat, inPose.actualMatrix); - inPose.originalMatrix = mat; + OpenVRUtil::convertTransformFromOVR(mat, inPose.actualMatrix); + inPose.originalMatrix = mat; #endif inPose.state = outPose.eTrackingResult; @@ -1195,10 +1195,10 @@ void OpenVRProvider::submitInputChanges() IDevicePose curPose = mCurrentDevicePose[i]; IDevicePose prevPose = mPreviousInputTrackedDevicePose[i]; - S32 eventIdx = -1; - - if (!mDeviceEventMap.tryGetValue(i, eventIdx) || eventIdx < 0) - continue; + S32 eventIdx = -1; + + if (!mDeviceEventMap.tryGetValue(i, eventIdx) || eventIdx < 0) + continue; if (!curPose.valid || !curPose.connected) continue; @@ -1266,293 +1266,293 @@ void OpenVRProvider::resetSensors() void OpenVRProvider::mapDeviceToEvent(U32 deviceIdx, S32 eventIdx) { - mDeviceEventMap[deviceIdx] = eventIdx; + mDeviceEventMap[deviceIdx] = eventIdx; } void OpenVRProvider::resetEventMap() { - mDeviceEventMap.clear(); + mDeviceEventMap.clear(); } IDevicePose OpenVRProvider::getTrackedDevicePose(U32 idx) { - if (idx >= vr::k_unMaxTrackedDeviceCount) - { - IDevicePose ret; - ret.connected = ret.valid = false; - return ret; - } + if (idx >= vr::k_unMaxTrackedDeviceCount) + { + IDevicePose ret; + ret.connected = ret.valid = false; + return ret; + } - return mCurrentDevicePose[idx]; + return mCurrentDevicePose[idx]; } void OpenVRProvider::registerOverlay(OpenVROverlay* overlay) { - mOverlays.push_back(overlay); + mOverlays.push_back(overlay); } void OpenVRProvider::unregisterOverlay(OpenVROverlay* overlay) { - S32 index = mOverlays.find_next(overlay); - if (index != -1) - { - mOverlays.erase(index); - } + S32 index = mOverlays.find_next(overlay); + if (index != -1) + { + mOverlays.erase(index); + } } const S32 OpenVRProvider::preloadRenderModelTexture(U32 index) { - S32 idx = -1; - if (mLoadedTextureLookup.tryGetValue(index, idx)) - return idx; + S32 idx = -1; + if (mLoadedTextureLookup.tryGetValue(index, idx)) + return idx; - char buffer[256]; - dSprintf(buffer, sizeof(buffer), "openvrtex_%u", index); + char buffer[256]; + dSprintf(buffer, sizeof(buffer), "openvrtex_%u", index); - OpenVRProvider::LoadedRenderTexture loadedTexture; - loadedTexture.vrTextureId = index; - loadedTexture.vrTexture = NULL; - loadedTexture.texture = NULL; - loadedTexture.textureError = vr::VRRenderModelError_Loading; - loadedTexture.targetTexture = new NamedTexTarget(); - loadedTexture.targetTexture->registerWithName(buffer); - mLoadedTextures.push_back(loadedTexture); - mLoadedTextureLookup[index] = mLoadedTextures.size() - 1; + OpenVRProvider::LoadedRenderTexture loadedTexture; + loadedTexture.vrTextureId = index; + loadedTexture.vrTexture = NULL; + loadedTexture.texture = NULL; + loadedTexture.textureError = vr::VRRenderModelError_Loading; + loadedTexture.targetTexture = new NamedTexTarget(); + loadedTexture.targetTexture->registerWithName(buffer); + mLoadedTextures.push_back(loadedTexture); + mLoadedTextureLookup[index] = mLoadedTextures.size() - 1; - return mLoadedTextures.size() - 1; + return mLoadedTextures.size() - 1; } const S32 OpenVRProvider::preloadRenderModel(StringTableEntry name) { - S32 idx = -1; - if (mLoadedModelLookup.tryGetValue(name, idx)) - return idx; + S32 idx = -1; + if (mLoadedModelLookup.tryGetValue(name, idx)) + return idx; - OpenVRProvider::LoadedRenderModel loadedModel; - loadedModel.name = name; - loadedModel.model = NULL; - loadedModel.vrModel = NULL; - loadedModel.modelError = vr::VRRenderModelError_Loading; - loadedModel.loadedTexture = false; - loadedModel.textureId = -1; - mLoadedModels.push_back(loadedModel); - mLoadedModelLookup[name] = mLoadedModels.size() - 1; + OpenVRProvider::LoadedRenderModel loadedModel; + loadedModel.name = name; + loadedModel.model = NULL; + loadedModel.vrModel = NULL; + loadedModel.modelError = vr::VRRenderModelError_Loading; + loadedModel.loadedTexture = false; + loadedModel.textureId = -1; + mLoadedModels.push_back(loadedModel); + mLoadedModelLookup[name] = mLoadedModels.size() - 1; - return mLoadedModels.size() - 1; + return mLoadedModels.size() - 1; } bool OpenVRProvider::getRenderModel(S32 idx, OpenVRRenderModel **ret, bool &failed) { - if (idx < 0 || idx > mLoadedModels.size()) - { - failed = true; - return true; - } + if (idx < 0 || idx > mLoadedModels.size()) + { + failed = true; + return true; + } - OpenVRProvider::LoadedRenderModel &loadedModel = mLoadedModels[idx]; - //Con::printf("RenderModel[%i] STAGE 1", idx); + OpenVRProvider::LoadedRenderModel &loadedModel = mLoadedModels[idx]; + //Con::printf("RenderModel[%i] STAGE 1", idx); - failed = false; + failed = false; - if (loadedModel.modelError > vr::VRRenderModelError_Loading) - { - failed = true; - return true; - } + if (loadedModel.modelError > vr::VRRenderModelError_Loading) + { + failed = true; + return true; + } - // Stage 1 : model - if (!loadedModel.model) - { - loadedModel.modelError = vr::VRRenderModels()->LoadRenderModel_Async(loadedModel.name, &loadedModel.vrModel); - //Con::printf(" vr::VRRenderModels()->LoadRenderModel_Async(\"%s\", %x); -> %i", loadedModel.name, &loadedModel.vrModel, loadedModel.modelError); - if (loadedModel.modelError == vr::VRRenderModelError_None) - { - if (loadedModel.vrModel == NULL) - { - failed = true; - return true; - } - // Load the model - loadedModel.model = new OpenVRRenderModel(); - } - else if (loadedModel.modelError == vr::VRRenderModelError_Loading) - { - return false; - } - } + // Stage 1 : model + if (!loadedModel.model) + { + loadedModel.modelError = vr::VRRenderModels()->LoadRenderModel_Async(loadedModel.name, &loadedModel.vrModel); + //Con::printf(" vr::VRRenderModels()->LoadRenderModel_Async(\"%s\", %x); -> %i", loadedModel.name, &loadedModel.vrModel, loadedModel.modelError); + if (loadedModel.modelError == vr::VRRenderModelError_None) + { + if (loadedModel.vrModel == NULL) + { + failed = true; + return true; + } + // Load the model + loadedModel.model = new OpenVRRenderModel(); + } + else if (loadedModel.modelError == vr::VRRenderModelError_Loading) + { + return false; + } + } - //Con::printf("RenderModel[%i] STAGE 2 (texId == %i)", idx, loadedModel.vrModel->diffuseTextureId); + //Con::printf("RenderModel[%i] STAGE 2 (texId == %i)", idx, loadedModel.vrModel->diffuseTextureId); - // Stage 2 : texture - if (!loadedModel.loadedTexture && loadedModel.model) - { - if (loadedModel.textureId == -1) - { - loadedModel.textureId = preloadRenderModelTexture(loadedModel.vrModel->diffuseTextureId); - } + // Stage 2 : texture + if (!loadedModel.loadedTexture && loadedModel.model) + { + if (loadedModel.textureId == -1) + { + loadedModel.textureId = preloadRenderModelTexture(loadedModel.vrModel->diffuseTextureId); + } - if (loadedModel.textureId == -1) - { - failed = true; - return true; - } + if (loadedModel.textureId == -1) + { + failed = true; + return true; + } - if (!getRenderModelTexture(loadedModel.textureId, NULL, failed)) - { - return false; - } + if (!getRenderModelTexture(loadedModel.textureId, NULL, failed)) + { + return false; + } - if (failed) - { - return true; - } + if (failed) + { + return true; + } - loadedModel.loadedTexture = true; + loadedModel.loadedTexture = true; - //Con::printf("RenderModel[%i] GOT TEXTURE"); + //Con::printf("RenderModel[%i] GOT TEXTURE"); - // Now we can load the model. Note we first need to get a Material for the mapped texture - NamedTexTarget *namedTexture = mLoadedTextures[loadedModel.textureId].targetTexture; - String materialName = MATMGR->getMapEntry(namedTexture->getName().c_str()); - if (materialName.isEmpty()) - { - char buffer[256]; - dSprintf(buffer, sizeof(buffer), "#%s", namedTexture->getName().c_str()); - materialName = buffer; + // Now we can load the model. Note we first need to get a Material for the mapped texture + NamedTexTarget *namedTexture = mLoadedTextures[loadedModel.textureId].targetTexture; + String materialName = MATMGR->getMapEntry(namedTexture->getName().c_str()); + if (materialName.isEmpty()) + { + char buffer[256]; + dSprintf(buffer, sizeof(buffer), "#%s", namedTexture->getName().c_str()); + materialName = buffer; - //Con::printf("RenderModel[%i] materialName == %s", idx, buffer); + //Con::printf("RenderModel[%i] materialName == %s", idx, buffer); - Material* mat = new Material(); - mat->mMapTo = namedTexture->getName(); - mat->mDiffuseMapFilename[0] = buffer; - mat->mEmissive[0] = true; + Material* mat = new Material(); + mat->mMapTo = namedTexture->getName(); + mat->mDiffuseMapFilename[0] = buffer; + mat->mEmissive[0] = true; - dSprintf(buffer, sizeof(buffer), "%s_Material", namedTexture->getName().c_str()); - if (!mat->registerObject(buffer)) - { - Con::errorf("Couldn't create placeholder openvr material %s!", buffer); - failed = true; - return true; - } + dSprintf(buffer, sizeof(buffer), "%s_Material", namedTexture->getName().c_str()); + if (!mat->registerObject(buffer)) + { + Con::errorf("Couldn't create placeholder openvr material %s!", buffer); + failed = true; + return true; + } - materialName = buffer; - } - - loadedModel.model->init(*loadedModel.vrModel, materialName); - } + materialName = buffer; + } + + loadedModel.model->init(*loadedModel.vrModel, materialName); + } - if ((loadedModel.modelError > vr::VRRenderModelError_Loading) || - (loadedModel.textureId >= 0 && mLoadedTextures[loadedModel.textureId].textureError > vr::VRRenderModelError_Loading)) - { - failed = true; - } + if ((loadedModel.modelError > vr::VRRenderModelError_Loading) || + (loadedModel.textureId >= 0 && mLoadedTextures[loadedModel.textureId].textureError > vr::VRRenderModelError_Loading)) + { + failed = true; + } - if (!failed && ret) - { - *ret = loadedModel.model; - } - return true; + if (!failed && ret) + { + *ret = loadedModel.model; + } + return true; } bool OpenVRProvider::getRenderModelTexture(S32 idx, GFXTextureObject **outTex, bool &failed) { - if (idx < 0 || idx > mLoadedModels.size()) - { - failed = true; - return true; - } + if (idx < 0 || idx > mLoadedModels.size()) + { + failed = true; + return true; + } - failed = false; + failed = false; - OpenVRProvider::LoadedRenderTexture &loadedTexture = mLoadedTextures[idx]; + OpenVRProvider::LoadedRenderTexture &loadedTexture = mLoadedTextures[idx]; - if (loadedTexture.textureError > vr::VRRenderModelError_Loading) - { - failed = true; - return true; - } + if (loadedTexture.textureError > vr::VRRenderModelError_Loading) + { + failed = true; + return true; + } - if (!loadedTexture.texture) - { - if (!loadedTexture.vrTexture) - { - loadedTexture.textureError = vr::VRRenderModels()->LoadTexture_Async(loadedTexture.vrTextureId, &loadedTexture.vrTexture); - if (loadedTexture.textureError == vr::VRRenderModelError_None) - { - // Load the texture - GFXTexHandle tex; + if (!loadedTexture.texture) + { + if (!loadedTexture.vrTexture) + { + loadedTexture.textureError = vr::VRRenderModels()->LoadTexture_Async(loadedTexture.vrTextureId, &loadedTexture.vrTexture); + if (loadedTexture.textureError == vr::VRRenderModelError_None) + { + // Load the texture + GFXTexHandle tex; - const U32 sz = loadedTexture.vrTexture->unWidth * loadedTexture.vrTexture->unHeight * 4; - GBitmap *bmp = new GBitmap(loadedTexture.vrTexture->unWidth, loadedTexture.vrTexture->unHeight, false, GFXFormatR8G8B8A8); + const U32 sz = loadedTexture.vrTexture->unWidth * loadedTexture.vrTexture->unHeight * 4; + GBitmap *bmp = new GBitmap(loadedTexture.vrTexture->unWidth, loadedTexture.vrTexture->unHeight, false, GFXFormatR8G8B8A8); - Swizzles::bgra.ToBuffer(bmp->getAddress(0,0,0), loadedTexture.vrTexture->rubTextureMapData, sz); + Swizzles::bgra.ToBuffer(bmp->getAddress(0,0,0), loadedTexture.vrTexture->rubTextureMapData, sz); - char buffer[256]; - dSprintf(buffer, 256, "OVRTEX-%i.png", loadedTexture.vrTextureId); + char buffer[256]; + dSprintf(buffer, 256, "OVRTEX-%i.png", loadedTexture.vrTextureId); - FileStream fs; - fs.open(buffer, Torque::FS::File::Write); - bmp->writeBitmap("PNG", fs); - fs.close(); + FileStream fs; + fs.open(buffer, Torque::FS::File::Write); + bmp->writeBitmap("PNG", fs); + fs.close(); - tex.set(bmp, &GFXDefaultStaticDiffuseProfile, true, "OpenVR Texture"); - //tex.set(loadedTexture.vrTexture->unWidth, loadedTexture.vrTexture->unHeight, 1, (void*)pixels, GFXFormatR8G8B8A8, &GFXDefaultStaticDiffuseProfile, "OpenVR Texture", 1); + tex.set(bmp, &GFXDefaultStaticDiffuseProfile, true, "OpenVR Texture"); + //tex.set(loadedTexture.vrTexture->unWidth, loadedTexture.vrTexture->unHeight, 1, (void*)pixels, GFXFormatR8G8B8A8, &GFXDefaultStaticDiffuseProfile, "OpenVR Texture", 1); - loadedTexture.targetTexture->setTexture(tex); - loadedTexture.texture = tex; - } - else if (loadedTexture.textureError == vr::VRRenderModelError_Loading) - { - return false; - } - } - } + loadedTexture.targetTexture->setTexture(tex); + loadedTexture.texture = tex; + } + else if (loadedTexture.textureError == vr::VRRenderModelError_Loading) + { + return false; + } + } + } - if (loadedTexture.textureError > vr::VRRenderModelError_Loading) - { - failed = true; - } + if (loadedTexture.textureError > vr::VRRenderModelError_Loading) + { + failed = true; + } - if (!failed && outTex) - { - *outTex = loadedTexture.texture; - } + if (!failed && outTex) + { + *outTex = loadedTexture.texture; + } - return true; + return true; } bool OpenVRProvider::getRenderModelTextureName(S32 idx, String &outName) { - if (idx < 0 || idx >= mLoadedTextures.size()) - return false; + if (idx < 0 || idx >= mLoadedTextures.size()) + return false; - if (mLoadedTextures[idx].targetTexture) - { - outName = mLoadedTextures[idx].targetTexture->getName(); - return true; - } + if (mLoadedTextures[idx].targetTexture) + { + outName = mLoadedTextures[idx].targetTexture->getName(); + return true; + } - return false; + return false; } void OpenVRProvider::resetRenderModels() { - for (U32 i = 0, sz = mLoadedModels.size(); i < sz; i++) - { - SAFE_DELETE(mLoadedModels[i].model); - if (mLoadedModels[i].vrModel) mRenderModels->FreeRenderModel(mLoadedModels[i].vrModel); - } - for (U32 i = 0, sz = mLoadedTextures.size(); i < sz; i++) - { - SAFE_DELETE(mLoadedTextures[i].targetTexture); - if (mLoadedTextures[i].vrTexture) mRenderModels->FreeTexture(mLoadedTextures[i].vrTexture); - } - mLoadedModels.clear(); - mLoadedTextures.clear(); - mLoadedModelLookup.clear(); - mLoadedTextureLookup.clear(); + for (U32 i = 0, sz = mLoadedModels.size(); i < sz; i++) + { + SAFE_DELETE(mLoadedModels[i].model); + if (mLoadedModels[i].vrModel) mRenderModels->FreeRenderModel(mLoadedModels[i].vrModel); + } + for (U32 i = 0, sz = mLoadedTextures.size(); i < sz; i++) + { + SAFE_DELETE(mLoadedTextures[i].targetTexture); + if (mLoadedTextures[i].vrTexture) mRenderModels->FreeTexture(mLoadedTextures[i].vrTexture); + } + mLoadedModels.clear(); + mLoadedTextures.clear(); + mLoadedModelLookup.clear(); + mLoadedTextureLookup.clear(); } OpenVROverlay *OpenVRProvider::getGamepadFocusOverlay() @@ -1593,50 +1593,50 @@ void OpenVRProvider::setKeyboardPositionForOverlay(OpenVROverlay *overlay, const void OpenVRProvider::getControllerDeviceIndexes(vr::TrackedDeviceClass &deviceClass, Vector &outList) { - for (U32 i = 0; iGetTrackedDeviceClass(i); - if (klass == deviceClass) - { - outList.push_back(i); - } - } + vr::TrackedDeviceClass klass = mHMD->GetTrackedDeviceClass(i); + if (klass == deviceClass) + { + outList.push_back(i); + } + } } StringTableEntry OpenVRProvider::getControllerModel(U32 idx) { - if (idx >= vr::k_unMaxTrackedDeviceCount || !mRenderModels) - return NULL; + if (idx >= vr::k_unMaxTrackedDeviceCount || !mRenderModels) + return NULL; - String str = GetTrackedDeviceString(mHMD, idx, vr::Prop_RenderModelName_String, NULL); - return StringTable->insert(str, true); + String str = GetTrackedDeviceString(mHMD, idx, vr::Prop_RenderModelName_String, NULL); + return StringTable->insert(str, true); } DefineEngineStaticMethod(OpenVR, getControllerDeviceIndexes, const char*, (OpenVRTrackedDeviceClass klass),, - "@brief Gets the indexes of devices which match the required device class") + "@brief Gets the indexes of devices which match the required device class") { - if (!ManagedSingleton::instanceOrNull()) - { - return ""; - } + if (!ManagedSingleton::instanceOrNull()) + { + return ""; + } - Vector outList; - OPENVR->getControllerDeviceIndexes(klass, outList); - return EngineMarshallData>(outList); + Vector outList; + OPENVR->getControllerDeviceIndexes(klass, outList); + return EngineMarshallData>(outList); } DefineEngineStaticMethod(OpenVR, getControllerModel, const char*, (S32 idx), , - "@brief Gets the indexes of devices which match the required device class") + "@brief Gets the indexes of devices which match the required device class") { - if (!ManagedSingleton::instanceOrNull()) - { - return ""; - } + if (!ManagedSingleton::instanceOrNull()) + { + return ""; + } - return OPENVR->getControllerModel(idx); + return OPENVR->getControllerModel(idx); } DefineEngineStaticMethod(OpenVR, isDeviceActive, bool, (), , @@ -1701,17 +1701,17 @@ DefineEngineStaticMethod(OpenVR, setHMDAsGameConnectionDisplayDevice, bool, (Gam DefineEngineStaticMethod(OpenVR, getDisplayDeviceId, S32, (), , - "@brief MacOS display ID.\n\n" - "@param index The HMD index.\n" - "@return The ID of the HMD display device, if any.\n" - "@ingroup Game") + "@brief MacOS display ID.\n\n" + "@param index The HMD index.\n" + "@return The ID of the HMD display device, if any.\n" + "@ingroup Game") { - if (!ManagedSingleton::instanceOrNull()) - { - return -1; - } + if (!ManagedSingleton::instanceOrNull()) + { + return -1; + } - return OPENVR->getDisplayDeviceId(); + return OPENVR->getDisplayDeviceId(); } DefineEngineStaticMethod(OpenVR, resetSensors, void, (), , @@ -1730,27 +1730,27 @@ DefineEngineStaticMethod(OpenVR, resetSensors, void, (), , } DefineEngineStaticMethod(OpenVR, mapDeviceToEvent, void, (S32 deviceId, S32 eventId), , - "@brief Maps a device to an event code.\n\n" - "@ingroup Game") + "@brief Maps a device to an event code.\n\n" + "@ingroup Game") { - if (!ManagedSingleton::instanceOrNull()) - { - return; - } + if (!ManagedSingleton::instanceOrNull()) + { + return; + } - OPENVR->mapDeviceToEvent(deviceId, eventId); + OPENVR->mapDeviceToEvent(deviceId, eventId); } DefineEngineStaticMethod(OpenVR, resetEventMap, void, (), , - "@brief Resets event map.\n\n" - "@ingroup Game") + "@brief Resets event map.\n\n" + "@ingroup Game") { - if (!ManagedSingleton::instanceOrNull()) - { - return; - } + if (!ManagedSingleton::instanceOrNull()) + { + return; + } - OPENVR->resetEventMap(); + OPENVR->resetEventMap(); } // Overlay stuff diff --git a/Engine/source/platform/input/openVR/openVRProvider.h b/Engine/source/platform/input/openVR/openVRProvider.h index f35684e70..009861af4 100644 --- a/Engine/source/platform/input/openVR/openVRProvider.h +++ b/Engine/source/platform/input/openVR/openVRProvider.h @@ -62,91 +62,91 @@ namespace OpenVRUtil U32 convertOpenVRButtonToTorqueButton(uint32_t vrButton); - /// Converts a point to OVR coords - inline Point3F convertPointToOVR(const Point3F &point) - { - return Point3F(-point.x, -point.z, point.y); - } + /// Converts a point to OVR coords + inline Point3F convertPointToOVR(const Point3F &point) + { + return Point3F(-point.x, -point.z, point.y); + } - /// Converts a point from OVR coords - inline Point3F convertPointFromOVR(const Point3F &point) - { - return Point3F(-point.x, point.z, -point.y); - } + /// Converts a point from OVR coords + inline Point3F convertPointFromOVR(const Point3F &point) + { + return Point3F(-point.x, point.z, -point.y); + } - // Converts a point from OVR coords, from an input float array - inline Point3F convertPointFromOVR(const vr::HmdVector3_t& v) - { - return Point3F(-v.v[0], v.v[2], -v.v[1]); - } + // Converts a point from OVR coords, from an input float array + inline Point3F convertPointFromOVR(const vr::HmdVector3_t& v) + { + return Point3F(-v.v[0], v.v[2], -v.v[1]); + } }; template class VRTextureSet { public: - static const int TextureCount = TEXSIZE; - GFXTexHandle mTextures[TEXSIZE]; - U32 mIndex; + static const int TextureCount = TEXSIZE; + GFXTexHandle mTextures[TEXSIZE]; + U32 mIndex; - VRTextureSet() : mIndex(0) - { - } + VRTextureSet() : mIndex(0) + { + } - void init(U32 width, U32 height, GFXFormat fmt, GFXTextureProfile *profile, const String &desc) - { - for (U32 i = 0; i < TextureCount; i++) - { - mTextures[i].set(width, height, fmt, profile, desc); - } - } + void init(U32 width, U32 height, GFXFormat fmt, GFXTextureProfile *profile, const String &desc) + { + for (U32 i = 0; i < TextureCount; i++) + { + mTextures[i].set(width, height, fmt, profile, desc); + } + } - void clear() - { - for (U32 i = 0; i < TextureCount; i++) - { - mTextures[i] = NULL; - } - } + void clear() + { + for (U32 i = 0; i < TextureCount; i++) + { + mTextures[i] = NULL; + } + } - void advance() - { - mIndex = (mIndex + 1) % TextureCount; - } + void advance() + { + mIndex = (mIndex + 1) % TextureCount; + } - GFXTexHandle& getTextureHandle() - { - return mTextures[mIndex]; - } + GFXTexHandle& getTextureHandle() + { + return mTextures[mIndex]; + } }; /// Simple class to handle rendering native OpenVR model data class OpenVRRenderModel { public: - typedef GFXVertexPNT VertexType; - GFXVertexBufferHandle mVertexBuffer; - GFXPrimitiveBufferHandle mPrimitiveBuffer; - BaseMatInstance* mMaterialInstance; ///< Material to use for rendering. NOTE: - Box3F mLocalBox; + typedef GFXVertexPNT VertexType; + GFXVertexBufferHandle mVertexBuffer; + GFXPrimitiveBufferHandle mPrimitiveBuffer; + BaseMatInstance* mMaterialInstance; ///< Material to use for rendering. NOTE: + Box3F mLocalBox; - OpenVRRenderModel() : mMaterialInstance(NULL) - { - } + OpenVRRenderModel() : mMaterialInstance(NULL) + { + } - ~OpenVRRenderModel() - { - SAFE_DELETE(mMaterialInstance); - } + ~OpenVRRenderModel() + { + SAFE_DELETE(mMaterialInstance); + } - Box3F getWorldBox(MatrixF &mat) - { - Box3F ret = mLocalBox; - mat.mul(ret); - return ret; - } + Box3F getWorldBox(MatrixF &mat) + { + Box3F ret = mLocalBox; + mat.mul(ret); + return ret; + } - bool init(const vr::RenderModel_t & vrModel, StringTableEntry materialName); - void draw(SceneRenderState *state, MeshRenderInst* renderInstance); + bool init(const vr::RenderModel_t & vrModel, StringTableEntry materialName); + void draw(SceneRenderState *state, MeshRenderInst* renderInstance); }; struct OpenVRRenderState @@ -196,21 +196,21 @@ public: struct LoadedRenderModel { - StringTableEntry name; - vr::RenderModel_t *vrModel; - OpenVRRenderModel *model; - vr::EVRRenderModelError modelError; - S32 textureId; - bool loadedTexture; + StringTableEntry name; + vr::RenderModel_t *vrModel; + OpenVRRenderModel *model; + vr::EVRRenderModelError modelError; + S32 textureId; + bool loadedTexture; }; struct LoadedRenderTexture { - U32 vrTextureId; - vr::RenderModel_TextureMap_t *vrTexture; - GFXTextureObject *texture; - NamedTexTarget *targetTexture; - vr::EVRRenderModelError textureError; + U32 vrTextureId; + vr::RenderModel_TextureMap_t *vrTexture; + GFXTextureObject *texture; + NamedTexTarget *targetTexture; + vr::EVRRenderModelError textureError; }; OpenVRProvider(); @@ -283,21 +283,21 @@ public: IDevicePose getTrackedDevicePose(U32 idx); /// } - /// @name Overlay registration - /// { - void registerOverlay(OpenVROverlay* overlay); - void unregisterOverlay(OpenVROverlay* overlay); - /// } + /// @name Overlay registration + /// { + void registerOverlay(OpenVROverlay* overlay); + void unregisterOverlay(OpenVROverlay* overlay); + /// } - /// @name Model loading - /// { - const S32 preloadRenderModel(StringTableEntry name); - const S32 preloadRenderModelTexture(U32 index); - bool getRenderModel(S32 idx, OpenVRRenderModel **ret, bool &failed); - bool getRenderModelTexture(S32 idx, GFXTextureObject **outTex, bool &failed); - bool getRenderModelTextureName(S32 idx, String &outName); - void resetRenderModels(); - /// } + /// @name Model loading + /// { + const S32 preloadRenderModel(StringTableEntry name); + const S32 preloadRenderModelTexture(U32 index); + bool getRenderModel(S32 idx, OpenVRRenderModel **ret, bool &failed); + bool getRenderModelTexture(S32 idx, GFXTextureObject **outTex, bool &failed); + bool getRenderModelTextureName(S32 idx, String &outName); + void resetRenderModels(); + /// } /// @name Console API @@ -338,17 +338,17 @@ public: vr::ETrackingUniverseOrigin mTrackingSpace; - Vector mOverlays; + Vector mOverlays; - VREventSignal mVREventSignal; - Namespace *mOpenVRNS; + VREventSignal mVREventSignal; + Namespace *mOpenVRNS; - Vector mLoadedModels; - Vector mLoadedTextures; - Map mLoadedModelLookup; - Map mLoadedTextureLookup; + Vector mLoadedModels; + Vector mLoadedTextures; + Map mLoadedModelLookup; + Map mLoadedTextureLookup; - Map mDeviceEventMap; + Map mDeviceEventMap; /// } GuiCanvas* mDrawCanvas; diff --git a/Engine/source/platform/input/openVR/openVRTrackedObject.cpp b/Engine/source/platform/input/openVR/openVRTrackedObject.cpp index a4467f55c..584ccda11 100644 --- a/Engine/source/platform/input/openVR/openVRTrackedObject.cpp +++ b/Engine/source/platform/input/openVR/openVRTrackedObject.cpp @@ -31,7 +31,7 @@ bool OpenVRTrackedObject::smDebugControllerMovePosition = true; bool OpenVRTrackedObject::smDebugControllerPosition = false; static const U32 sCollisionMoveMask = (PlayerObjectType | - StaticShapeObjectType | VehicleObjectType); + StaticShapeObjectType | VehicleObjectType); U32 OpenVRTrackedObject::sServerCollisionMask = sCollisionMoveMask; // ItemObjectType U32 OpenVRTrackedObject::sClientCollisionMask = sCollisionMoveMask; @@ -43,8 +43,8 @@ IMPLEMENT_CO_DATABLOCK_V1(OpenVRTrackedObjectData); OpenVRTrackedObjectData::OpenVRTrackedObjectData() : mShapeFile(NULL) { - mCollisionBoxMin = Point3F(-0.02, -0.20, -0.02); - mCollisionBoxMax = Point3F(0.02, 0.05, 0.02); + mCollisionBoxMin = Point3F(-0.02, -0.20, -0.02); + mCollisionBoxMax = Point3F(0.02, 0.05, 0.02); } OpenVRTrackedObjectData::~OpenVRTrackedObjectData() @@ -53,49 +53,49 @@ OpenVRTrackedObjectData::~OpenVRTrackedObjectData() bool OpenVRTrackedObjectData::onAdd() { - if (Parent::onAdd()) - { - return true; - } + if (Parent::onAdd()) + { + return true; + } - return false; + return false; } bool OpenVRTrackedObjectData::preload(bool server, String &errorStr) { - if (!Parent::preload(server, errorStr)) - return false; + if (!Parent::preload(server, errorStr)) + return false; - bool error = false; - if (!server) - { - mShape = mShapeFile ? ResourceManager::get().load(mShapeFile) : NULL; - } + bool error = false; + if (!server) + { + mShape = mShapeFile ? ResourceManager::get().load(mShapeFile) : NULL; + } } void OpenVRTrackedObjectData::initPersistFields() { - addGroup("Render Components"); - addField("shape", TypeShapeFilename, Offset(mShapeFile, OpenVRTrackedObjectData), "Shape file to use for controller model."); - addField("collisionMin", TypePoint3F, Offset(mCollisionBoxMin, OpenVRTrackedObjectData), "Box min"); - addField("collisionMax", TypePoint3F, Offset(mCollisionBoxMax, OpenVRTrackedObjectData), "Box min"); - endGroup("Render Components"); + addGroup("Render Components"); + addField("shape", TypeShapeFilename, Offset(mShapeFile, OpenVRTrackedObjectData), "Shape file to use for controller model."); + addField("collisionMin", TypePoint3F, Offset(mCollisionBoxMin, OpenVRTrackedObjectData), "Box min"); + addField("collisionMax", TypePoint3F, Offset(mCollisionBoxMax, OpenVRTrackedObjectData), "Box min"); + endGroup("Render Components"); - Parent::initPersistFields(); + Parent::initPersistFields(); } void OpenVRTrackedObjectData::packData(BitStream* stream) { - Parent::packData(stream); + Parent::packData(stream); - stream->writeString(mShapeFile); + stream->writeString(mShapeFile); } void OpenVRTrackedObjectData::unpackData(BitStream* stream) { - Parent::unpackData(stream); + Parent::unpackData(stream); - mShapeFile = stream->readSTString(); + mShapeFile = stream->readSTString(); } //----------------------------------------------------------------------------- @@ -104,11 +104,11 @@ void OpenVRTrackedObjectData::unpackData(BitStream* stream) IMPLEMENT_CO_NETOBJECT_V1(OpenVRTrackedObject); ConsoleDocClass(OpenVRTrackedObject, - "@brief Renders and handles interactions OpenVR controllers and tracked objects.\n\n" - "This class implements basic rendering and interactions with OpenVR controllers.\n\n" - "The object should be controlled by a player object. Controllers will be rendered at\n" - "the correct position regardless of the current transform of the object.\n" - "@ingroup OpenVR\n"); + "@brief Renders and handles interactions OpenVR controllers and tracked objects.\n\n" + "This class implements basic rendering and interactions with OpenVR controllers.\n\n" + "The object should be controlled by a player object. Controllers will be rendered at\n" + "the correct position regardless of the current transform of the object.\n" + "@ingroup OpenVR\n"); //----------------------------------------------------------------------------- @@ -124,122 +124,122 @@ OpenVRTrackedObject::OpenVRTrackedObject() : mConvexList(new Convex()), mPhysicsRep(NULL) { - // Flag this object so that it will always - // be sent across the network to clients - mNetFlags.set(Ghostable | ScopeAlways); + // Flag this object so that it will always + // be sent across the network to clients + mNetFlags.set(Ghostable | ScopeAlways); - // Set it as a "static" object that casts shadows - mTypeMask |= StaticObjectType | StaticShapeObjectType; + // Set it as a "static" object that casts shadows + mTypeMask |= StaticObjectType | StaticShapeObjectType; - mPose.connected = false; + mPose.connected = false; } OpenVRTrackedObject::~OpenVRTrackedObject() { - clearRenderData(); - delete mConvexList; + clearRenderData(); + delete mConvexList; } void OpenVRTrackedObject::updateRenderData() { - clearRenderData(); + clearRenderData(); - if (!mDataBlock) - return; + if (!mDataBlock) + return; - // Are we using a model? - if (mDataBlock->mShape) - { - if (mShapeInstance && mShapeInstance->getShape() != mDataBlock->mShape) - { - delete mShapeInstance; - mShapeInstance = NULL; - } + // Are we using a model? + if (mDataBlock->mShape) + { + if (mShapeInstance && mShapeInstance->getShape() != mDataBlock->mShape) + { + delete mShapeInstance; + mShapeInstance = NULL; + } - if (!mShapeInstance) - { - mShapeInstance = new TSShapeInstance(mDataBlock->mShape, isClientObject()); - } - } - else - { - setupRenderDataFromModel(isClientObject()); - } + if (!mShapeInstance) + { + mShapeInstance = new TSShapeInstance(mDataBlock->mShape, isClientObject()); + } + } + else + { + setupRenderDataFromModel(isClientObject()); + } } void OpenVRTrackedObject::setupRenderDataFromModel(bool loadComponentModels) { - clearRenderData(); - - if (!OPENVR || !OPENVR->isEnabled()) - return; + clearRenderData(); + + if (!OPENVR || !OPENVR->isEnabled()) + return; - vr::IVRRenderModels *models = OPENVR->getRenderModels(); - if (!models) - return; + vr::IVRRenderModels *models = OPENVR->getRenderModels(); + if (!models) + return; - if (!mShapeInstance && mModelName && mModelName[0] != '\0') - { - bool failed = false; - S32 idx = OPENVR->preloadRenderModel(mModelName); - while (!OPENVR->getRenderModel(idx, &mBasicModel, failed)) - { - if (failed) - break; - } - } + if (!mShapeInstance && mModelName && mModelName[0] != '\0') + { + bool failed = false; + S32 idx = OPENVR->preloadRenderModel(mModelName); + while (!OPENVR->getRenderModel(idx, &mBasicModel, failed)) + { + if (failed) + break; + } + } - if (loadComponentModels) - { - mRenderComponents.setSize(models->GetComponentCount(mModelName)); + if (loadComponentModels) + { + mRenderComponents.setSize(models->GetComponentCount(mModelName)); - for (U32 i = 0, sz = mRenderComponents.size(); i < sz; i++) - { - RenderModelSlot &slot = mRenderComponents[i]; - char buffer[1024]; + for (U32 i = 0, sz = mRenderComponents.size(); i < sz; i++) + { + RenderModelSlot &slot = mRenderComponents[i]; + char buffer[1024]; - slot.mappedNodeIdx = -1; - slot.componentName = NULL; - slot.nativeModel = NULL; + slot.mappedNodeIdx = -1; + slot.componentName = NULL; + slot.nativeModel = NULL; - U32 result = models->GetComponentName(mModelName, i, buffer, sizeof(buffer)); - if (result == 0) - continue; + U32 result = models->GetComponentName(mModelName, i, buffer, sizeof(buffer)); + if (result == 0) + continue; #ifdef DEBUG_CONTROLLER_MODELS - Con::printf("Controller[%s] component %i NAME == %s", mModelName, i, buffer); + Con::printf("Controller[%s] component %i NAME == %s", mModelName, i, buffer); #endif - slot.componentName = StringTable->insert(buffer, true); + slot.componentName = StringTable->insert(buffer, true); - result = models->GetComponentRenderModelName(mModelName, slot.componentName, buffer, sizeof(buffer)); - if (result == 0) - { + result = models->GetComponentRenderModelName(mModelName, slot.componentName, buffer, sizeof(buffer)); + if (result == 0) + { #ifdef DEBUG_CONTROLLER_MODELS - Con::printf("Controller[%s] component %i NO MODEL", mModelName, i); + Con::printf("Controller[%s] component %i NO MODEL", mModelName, i); #endif - continue; - } + continue; + } #ifdef DEBUG_CONTROLLER_MODELS - Con::printf("Controller[%s] component %i == %s", mModelName, i, slot.componentName); + Con::printf("Controller[%s] component %i == %s", mModelName, i, slot.componentName); #endif - bool failed = false; - S32 idx = OPENVR->preloadRenderModel(StringTable->insert(buffer, true)); - while (!OPENVR->getRenderModel(idx, &slot.nativeModel, failed)) - { - if (failed) - break; - } - } - } + bool failed = false; + S32 idx = OPENVR->preloadRenderModel(StringTable->insert(buffer, true)); + while (!OPENVR->getRenderModel(idx, &slot.nativeModel, failed)) + { + if (failed) + break; + } + } + } } void OpenVRTrackedObject::clearRenderData() { - mBasicModel = NULL; - mRenderComponents.clear(); + mBasicModel = NULL; + mRenderComponents.clear(); } //----------------------------------------------------------------------------- @@ -247,735 +247,735 @@ void OpenVRTrackedObject::clearRenderData() //----------------------------------------------------------------------------- void OpenVRTrackedObject::initPersistFields() { - // SceneObject already handles exposing the transform - Parent::initPersistFields(); + // SceneObject already handles exposing the transform + Parent::initPersistFields(); - addField("deviceIndex", TypeS32, Offset(mDeviceIndex, OpenVRTrackedObject), "Index of device to track"); - addField("mappedMoveIndex", TypeS32, Offset(mMappedMoveIndex, OpenVRTrackedObject), "Index of movemanager state to track"); addField("deviceIndex", TypeS32, Offset(mDeviceIndex, OpenVRTrackedObject), "Index of device to track"); - addField("ignoreParentRotation", TypeBool, Offset(mIgnoreParentRotation, OpenVRTrackedObject), "Index of movemanager state to track"); addField("deviceIndex", TypeS32, Offset(mDeviceIndex, OpenVRTrackedObject), "Index of device to track"); + addField("deviceIndex", TypeS32, Offset(mDeviceIndex, OpenVRTrackedObject), "Index of device to track"); + addField("mappedMoveIndex", TypeS32, Offset(mMappedMoveIndex, OpenVRTrackedObject), "Index of movemanager state to track"); addField("deviceIndex", TypeS32, Offset(mDeviceIndex, OpenVRTrackedObject), "Index of device to track"); + addField("ignoreParentRotation", TypeBool, Offset(mIgnoreParentRotation, OpenVRTrackedObject), "Index of movemanager state to track"); addField("deviceIndex", TypeS32, Offset(mDeviceIndex, OpenVRTrackedObject), "Index of device to track"); - static bool conInit = false; - if (!conInit) - { - Con::addVariable("$OpenVRTrackedObject::debugControllerPosition", TypeBool, &smDebugControllerPosition); - Con::addVariable("$OpenVRTrackedObject::debugControllerMovePosition", TypeBool, &smDebugControllerMovePosition); - conInit = true; - } + static bool conInit = false; + if (!conInit) + { + Con::addVariable("$OpenVRTrackedObject::debugControllerPosition", TypeBool, &smDebugControllerPosition); + Con::addVariable("$OpenVRTrackedObject::debugControllerMovePosition", TypeBool, &smDebugControllerMovePosition); + conInit = true; + } } void OpenVRTrackedObject::inspectPostApply() { - Parent::inspectPostApply(); + Parent::inspectPostApply(); - // Flag the network mask to send the updates - // to the client object - setMaskBits(UpdateMask); + // Flag the network mask to send the updates + // to the client object + setMaskBits(UpdateMask); } bool OpenVRTrackedObject::onAdd() { - if (!Parent::onAdd()) - return false; + if (!Parent::onAdd()) + return false; - // Set up a 1x1x1 bounding box - mObjBox.set(Point3F(-0.5f, -0.5f, -0.5f), - Point3F(0.5f, 0.5f, 0.5f)); + // Set up a 1x1x1 bounding box + mObjBox.set(Point3F(-0.5f, -0.5f, -0.5f), + Point3F(0.5f, 0.5f, 0.5f)); - resetWorldBox(); + resetWorldBox(); - // Add this object to the scene - addToScene(); + // Add this object to the scene + addToScene(); - if (mDataBlock) - { - mObjBox.minExtents = mDataBlock->mCollisionBoxMin; - mObjBox.maxExtents = mDataBlock->mCollisionBoxMax; - resetWorldBox(); - } - else - { - setGlobalBounds(); - } + if (mDataBlock) + { + mObjBox.minExtents = mDataBlock->mCollisionBoxMin; + mObjBox.maxExtents = mDataBlock->mCollisionBoxMax; + resetWorldBox(); + } + else + { + setGlobalBounds(); + } - return true; + return true; } void OpenVRTrackedObject::onRemove() { - // Remove this object from the scene - removeFromScene(); + // Remove this object from the scene + removeFromScene(); - clearRenderData(); + clearRenderData(); - SAFE_DELETE(mPhysicsRep); + SAFE_DELETE(mPhysicsRep); - Parent::onRemove(); + Parent::onRemove(); } void OpenVRTrackedObject::_updatePhysics() { - SAFE_DELETE(mPhysicsRep); + SAFE_DELETE(mPhysicsRep); - if (!PHYSICSMGR) - return; + if (!PHYSICSMGR) + return; - PhysicsCollision *colShape = NULL; - MatrixF offset(true); - colShape = PHYSICSMGR->createCollision(); - colShape->addBox(getObjBox().getExtents() * 0.5f * mObjScale, offset); + PhysicsCollision *colShape = NULL; + MatrixF offset(true); + colShape = PHYSICSMGR->createCollision(); + colShape->addBox(getObjBox().getExtents() * 0.5f * mObjScale, offset); - if (colShape) - { - PhysicsWorld *world = PHYSICSMGR->getWorld(isServerObject() ? "server" : "client"); - mPhysicsRep = PHYSICSMGR->createBody(); - mPhysicsRep->init(colShape, 0, PhysicsBody::BF_TRIGGER | PhysicsBody::BF_KINEMATIC, this, world); - mPhysicsRep->setTransform(getTransform()); - } + if (colShape) + { + PhysicsWorld *world = PHYSICSMGR->getWorld(isServerObject() ? "server" : "client"); + mPhysicsRep = PHYSICSMGR->createBody(); + mPhysicsRep->init(colShape, 0, PhysicsBody::BF_TRIGGER | PhysicsBody::BF_KINEMATIC, this, world); + mPhysicsRep->setTransform(getTransform()); + } } bool OpenVRTrackedObject::onNewDataBlock(GameBaseData *dptr, bool reload) { - mDataBlock = dynamic_cast(dptr); - if (!mDataBlock || !Parent::onNewDataBlock(dptr, reload)) - return false; + mDataBlock = dynamic_cast(dptr); + if (!mDataBlock || !Parent::onNewDataBlock(dptr, reload)) + return false; - // Setup the models - clearRenderData(); + // Setup the models + clearRenderData(); - mObjBox.minExtents = mDataBlock->mCollisionBoxMin; - mObjBox.maxExtents = mDataBlock->mCollisionBoxMax; + mObjBox.minExtents = mDataBlock->mCollisionBoxMin; + mObjBox.maxExtents = mDataBlock->mCollisionBoxMax; - mGlobalBounds = false; + mGlobalBounds = false; - resetWorldBox(); + resetWorldBox(); - _updatePhysics(); + _updatePhysics(); - scriptOnNewDataBlock(); + scriptOnNewDataBlock(); - return true; + return true; } void OpenVRTrackedObject::setInteractObject(SceneObject* object, bool holding) { - mInteractObject = object; - mHoldInteractedObject = holding; + mInteractObject = object; + mHoldInteractedObject = holding; } void OpenVRTrackedObject::setTransform(const MatrixF & mat) { - // Let SceneObject handle all of the matrix manipulation - Parent::setTransform(mat); + // Let SceneObject handle all of the matrix manipulation + Parent::setTransform(mat); - // Dirty our network mask so that the new transform gets - // transmitted to the client object - setMaskBits(UpdateMask); + // Dirty our network mask so that the new transform gets + // transmitted to the client object + setMaskBits(UpdateMask); } void OpenVRTrackedObject::setModelName(String &modelName) { - if (!isServerObject()) - return; + if (!isServerObject()) + return; - mModelName = StringTable->insert(modelName.c_str(), true); - setMaskBits(UpdateMask); + mModelName = StringTable->insert(modelName.c_str(), true); + setMaskBits(UpdateMask); } U32 OpenVRTrackedObject::packUpdate(NetConnection *conn, U32 mask, BitStream *stream) { - // Allow the Parent to get a crack at writing its info - U32 retMask = Parent::packUpdate(conn, mask, stream); + // Allow the Parent to get a crack at writing its info + U32 retMask = Parent::packUpdate(conn, mask, stream); - // Write our transform information - if (stream->writeFlag(mask & UpdateMask)) - { - mathWrite(*stream, getTransform()); - mathWrite(*stream, getScale()); + // Write our transform information + if (stream->writeFlag(mask & UpdateMask)) + { + mathWrite(*stream, getTransform()); + mathWrite(*stream, getScale()); - stream->write((S16)mDeviceIndex); - stream->write((S16)mMappedMoveIndex); - stream->writeString(mModelName); - } + stream->write((S16)mDeviceIndex); + stream->write((S16)mMappedMoveIndex); + stream->writeString(mModelName); + } - return retMask; + return retMask; } void OpenVRTrackedObject::unpackUpdate(NetConnection *conn, BitStream *stream) { - // Let the Parent read any info it sent - Parent::unpackUpdate(conn, stream); + // Let the Parent read any info it sent + Parent::unpackUpdate(conn, stream); - if (stream->readFlag()) // UpdateMask - { - mathRead(*stream, &mObjToWorld); - mathRead(*stream, &mObjScale); + if (stream->readFlag()) // UpdateMask + { + mathRead(*stream, &mObjToWorld); + mathRead(*stream, &mObjScale); - setTransform(mObjToWorld); - - S16 readDeviceIndex; - S16 readMoveIndex; - stream->read(&readDeviceIndex); - stream->read(&readMoveIndex); + setTransform(mObjToWorld); + + S16 readDeviceIndex; + S16 readMoveIndex; + stream->read(&readDeviceIndex); + stream->read(&readMoveIndex); - mDeviceIndex = readDeviceIndex; - mMappedMoveIndex = readMoveIndex; - mModelName = stream->readSTString(); + mDeviceIndex = readDeviceIndex; + mMappedMoveIndex = readMoveIndex; + mModelName = stream->readSTString(); - updateRenderData(); - } + updateRenderData(); + } } void OpenVRTrackedObject::writePacketData(GameConnection *conn, BitStream *stream) { - Parent::writePacketData(conn, stream); + Parent::writePacketData(conn, stream); } void OpenVRTrackedObject::readPacketData(GameConnection *conn, BitStream *stream) { - Parent::readPacketData(conn, stream); + Parent::readPacketData(conn, stream); } MatrixF OpenVRTrackedObject::getTrackedTransform() { - IDevicePose pose = OPENVR->getTrackedDevicePose(mDeviceIndex); - MatrixF trackedMat(1); + IDevicePose pose = OPENVR->getTrackedDevicePose(mDeviceIndex); + MatrixF trackedMat(1); - pose.orientation.setMatrix(&trackedMat); - trackedMat.setPosition(pose.position); + pose.orientation.setMatrix(&trackedMat); + trackedMat.setPosition(pose.position); - return trackedMat; + return trackedMat; } MatrixF OpenVRTrackedObject::getLastTrackedTransform() { - MatrixF trackedMat(1); + MatrixF trackedMat(1); - mPose.orientation.setMatrix(&trackedMat); - trackedMat.setPosition(mPose.position); + mPose.orientation.setMatrix(&trackedMat); + trackedMat.setPosition(mPose.position); - return trackedMat; + return trackedMat; } MatrixF OpenVRTrackedObject::getBaseTrackingTransform() { - if (isMounted()) - { - MatrixF mat; + if (isMounted()) + { + MatrixF mat; - mMount.object->getMountTransform(mMount.node, mMount.xfm, &mat); - if (mIgnoreParentRotation) - { - Point3F pos = mat.getPosition(); - mat = MatrixF(1); - mat.setPosition(pos); - } - //mat.inverse(); - return mat; - } + mMount.object->getMountTransform(mMount.node, mMount.xfm, &mat); + if (mIgnoreParentRotation) + { + Point3F pos = mat.getPosition(); + mat = MatrixF(1); + mat.setPosition(pos); + } + //mat.inverse(); + return mat; + } - return MatrixF(1); + return MatrixF(1); } void OpenVRTrackedObject::prepRenderImage(SceneRenderState *state) { - RenderPassManager *renderPass = state->getRenderPass(); + RenderPassManager *renderPass = state->getRenderPass(); - // debug rendering for now + // debug rendering for now - if (mDeviceIndex < 0) - return; + if (mDeviceIndex < 0) + return; - // Current pose - IDevicePose pose = OPENVR->getTrackedDevicePose(mDeviceIndex); - IDevicePose hmdPose = OPENVR->getTrackedDevicePose(0); + // Current pose + IDevicePose pose = OPENVR->getTrackedDevicePose(mDeviceIndex); + IDevicePose hmdPose = OPENVR->getTrackedDevicePose(0); - if (!pose.connected && !mPose.connected) - return; + if (!pose.connected && !mPose.connected) + return; - MatrixF offsetMat = getBaseTrackingTransform(); - //offsetMat.inverse(); + MatrixF offsetMat = getBaseTrackingTransform(); + //offsetMat.inverse(); - Point3F pos = offsetMat.getPosition(); - //Con::printf("Base offs == %f,%f,%f", pos.x, pos.y, pos.z); + Point3F pos = offsetMat.getPosition(); + //Con::printf("Base offs == %f,%f,%f", pos.x, pos.y, pos.z); - const F32 CONTROLLER_SCALE = 0.1; + const F32 CONTROLLER_SCALE = 0.1; - if (smDebugControllerPosition) - { - ColorI drawColor = ColorI::GREEN; - if (!pose.valid) - { - drawColor = ColorI::RED; - } + if (smDebugControllerPosition) + { + ColorI drawColor = ColorI::GREEN; + if (!pose.valid) + { + drawColor = ColorI::RED; + } - // Draw Camera - /* - DisplayPose cameraPose; - OPENVR->getFrameEyePose(&cameraPose, -1); - Point3F cameraCenter(0); - MatrixF cameraMat(1); - cameraPose.orientation.setMatrix(&cameraMat); - cameraMat.setPosition(cameraPose.position); - cameraMat.mulP(cameraCenter); - //DebugDrawer::get()->drawBox(cameraCenter - Point3F(0.1), cameraCenter + Point3F(0.1), ColorI::GREEN); - - DebugDrawer::get()->drawTransformedBoxOutline(Point3F(-0.5, -0.1, -0.5), Point3F(0.5, 0.1, 0.5), ColorI::WHITE, cameraMat); // general box - */ + // Draw Camera + /* + DisplayPose cameraPose; + OPENVR->getFrameEyePose(&cameraPose, -1); + Point3F cameraCenter(0); + MatrixF cameraMat(1); + cameraPose.orientation.setMatrix(&cameraMat); + cameraMat.setPosition(cameraPose.position); + cameraMat.mulP(cameraCenter); + //DebugDrawer::get()->drawBox(cameraCenter - Point3F(0.1), cameraCenter + Point3F(0.1), ColorI::GREEN); + + DebugDrawer::get()->drawTransformedBoxOutline(Point3F(-0.5, -0.1, -0.5), Point3F(0.5, 0.1, 0.5), ColorI::WHITE, cameraMat); // general box + */ - // Draw Tracked HMD Pos - Point3F hmdCenter(0, 0, 0); - MatrixF hmdMat(1); - hmdPose.orientation.setMatrix(&hmdMat); - hmdMat.setPosition(hmdPose.position); - hmdMat.inverse(); // -> world mat (as opposed to world -> tracked pos) - hmdMat = offsetMat * hmdMat; - hmdMat.mulP(hmdCenter); - DebugDrawer::get()->drawBox(hmdCenter - Point3F(0.1), hmdCenter + Point3F(0.1), ColorI::RED); - DebugDrawer::get()->drawTransformedBoxOutline(Point3F(-0.5, -0.1, -0.5), Point3F(0.5, 0.1, 0.5), ColorI::GREEN, hmdMat); // general box + // Draw Tracked HMD Pos + Point3F hmdCenter(0, 0, 0); + MatrixF hmdMat(1); + hmdPose.orientation.setMatrix(&hmdMat); + hmdMat.setPosition(hmdPose.position); + hmdMat.inverse(); // -> world mat (as opposed to world -> tracked pos) + hmdMat = offsetMat * hmdMat; + hmdMat.mulP(hmdCenter); + DebugDrawer::get()->drawBox(hmdCenter - Point3F(0.1), hmdCenter + Point3F(0.1), ColorI::RED); + DebugDrawer::get()->drawTransformedBoxOutline(Point3F(-0.5, -0.1, -0.5), Point3F(0.5, 0.1, 0.5), ColorI::GREEN, hmdMat); // general box - // Draw Controller - MatrixF mat(1); - pose.orientation.setMatrix(&mat); - mat.setPosition(pose.position); - mat.inverse(); // same as HMD - mat = offsetMat * mat; + // Draw Controller + MatrixF mat(1); + pose.orientation.setMatrix(&mat); + mat.setPosition(pose.position); + mat.inverse(); // same as HMD + mat = offsetMat * mat; - Point3F middleStart(0, -1 * CONTROLLER_SCALE, 0); - Point3F middleEnd(0, 1 * CONTROLLER_SCALE, 0); - Point3F middle(0, 0, 0); + Point3F middleStart(0, -1 * CONTROLLER_SCALE, 0); + Point3F middleEnd(0, 1 * CONTROLLER_SCALE, 0); + Point3F middle(0, 0, 0); - Point3F center(0, 0, 0); - mat.mulP(center); + Point3F center(0, 0, 0); + mat.mulP(center); - //DebugDrawer::get()->drawBox(center - Point3F(0.1), center + Point3F(0.1), ColorI::BLUE); + //DebugDrawer::get()->drawBox(center - Point3F(0.1), center + Point3F(0.1), ColorI::BLUE); - mat.mulP(middleStart); - mat.mulP(middle); - mat.mulP(middleEnd); + mat.mulP(middleStart); + mat.mulP(middle); + mat.mulP(middleEnd); - char buffer[256]; - dSprintf(buffer, 256, "%f %f %f", center.x, center.y, center.z); - DebugDrawer::get()->drawText(middle, buffer); - DebugDrawer::get()->drawLine(middleStart, middle, ColorI(0, 255, 0)); // axis back - DebugDrawer::get()->drawLine(middleEnd, middle, ColorI(255, 0, 0)); // axis forward - DebugDrawer::get()->drawTransformedBoxOutline(Point3F(-0.5, -1, -0.5) * CONTROLLER_SCALE, Point3F(0.5, 1, 0.5) * CONTROLLER_SCALE, drawColor, mat); // general box - DebugDrawer::get()->drawBoxOutline(Point3F(-1), Point3F(1), ColorI::WHITE); - } + char buffer[256]; + dSprintf(buffer, 256, "%f %f %f", center.x, center.y, center.z); + DebugDrawer::get()->drawText(middle, buffer); + DebugDrawer::get()->drawLine(middleStart, middle, ColorI(0, 255, 0)); // axis back + DebugDrawer::get()->drawLine(middleEnd, middle, ColorI(255, 0, 0)); // axis forward + DebugDrawer::get()->drawTransformedBoxOutline(Point3F(-0.5, -1, -0.5) * CONTROLLER_SCALE, Point3F(0.5, 1, 0.5) * CONTROLLER_SCALE, drawColor, mat); // general box + DebugDrawer::get()->drawBoxOutline(Point3F(-1), Point3F(1), ColorI::WHITE); + } - if (isClientObject() && smDebugControllerMovePosition) - { - MatrixF transform = getRenderTransform(); - transform.scale(mObjScale); - DebugDrawer::get()->drawTransformedBoxOutline(mObjBox.minExtents, mObjBox.maxExtents, ColorI::RED, transform); - - // jamesu - grab server object pose for debugging - OpenVRTrackedObject* tracked = static_cast(getServerObject()); - if (tracked) - { - mPose = tracked->mPose; - } + if (isClientObject() && smDebugControllerMovePosition) + { + MatrixF transform = getRenderTransform(); + transform.scale(mObjScale); + DebugDrawer::get()->drawTransformedBoxOutline(mObjBox.minExtents, mObjBox.maxExtents, ColorI::RED, transform); + + // jamesu - grab server object pose for debugging + OpenVRTrackedObject* tracked = static_cast(getServerObject()); + if (tracked) + { + mPose = tracked->mPose; + } - ColorI drawColor = ColorI::GREEN; - if (!pose.valid) - { - drawColor = ColorI::RED; - } - // Draw Controller - MatrixF mat(1); - mPose.orientation.setMatrix(&mat); - mat.setPosition(mPose.position); - mat.inverse(); // same as HMD - mat = offsetMat * mat; + ColorI drawColor = ColorI::GREEN; + if (!pose.valid) + { + drawColor = ColorI::RED; + } + // Draw Controller + MatrixF mat(1); + mPose.orientation.setMatrix(&mat); + mat.setPosition(mPose.position); + mat.inverse(); // same as HMD + mat = offsetMat * mat; - Point3F middleStart(0, -1 * CONTROLLER_SCALE, 0); - Point3F middleEnd(0, 1 * CONTROLLER_SCALE, 0); - Point3F middle(0, 0, 0); + Point3F middleStart(0, -1 * CONTROLLER_SCALE, 0); + Point3F middleEnd(0, 1 * CONTROLLER_SCALE, 0); + Point3F middle(0, 0, 0); - Point3F center(0, 0, 0); - mat.mulP(center); + Point3F center(0, 0, 0); + mat.mulP(center); - //DebugDrawer::get()->drawBox(center - Point3F(0.1), center + Point3F(0.1), ColorI::BLUE); + //DebugDrawer::get()->drawBox(center - Point3F(0.1), center + Point3F(0.1), ColorI::BLUE); - mat.mulP(middleStart); - mat.mulP(middle); - mat.mulP(middleEnd); + mat.mulP(middleStart); + mat.mulP(middle); + mat.mulP(middleEnd); - char buffer[256]; - dSprintf(buffer, 256, "%f %f %f", center.x, center.y, center.z); - DebugDrawer::get()->drawText(middle, buffer); - DebugDrawer::get()->drawLine(middleStart, middle, ColorI(0, 255, 0)); // axis back - DebugDrawer::get()->drawLine(middleEnd, middle, ColorI(255, 0, 0)); // axis forward - DebugDrawer::get()->drawTransformedBoxOutline(Point3F(-0.5, -1, -0.5) * CONTROLLER_SCALE, Point3F(0.5, 1, 0.5) * CONTROLLER_SCALE, drawColor, mat); // general box - DebugDrawer::get()->drawBoxOutline(Point3F(-1), Point3F(1), ColorI::WHITE); - } + char buffer[256]; + dSprintf(buffer, 256, "%f %f %f", center.x, center.y, center.z); + DebugDrawer::get()->drawText(middle, buffer); + DebugDrawer::get()->drawLine(middleStart, middle, ColorI(0, 255, 0)); // axis back + DebugDrawer::get()->drawLine(middleEnd, middle, ColorI(255, 0, 0)); // axis forward + DebugDrawer::get()->drawTransformedBoxOutline(Point3F(-0.5, -1, -0.5) * CONTROLLER_SCALE, Point3F(0.5, 1, 0.5) * CONTROLLER_SCALE, drawColor, mat); // general box + DebugDrawer::get()->drawBoxOutline(Point3F(-1), Point3F(1), ColorI::WHITE); + } - // Controller matrix base - MatrixF trackedMat = getTrackedTransform(); - MatrixF invTrackedMat(1); + // Controller matrix base + MatrixF trackedMat = getTrackedTransform(); + MatrixF invTrackedMat(1); - invTrackedMat = trackedMat; - invTrackedMat.inverse(); // -> world mat (as opposed to world -> tracked pos) + invTrackedMat = trackedMat; + invTrackedMat.inverse(); // -> world mat (as opposed to world -> tracked pos) - invTrackedMat = getBaseTrackingTransform() * invTrackedMat; - trackedMat = invTrackedMat; - trackedMat.inverse(); + invTrackedMat = getBaseTrackingTransform() * invTrackedMat; + trackedMat = invTrackedMat; + trackedMat.inverse(); - // Render the controllers, using either the render model or the shape - if (mShapeInstance) - { - // Calculate the distance of this object from the camera - Point3F cameraOffset = invTrackedMat.getPosition(); - cameraOffset -= state->getDiffuseCameraPosition(); - F32 dist = cameraOffset.len(); - if (dist < 0.01f) - dist = 0.01f; + // Render the controllers, using either the render model or the shape + if (mShapeInstance) + { + // Calculate the distance of this object from the camera + Point3F cameraOffset = invTrackedMat.getPosition(); + cameraOffset -= state->getDiffuseCameraPosition(); + F32 dist = cameraOffset.len(); + if (dist < 0.01f) + dist = 0.01f; - // Set up the LOD for the shape - F32 invScale = (1.0f / getMax(getMax(mObjScale.x, mObjScale.y), mObjScale.z)); + // Set up the LOD for the shape + F32 invScale = (1.0f / getMax(getMax(mObjScale.x, mObjScale.y), mObjScale.z)); - mShapeInstance->setDetailFromDistance(state, dist * invScale); + mShapeInstance->setDetailFromDistance(state, dist * invScale); - // Make sure we have a valid level of detail - if (mShapeInstance->getCurrentDetail() < 0) - return; + // Make sure we have a valid level of detail + if (mShapeInstance->getCurrentDetail() < 0) + return; - // GFXTransformSaver is a handy helper class that restores - // the current GFX matrices to their original values when - // it goes out of scope at the end of the function - GFXTransformSaver saver; + // GFXTransformSaver is a handy helper class that restores + // the current GFX matrices to their original values when + // it goes out of scope at the end of the function + GFXTransformSaver saver; - // Set up our TS render state - TSRenderState rdata; - rdata.setSceneState(state); - rdata.setFadeOverride(1.0f); + // Set up our TS render state + TSRenderState rdata; + rdata.setSceneState(state); + rdata.setFadeOverride(1.0f); - // We might have some forward lit materials - // so pass down a query to gather lights. - LightQuery query; - query.init(getWorldSphere()); - rdata.setLightQuery(&query); + // We might have some forward lit materials + // so pass down a query to gather lights. + LightQuery query; + query.init(getWorldSphere()); + rdata.setLightQuery(&query); - // Set the world matrix to the objects render transform - MatrixF mat = trackedMat; + // Set the world matrix to the objects render transform + MatrixF mat = trackedMat; - mat.scale(mObjScale); - GFX->setWorldMatrix(mat); + mat.scale(mObjScale); + GFX->setWorldMatrix(mat); - // TODO: move the nodes about for components + // TODO: move the nodes about for components - mShapeInstance->animate(); - mShapeInstance->render(rdata); - } - else if (mRenderComponents.size() > 0) - { - vr::IVRRenderModels *models = OPENVR->getRenderModels(); - if (!models) - return; + mShapeInstance->animate(); + mShapeInstance->render(rdata); + } + else if (mRenderComponents.size() > 0) + { + vr::IVRRenderModels *models = OPENVR->getRenderModels(); + if (!models) + return; - vr::IVRSystem* vrs = vr::VRSystem(); + vr::IVRSystem* vrs = vr::VRSystem(); - if (!vrs->GetControllerState(mDeviceIndex, &mCurrentControllerState)) - { - return; - } + if (!vrs->GetControllerState(mDeviceIndex, &mCurrentControllerState)) + { + return; + } - for (U32 i = 0, sz = mRenderComponents.size(); i < sz; i++) - { - RenderModelSlot slot = mRenderComponents[i]; - vr::RenderModel_ControllerMode_State_t modeState; - vr::RenderModel_ComponentState_t componentState; + for (U32 i = 0, sz = mRenderComponents.size(); i < sz; i++) + { + RenderModelSlot slot = mRenderComponents[i]; + vr::RenderModel_ControllerMode_State_t modeState; + vr::RenderModel_ComponentState_t componentState; - modeState.bScrollWheelVisible = false; + modeState.bScrollWheelVisible = false; - if (models->GetComponentState(mModelName, slot.componentName, &mCurrentControllerState, &modeState, &componentState)) - { - MeshRenderInst *ri = renderPass->allocInst(); + if (models->GetComponentState(mModelName, slot.componentName, &mCurrentControllerState, &modeState, &componentState)) + { + MeshRenderInst *ri = renderPass->allocInst(); - // Set our RenderInst as a standard mesh render - ri->type = RenderPassManager::RIT_Mesh; + // Set our RenderInst as a standard mesh render + ri->type = RenderPassManager::RIT_Mesh; - // Calculate our sorting point - if (state && slot.nativeModel) - { - // Calculate our sort point manually. - const Box3F rBox = slot.nativeModel->getWorldBox(invTrackedMat); - ri->sortDistSq = rBox.getSqDistanceToPoint(state->getCameraPosition()); - } - else - { - ri->sortDistSq = 0.0f; - } + // Calculate our sorting point + if (state && slot.nativeModel) + { + // Calculate our sort point manually. + const Box3F rBox = slot.nativeModel->getWorldBox(invTrackedMat); + ri->sortDistSq = rBox.getSqDistanceToPoint(state->getCameraPosition()); + } + else + { + ri->sortDistSq = 0.0f; + } - MatrixF newTransform = trackedMat; - MatrixF controllerOffsMat = OpenVRUtil::convertSteamVRAffineMatrixToMatrixFPlain(componentState.mTrackingToComponentRenderModel); - MatrixF offComponentMat(1); - OpenVRUtil::convertTransformFromOVR(controllerOffsMat, offComponentMat); + MatrixF newTransform = trackedMat; + MatrixF controllerOffsMat = OpenVRUtil::convertSteamVRAffineMatrixToMatrixFPlain(componentState.mTrackingToComponentRenderModel); + MatrixF offComponentMat(1); + OpenVRUtil::convertTransformFromOVR(controllerOffsMat, offComponentMat); - newTransform = offComponentMat * newTransform; + newTransform = offComponentMat * newTransform; - newTransform.inverse(); + newTransform.inverse(); - //DebugDrawer::get()->drawBox(newTransform.getPosition() - Point3F(0.001), newTransform.getPosition() + Point3F(0.001), ColorI::BLUE); + //DebugDrawer::get()->drawBox(newTransform.getPosition() - Point3F(0.001), newTransform.getPosition() + Point3F(0.001), ColorI::BLUE); - if (!slot.nativeModel) - continue; - if (i < 1) - continue; + if (!slot.nativeModel) + continue; + if (i < 1) + continue; - // Set up our transforms - ri->objectToWorld = renderPass->allocUniqueXform(newTransform); - ri->worldToCamera = renderPass->allocSharedXform(RenderPassManager::View); - ri->projection = renderPass->allocSharedXform(RenderPassManager::Projection); + // Set up our transforms + ri->objectToWorld = renderPass->allocUniqueXform(newTransform); + ri->worldToCamera = renderPass->allocSharedXform(RenderPassManager::View); + ri->projection = renderPass->allocSharedXform(RenderPassManager::Projection); - // If our material needs lights then fill the RIs - // light vector with the best lights. - if (true) - { - LightQuery query; - Point3F center(0, 0, 0); - invTrackedMat.mulP(center); - query.init(SphereF(center, 10.0f)); - query.getLights(ri->lights, 8); - } + // If our material needs lights then fill the RIs + // light vector with the best lights. + if (true) + { + LightQuery query; + Point3F center(0, 0, 0); + invTrackedMat.mulP(center); + query.init(SphereF(center, 10.0f)); + query.getLights(ri->lights, 8); + } - // Draw model - slot.nativeModel->draw(state, ri); - state->getRenderPass()->addInst(ri); - } - } - } - else if (mBasicModel) - { - MeshRenderInst *ri = renderPass->allocInst(); + // Draw model + slot.nativeModel->draw(state, ri); + state->getRenderPass()->addInst(ri); + } + } + } + else if (mBasicModel) + { + MeshRenderInst *ri = renderPass->allocInst(); - // Set our RenderInst as a standard mesh render - ri->type = RenderPassManager::RIT_Mesh; + // Set our RenderInst as a standard mesh render + ri->type = RenderPassManager::RIT_Mesh; - // Calculate our sorting point - if (state) - { - // Calculate our sort point manually. - const Box3F rBox = mBasicModel->getWorldBox(invTrackedMat); - ri->sortDistSq = rBox.getSqDistanceToPoint(state->getCameraPosition()); - } - else - { - ri->sortDistSq = 0.0f; - } + // Calculate our sorting point + if (state) + { + // Calculate our sort point manually. + const Box3F rBox = mBasicModel->getWorldBox(invTrackedMat); + ri->sortDistSq = rBox.getSqDistanceToPoint(state->getCameraPosition()); + } + else + { + ri->sortDistSq = 0.0f; + } - MatrixF newTransform = invTrackedMat; - // Set up our transforms - ri->objectToWorld = renderPass->allocUniqueXform(newTransform); - ri->worldToCamera = renderPass->allocSharedXform(RenderPassManager::View); - ri->projection = renderPass->allocSharedXform(RenderPassManager::Projection); + MatrixF newTransform = invTrackedMat; + // Set up our transforms + ri->objectToWorld = renderPass->allocUniqueXform(newTransform); + ri->worldToCamera = renderPass->allocSharedXform(RenderPassManager::View); + ri->projection = renderPass->allocSharedXform(RenderPassManager::Projection); - // If our material needs lights then fill the RIs - // light vector with the best lights. - if (true) - { - LightQuery query; - Point3F center(0, 0, 0); - invTrackedMat.mulP(center); - query.init(SphereF(center, 10.0f)); - query.getLights(ri->lights, 8); - } + // If our material needs lights then fill the RIs + // light vector with the best lights. + if (true) + { + LightQuery query; + Point3F center(0, 0, 0); + invTrackedMat.mulP(center); + query.init(SphereF(center, 10.0f)); + query.getLights(ri->lights, 8); + } - // Draw model - mBasicModel->draw(state, ri); - state->getRenderPass()->addInst(ri); - } + // Draw model + mBasicModel->draw(state, ri); + state->getRenderPass()->addInst(ri); + } } U32 OpenVRTrackedObject::getCollisionMask() { - if (isServerObject()) - return sServerCollisionMask; - else - return sClientCollisionMask; + if (isServerObject()) + return sServerCollisionMask; + else + return sClientCollisionMask; } void OpenVRTrackedObject::updateWorkingCollisionSet() { - const U32 mask = getCollisionMask(); - Box3F convexBox = mConvexList->getBoundingBox(getTransform(), getScale()); - F32 len = (50) * TickSec; - F32 l = (len * 1.1) + 0.1; // fudge factor - convexBox.minExtents -= Point3F(l, l, l); - convexBox.maxExtents += Point3F(l, l, l); + const U32 mask = getCollisionMask(); + Box3F convexBox = mConvexList->getBoundingBox(getTransform(), getScale()); + F32 len = (50) * TickSec; + F32 l = (len * 1.1) + 0.1; // fudge factor + convexBox.minExtents -= Point3F(l, l, l); + convexBox.maxExtents += Point3F(l, l, l); - disableCollision(); - mConvexList->updateWorkingList(convexBox, mask); - enableCollision(); + disableCollision(); + mConvexList->updateWorkingList(convexBox, mask); + enableCollision(); } void OpenVRTrackedObject::updateMove(const Move *move) { - // Set transform based on move + // Set transform based on move #ifdef TORQUE_EXTENDED_MOVE - const ExtendedMove* emove = dynamic_cast(move); - if (!emove) - return; + const ExtendedMove* emove = dynamic_cast(move); + if (!emove) + return; - U32 emoveIndex = mMappedMoveIndex; - if (emoveIndex >= ExtendedMove::MaxPositionsRotations) - emoveIndex = 0; + U32 emoveIndex = mMappedMoveIndex; + if (emoveIndex >= ExtendedMove::MaxPositionsRotations) + emoveIndex = 0; - //IDevicePose pose = OPENVR->getTrackedDevicePose(mDeviceIndex); - //Con::printf("OpenVRTrackedObject::processTick move %i", emoveIndex); + //IDevicePose pose = OPENVR->getTrackedDevicePose(mDeviceIndex); + //Con::printf("OpenVRTrackedObject::processTick move %i", emoveIndex); - if (!emove->EulerBasedRotation[emoveIndex]) - { - AngAxisF inRot = AngAxisF(Point3F(emove->rotX[emoveIndex], emove->rotY[emoveIndex], emove->rotZ[emoveIndex]), emove->rotW[emoveIndex]); - // Update our pose based on the move info - mPose.orientation = inRot; - mPose.position = Point3F(emove->posX[emoveIndex], emove->posY[emoveIndex], emove->posZ[emoveIndex]); - mPose.valid = true; - mPose.connected = true; - } + if (!emove->EulerBasedRotation[emoveIndex]) + { + AngAxisF inRot = AngAxisF(Point3F(emove->rotX[emoveIndex], emove->rotY[emoveIndex], emove->rotZ[emoveIndex]), emove->rotW[emoveIndex]); + // Update our pose based on the move info + mPose.orientation = inRot; + mPose.position = Point3F(emove->posX[emoveIndex], emove->posY[emoveIndex], emove->posZ[emoveIndex]); + mPose.valid = true; + mPose.connected = true; + } - // Set transform based on move pose - MatrixF trackedMat(1); - MatrixF invTrackedMat(1); + // Set transform based on move pose + MatrixF trackedMat(1); + MatrixF invTrackedMat(1); - mPose.orientation.setMatrix(&trackedMat); - trackedMat.setPosition(mPose.position); + mPose.orientation.setMatrix(&trackedMat); + trackedMat.setPosition(mPose.position); - invTrackedMat = trackedMat; - invTrackedMat.inverse(); // -> world mat (as opposed to world -> tracked pos) + invTrackedMat = trackedMat; + invTrackedMat.inverse(); // -> world mat (as opposed to world -> tracked pos) - invTrackedMat = getBaseTrackingTransform() * invTrackedMat; - trackedMat = invTrackedMat; - trackedMat.inverse(); + invTrackedMat = getBaseTrackingTransform() * invTrackedMat; + trackedMat = invTrackedMat; + trackedMat.inverse(); - SceneObject::setTransform(invTrackedMat); + SceneObject::setTransform(invTrackedMat); - if (mPhysicsRep) - mPhysicsRep->setTransform(invTrackedMat); + if (mPhysicsRep) + mPhysicsRep->setTransform(invTrackedMat); #endif } void OpenVRTrackedObject::processTick(const Move *move) { - // Perform collision checks - if (isServerObject()) - { - updateMove(move); + // Perform collision checks + if (isServerObject()) + { + updateMove(move); - if (!mPhysicsRep) - { - updateWorkingCollisionSet(); - } - } + if (!mPhysicsRep) + { + updateWorkingCollisionSet(); + } + } - Parent::processTick(move); + Parent::processTick(move); } void OpenVRTrackedObject::interpolateTick(F32 delta) { - // Set latest transform + // Set latest transform - Parent::interpolateTick(delta); + Parent::interpolateTick(delta); } void OpenVRTrackedObject::advanceTime(F32 dt) { - Parent::advanceTime(dt); + Parent::advanceTime(dt); } bool OpenVRTrackedObject::castRay(const Point3F &start, const Point3F &end, RayInfo* info) { - if (!mPose.connected || !mPose.valid) - return false; + if (!mPose.connected || !mPose.valid) + return false; - // Collide against bounding box. - F32 st, et, fst = 0.0f, fet = 1.0f; - F32 *bmin = &mObjBox.minExtents.x; - F32 *bmax = &mObjBox.maxExtents.x; - F32 const *si = &start.x; - F32 const *ei = &end.x; + // Collide against bounding box. + F32 st, et, fst = 0.0f, fet = 1.0f; + F32 *bmin = &mObjBox.minExtents.x; + F32 *bmax = &mObjBox.maxExtents.x; + F32 const *si = &start.x; + F32 const *ei = &end.x; - for (S32 i = 0; i < 3; i++) { - if (*si < *ei) { - if (*si > *bmax || *ei < *bmin) - return false; - F32 di = *ei - *si; - st = (*si < *bmin) ? (*bmin - *si) / di : 0.0f; - et = (*ei > *bmax) ? (*bmax - *si) / di : 1.0f; - } - else { - if (*ei > *bmax || *si < *bmin) - return false; - F32 di = *ei - *si; - st = (*si > *bmax) ? (*bmax - *si) / di : 0.0f; - et = (*ei < *bmin) ? (*bmin - *si) / di : 1.0f; - } - if (st > fst) fst = st; - if (et < fet) fet = et; - if (fet < fst) - return false; - bmin++; bmax++; - si++; ei++; - } + for (S32 i = 0; i < 3; i++) { + if (*si < *ei) { + if (*si > *bmax || *ei < *bmin) + return false; + F32 di = *ei - *si; + st = (*si < *bmin) ? (*bmin - *si) / di : 0.0f; + et = (*ei > *bmax) ? (*bmax - *si) / di : 1.0f; + } + else { + if (*ei > *bmax || *si < *bmin) + return false; + F32 di = *ei - *si; + st = (*si > *bmax) ? (*bmax - *si) / di : 0.0f; + et = (*ei < *bmin) ? (*bmin - *si) / di : 1.0f; + } + if (st > fst) fst = st; + if (et < fet) fet = et; + if (fet < fst) + return false; + bmin++; bmax++; + si++; ei++; + } - info->normal = start - end; - info->normal.normalizeSafe(); - getTransform().mulV(info->normal); + info->normal = start - end; + info->normal.normalizeSafe(); + getTransform().mulV(info->normal); - info->t = fst; - info->object = this; - info->point.interpolate(start, end, fst); - info->material = 0; - return true; + info->t = fst; + info->object = this; + info->point.interpolate(start, end, fst); + info->material = 0; + return true; } void OpenVRTrackedObject::buildConvex(const Box3F& box, Convex* convex) { - // These should really come out of a pool - mConvexList->collectGarbage(); + // These should really come out of a pool + mConvexList->collectGarbage(); - Box3F realBox = box; - mWorldToObj.mul(realBox); - realBox.minExtents.convolveInverse(mObjScale); - realBox.maxExtents.convolveInverse(mObjScale); + Box3F realBox = box; + mWorldToObj.mul(realBox); + realBox.minExtents.convolveInverse(mObjScale); + realBox.maxExtents.convolveInverse(mObjScale); - if (realBox.isOverlapped(getObjBox()) == false) - return; + if (realBox.isOverlapped(getObjBox()) == false) + return; - // Just return a box convex for the entire shape... - Convex* cc = 0; - CollisionWorkingList& wl = convex->getWorkingList(); - for (CollisionWorkingList* itr = wl.wLink.mNext; itr != &wl; itr = itr->wLink.mNext) { - if (itr->mConvex->getType() == BoxConvexType && - itr->mConvex->getObject() == this) { - cc = itr->mConvex; - break; - } - } - if (cc) - return; + // Just return a box convex for the entire shape... + Convex* cc = 0; + CollisionWorkingList& wl = convex->getWorkingList(); + for (CollisionWorkingList* itr = wl.wLink.mNext; itr != &wl; itr = itr->wLink.mNext) { + if (itr->mConvex->getType() == BoxConvexType && + itr->mConvex->getObject() == this) { + cc = itr->mConvex; + break; + } + } + if (cc) + return; - // Create a new convex. - BoxConvex* cp = new BoxConvex; - mConvexList->registerObject(cp); - convex->addToWorkingList(cp); - cp->init(this); + // Create a new convex. + BoxConvex* cp = new BoxConvex; + mConvexList->registerObject(cp); + convex->addToWorkingList(cp); + cp->init(this); - mObjBox.getCenter(&cp->mCenter); - cp->mSize.x = mObjBox.len_x() / 2.0f; - cp->mSize.y = mObjBox.len_y() / 2.0f; - cp->mSize.z = mObjBox.len_z() / 2.0f; + mObjBox.getCenter(&cp->mCenter); + cp->mSize.x = mObjBox.len_x() / 2.0f; + cp->mSize.y = mObjBox.len_y() / 2.0f; + cp->mSize.z = mObjBox.len_z() / 2.0f; } bool OpenVRTrackedObject::testObject(SceneObject* enter) { - return false; // TODO + return false; // TODO } DefineEngineMethod(OpenVRTrackedObject, setModelName, void, (String modelName),, "Set model name. Typically you should do this from the client to update the server representation.") { - object->setModelName(modelName); + object->setModelName(modelName); } diff --git a/Engine/source/platform/input/openVR/openVRTrackedObject.h b/Engine/source/platform/input/openVR/openVRTrackedObject.h index 572649a8b..eb2feb87c 100644 --- a/Engine/source/platform/input/openVR/openVRTrackedObject.h +++ b/Engine/source/platform/input/openVR/openVRTrackedObject.h @@ -23,132 +23,132 @@ class PhysicsBody; class OpenVRTrackedObjectData : public GameBaseData { public: - typedef GameBaseData Parent; + typedef GameBaseData Parent; - StringTableEntry mShapeFile; - Resource mShape; ///< Torque model + StringTableEntry mShapeFile; + Resource mShape; ///< Torque model - Point3F mCollisionBoxMin; - Point3F mCollisionBoxMax; + Point3F mCollisionBoxMin; + Point3F mCollisionBoxMax; public: - OpenVRTrackedObjectData(); - ~OpenVRTrackedObjectData(); + OpenVRTrackedObjectData(); + ~OpenVRTrackedObjectData(); - DECLARE_CONOBJECT(OpenVRTrackedObjectData); + DECLARE_CONOBJECT(OpenVRTrackedObjectData); - bool onAdd(); - bool preload(bool server, String &errorStr); + bool onAdd(); + bool preload(bool server, String &errorStr); - static void initPersistFields(); + static void initPersistFields(); - virtual void packData(BitStream* stream); - virtual void unpackData(BitStream* stream); + virtual void packData(BitStream* stream); + virtual void unpackData(BitStream* stream); }; /// Implements a GameObject which tracks an OpenVR controller class OpenVRTrackedObject : public GameBase { - typedef GameBase Parent; + typedef GameBase Parent; - enum MaskBits - { - UpdateMask = Parent::NextFreeMask << 0, - NextFreeMask = Parent::NextFreeMask << 1 - }; + enum MaskBits + { + UpdateMask = Parent::NextFreeMask << 0, + NextFreeMask = Parent::NextFreeMask << 1 + }; - struct RenderModelSlot - { - StringTableEntry componentName; ///< Component name - S16 mappedNodeIdx; ///< Mapped node idx in mShape - OpenVRRenderModel *nativeModel; ///< Native model - }; + struct RenderModelSlot + { + StringTableEntry componentName; ///< Component name + S16 mappedNodeIdx; ///< Mapped node idx in mShape + OpenVRRenderModel *nativeModel; ///< Native model + }; - OpenVRTrackedObjectData *mDataBlock; + OpenVRTrackedObjectData *mDataBlock; - /// @name Rendering - /// { - TSShapeInstance *mShapeInstance; ///< Shape used to render controller (uses native model otherwise) - StringTableEntry mModelName; - OpenVRRenderModel *mBasicModel; ///< Basic model - Vector mRenderComponents; - /// } + /// @name Rendering + /// { + TSShapeInstance *mShapeInstance; ///< Shape used to render controller (uses native model otherwise) + StringTableEntry mModelName; + OpenVRRenderModel *mBasicModel; ///< Basic model + Vector mRenderComponents; + /// } - S32 mDeviceIndex; ///< Controller idx in openvr (for direct updating) - S32 mMappedMoveIndex; ///< Movemanager move index for rotation + S32 mDeviceIndex; ///< Controller idx in openvr (for direct updating) + S32 mMappedMoveIndex; ///< Movemanager move index for rotation - vr::VRControllerState_t mCurrentControllerState; - vr::VRControllerState_t mPreviousControllerState; + vr::VRControllerState_t mCurrentControllerState; + vr::VRControllerState_t mPreviousControllerState; - IDevicePose mPose; ///< Current openvr pose data, or reconstructed data from the client + IDevicePose mPose; ///< Current openvr pose data, or reconstructed data from the client - Convex* mConvexList; - EarlyOutPolyList mClippedList; - PhysicsBody *mPhysicsRep; + Convex* mConvexList; + EarlyOutPolyList mClippedList; + PhysicsBody *mPhysicsRep; - SimObjectPtr mCollisionObject; ///< Object we're currently colliding with - SimObjectPtr mInteractObject; ///< Object we've designated as important to interact with + SimObjectPtr mCollisionObject; ///< Object we're currently colliding with + SimObjectPtr mInteractObject; ///< Object we've designated as important to interact with - bool mHoldInteractedObject; ///< Performs pickup logic with mInteractObject - bool mIgnoreParentRotation; ///< Ignores the rotation of the parent object + bool mHoldInteractedObject; ///< Performs pickup logic with mInteractObject + bool mIgnoreParentRotation; ///< Ignores the rotation of the parent object - static bool smDebugControllerPosition; ///< Shows latest controller position in DebugDrawer - static bool smDebugControllerMovePosition; ///< Shows move position in DebugDrawer - static U32 sServerCollisionMask; - static U32 sClientCollisionMask; + static bool smDebugControllerPosition; ///< Shows latest controller position in DebugDrawer + static bool smDebugControllerMovePosition; ///< Shows move position in DebugDrawer + static U32 sServerCollisionMask; + static U32 sClientCollisionMask; public: - OpenVRTrackedObject(); - virtual ~OpenVRTrackedObject(); + OpenVRTrackedObject(); + virtual ~OpenVRTrackedObject(); - void updateRenderData(); - void setupRenderDataFromModel(bool loadComponentModels); + void updateRenderData(); + void setupRenderDataFromModel(bool loadComponentModels); - void clearRenderData(); + void clearRenderData(); - DECLARE_CONOBJECT(OpenVRTrackedObject); + DECLARE_CONOBJECT(OpenVRTrackedObject); - static void initPersistFields(); + static void initPersistFields(); - virtual void inspectPostApply(); + virtual void inspectPostApply(); - bool onAdd(); - void onRemove(); + bool onAdd(); + void onRemove(); - void _updatePhysics(); - bool onNewDataBlock(GameBaseData *dptr, bool reload); + void _updatePhysics(); + bool onNewDataBlock(GameBaseData *dptr, bool reload); - void setInteractObject(SceneObject* object, bool holding); + void setInteractObject(SceneObject* object, bool holding); - void setTransform(const MatrixF &mat); - void setModelName(String &modelName); + void setTransform(const MatrixF &mat); + void setModelName(String &modelName); - U32 packUpdate(NetConnection *conn, U32 mask, BitStream *stream); - void unpackUpdate(NetConnection *conn, BitStream *stream); - void writePacketData(GameConnection *conn, BitStream *stream); - void readPacketData(GameConnection *conn, BitStream *stream); + U32 packUpdate(NetConnection *conn, U32 mask, BitStream *stream); + void unpackUpdate(NetConnection *conn, BitStream *stream); + void writePacketData(GameConnection *conn, BitStream *stream); + void readPacketData(GameConnection *conn, BitStream *stream); - void prepRenderImage(SceneRenderState *state); + void prepRenderImage(SceneRenderState *state); - MatrixF getTrackedTransform(); - MatrixF getLastTrackedTransform(); - MatrixF getBaseTrackingTransform(); + MatrixF getTrackedTransform(); + MatrixF getLastTrackedTransform(); + MatrixF getBaseTrackingTransform(); - U32 getCollisionMask(); - void updateWorkingCollisionSet(); + U32 getCollisionMask(); + void updateWorkingCollisionSet(); - // Time management - void updateMove(const Move *move); - void processTick(const Move *move); - void interpolateTick(F32 delta); - void advanceTime(F32 dt); + // Time management + void updateMove(const Move *move); + void processTick(const Move *move); + void interpolateTick(F32 delta); + void advanceTime(F32 dt); - // Collision - bool castRay(const Point3F &start, const Point3F &end, RayInfo* info); - void buildConvex(const Box3F& box, Convex* convex); - bool testObject(SceneObject* enter); + // Collision + bool castRay(const Point3F &start, const Point3F &end, RayInfo* info); + void buildConvex(const Box3F& box, Convex* convex); + bool testObject(SceneObject* enter); };