Tidy up indentation in openvr changes

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

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

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<OpenVRTrackedObject*> 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<OpenVRTrackedObject*> list;
-
-	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);
-	}
-
-	object->setControllers(list);
+   OpenVRTrackedObject *controllerL, *controllerR;
+   Vector<OpenVRTrackedObject*> list;
+
+   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);
+   }
+
+   object->setControllers(list);
 }
 
 #endif

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

Engine/source/gfx/gfxAdapter.h

@@ -37,8 +37,8 @@
 
 struct GFXAdapterLUID
 {
-	unsigned long LowPart;
-	long HighPart;
+   unsigned long LowPart;
+   long HighPart;
 };
 
 struct GFXAdapter 

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;
    

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<GFXFormat> &formats, bool texture, bool mustblend, bool mustfilter) = 0;
+      const Vector<GFXFormat> &formats, bool texture, bool mustblend, bool mustfilter) = 0;
 
    /// @}
 

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

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

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];
-			}
-		}
-	}
-
-	return NULL;
+   for (U32 i = 0; i < smAdapters.size(); i++)
+   {
+      if (smAdapters[i]->mType == type)
+      {
+         if (smAdapters[i]->mIndex == outputDeviceIndex)
+         {
+            return smAdapters[i];
+         }
+      }
+   }
+
+   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);
-
-	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);
-	}
-
-	AssertFatal(adapter, "There is no rendering device available whatsoever.");
-	return adapter;
+   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)
+   {
+      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;
 }
 
 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.

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

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

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 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 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);
+   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);
+
+   // 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 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 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);
-
-	// 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 connecting corners
-	drawLine(point0, point4, color);
-	drawLine(point1, point5, color);
-	drawLine(point2, point6, color);
-	drawLine(point3, point7, 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 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);
+
+   // 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 connecting corners
+   drawLine(point0, point4, color);
+   drawLine(point1, point5, color);
+   drawLine(point2, point6, color);
+   drawLine(point3, point7, color);
 }
 
 void DebugDrawer::render(bool clear)

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.      

Engine/source/gui/3d/guiTSControl.cpp

@@ -64,9 +64,9 @@ Vector<GuiTSCtrl*> 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;
-
-	   REFLECTMGR->update(mReflectPriority / totalPriority,
-		   renderSize,
-		   mLastCameraQuery);
+      // 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);
    }
 
    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;
-
-	   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();
+      // 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[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;
 

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

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;
-
-	D3D11OculusTexture(GFXDevice* owner) :
-		hmd(nullptr),
-		TextureSet(nullptr),
-		Owner(owner)
-	{
-		TexRtv[0] = TexRtv[1] = nullptr;
-	}
-
-	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;
-
-
-		GFXD3D11Device* device = static_cast<GFXD3D11Device*>(GFX);
-		ovrResult result = ovr_CreateSwapTextureSetD3D11(hmd, device->mD3DDevice, &dsDesc, ovrSwapTextureSetD3D11_Typeless, &TextureSet);
-		if (!OVR_SUCCESS(result))
-			return false;
-
-		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;
-
-			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;
-
-			// 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;
-
-			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;
-	}
-
-	~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;
-	}
+   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;
+   }
+
+   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;
+
+
+      GFXD3D11Device* device = static_cast<GFXD3D11Device*>(GFX);
+      ovrResult result = ovr_CreateSwapTextureSetD3D11(hmd, device->mD3DDevice, &dsDesc, ovrSwapTextureSetD3D11_Typeless, &TextureSet);
+      if (!OVR_SUCCESS(result))
+         return false;
+
+      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;
+
+         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;
+
+         // 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;
+
+         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;
+   }
+
+   ~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;
+   }
 };
 
 
@@ -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<GFXAdapter*> adapterList;
-	GFXD3D11Device::enumerateAdapters(adapterList);
+   //
+   Vector<GFXAdapter*> 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;
-
-	GFXD3D11Device* device = static_cast<GFXD3D11Device*>(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]);
-	}
-
-	ovrSizei recommendedEyeTargetSize[2];
-	recommendedEyeTargetSize[0] = mRenderLayer.Viewport[0].Size;
-	recommendedEyeTargetSize[1] = mRenderLayer.Viewport[1].Size;
-
-	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
-			);
-
-		GFXFormat targetFormat = GFX->getActiveRenderTarget()->getFormat();
-		mRTFormat = targetFormat;
-
-		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;
-		}
-
-		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;
-
-		// 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));
-
-		GFXD3D11Device* device = static_cast<GFXD3D11Device*>(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;
-
-		// 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;
-		}
-
-		// 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());
-
-
-		// 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);
-
-		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;
-	}
-
-	return true;
+   // Create eye render buffers
+   ID3D11RenderTargetView * eyeRenderTexRtv[2];
+   ovrLayerEyeFov           ld = { { ovrLayerType_EyeFov } };
+   mRenderLayer = ld;
+
+   GFXD3D11Device* device = static_cast<GFXD3D11Device*>(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]);
+   }
+
+   ovrSizei recommendedEyeTargetSize[2];
+   recommendedEyeTargetSize[0] = mRenderLayer.Viewport[0].Size;
+   recommendedEyeTargetSize[1] = mRenderLayer.Viewport[1].Size;
+
+   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
+         );
+
+      GFXFormat targetFormat = GFX->getActiveRenderTarget()->getFormat();
+      mRTFormat = targetFormat;
+
+      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;
+      }
+
+      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;
+
+      // 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));
+
+      GFXD3D11Device* device = static_cast<GFXD3D11Device*>(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;
+
+      // 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;
+      }
+
+      // 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());
+
+
+      // 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);
+
+      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;
+   }
+
+   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<GFXD3D11Device*>(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;

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;
 

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<OpenVRProvider>::instanceOrNull())
-	{
-		OPENVR->unregisterOverlay(this);
-	}
+   if (ManagedSingleton<OpenVRProvider>::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;
-
-	GuiTextCtrl* textCtrl = dynamic_cast<GuiTextCtrl*>(ctrl);
-	if (textCtrl)
-	{
-		char text[GuiTextCtrl::MAX_STRING_LENGTH];
-		vr::VROverlay()->GetKeyboardText(text, GuiTextCtrl::MAX_STRING_LENGTH);
-		textCtrl->setText(text);
-	}
+   if (!ctrl)
+      return;
+
+   GuiTextCtrl* textCtrl = dynamic_cast<GuiTextCtrl*>(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;
-
-	GuiTextEditCtrl* ctrl = dynamic_cast<GuiTextEditCtrl*>(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);
-	}
+   vr::IVROverlay *overlay = vr::VROverlay();
+   if (!overlay || !mOverlayHandle)
+      return;
+
+   GuiTextEditCtrl* ctrl = dynamic_cast<GuiTextEditCtrl*>(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)

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;

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 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 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, 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<int TEXSIZE> class VRTextureSet
 {
 public:
-	static const int TextureCount = TEXSIZE;
-	GFXTexHandle mTextures[TEXSIZE];
-	U32 mIndex;
-
-	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 clear()
-	{
-		for (U32 i = 0; i < TextureCount; i++)
-		{
-			mTextures[i] = NULL;
-		}
-	}
-
-	void advance()
-	{
-		mIndex = (mIndex + 1) % TextureCount;
-	}
-
-	GFXTexHandle& getTextureHandle()
-	{
-		return mTextures[mIndex];
-	}
+   static const int TextureCount = TEXSIZE;
+   GFXTexHandle mTextures[TEXSIZE];
+   U32 mIndex;
+
+   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 clear()
+   {
+      for (U32 i = 0; i < TextureCount; i++)
+      {
+         mTextures[i] = NULL;
+      }
+   }
+
+   void advance()
+   {
+      mIndex = (mIndex + 1) % TextureCount;
+   }
+
+   GFXTexHandle& getTextureHandle()
+   {
+      return mTextures[mIndex];
+   }
 };
 
 /// Simple class to handle rendering native OpenVR model data
 class OpenVRRenderModel
 {
 public:
-	typedef GFXVertexPNT VertexType;
-	GFXVertexBufferHandle<VertexType> mVertexBuffer;
-	GFXPrimitiveBufferHandle mPrimitiveBuffer;
-	BaseMatInstance* mMaterialInstance; ///< Material to use for rendering. NOTE:  
-	Box3F mLocalBox;
-
-	OpenVRRenderModel() : mMaterialInstance(NULL)
-	{
-	}
-
-	~OpenVRRenderModel()
-	{
-		SAFE_DELETE(mMaterialInstance);
-	}
-
-	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);
+   typedef GFXVertexPNT VertexType;
+   GFXVertexBufferHandle<VertexType> mVertexBuffer;
+   GFXPrimitiveBufferHandle mPrimitiveBuffer;
+   BaseMatInstance* mMaterialInstance; ///< Material to use for rendering. NOTE:  
+   Box3F mLocalBox;
+
+   OpenVRRenderModel() : mMaterialInstance(NULL)
+   {
+   }
+
+   ~OpenVRRenderModel()
+   {
+      SAFE_DELETE(mMaterialInstance);
+   }
+
+   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);
 };
 
 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<OpenVROverlay*> mOverlays;
+   Vector<OpenVROverlay*> mOverlays;
 
-	VREventSignal mVREventSignal;
-	Namespace *mOpenVRNS;
+   VREventSignal mVREventSignal;
+   Namespace *mOpenVRNS;
 
-	Vector<LoadedRenderModel> mLoadedModels;
-	Vector<LoadedRenderTexture> mLoadedTextures;
-	Map<StringTableEntry, S32> mLoadedModelLookup;
-	Map<U32, S32> mLoadedTextureLookup;
+   Vector<LoadedRenderModel> mLoadedModels;
+   Vector<LoadedRenderTexture> mLoadedTextures;
+   Map<StringTableEntry, S32> mLoadedModelLookup;
+   Map<U32, S32> mLoadedTextureLookup;
 
-	Map<U32, S32> mDeviceEventMap;
+   Map<U32, S32> mDeviceEventMap;
    /// }
 
    GuiCanvas* mDrawCanvas;

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;
-
-	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 (loadComponentModels)
-	{
-		mRenderComponents.setSize(models->GetComponentCount(mModelName));
-
-		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;
-
-			U32 result = models->GetComponentName(mModelName, i, buffer, sizeof(buffer));
-			if (result == 0)
-				continue;
+   clearRenderData();
+   
+   if (!OPENVR || !OPENVR->isEnabled())
+      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 (loadComponentModels)
+   {
+      mRenderComponents.setSize(models->GetComponentCount(mModelName));
+
+      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;
+
+         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<OpenVRTrackedObjectData*>(dptr);
-	if (!mDataBlock || !Parent::onNewDataBlock(dptr, reload))
-		return false;
+   mDataBlock = dynamic_cast<OpenVRTrackedObjectData*>(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();
-
-	// debug rendering for now
-
-	if (mDeviceIndex < 0)
-		return;
-
-	// Current pose
-	IDevicePose pose = OPENVR->getTrackedDevicePose(mDeviceIndex);
-	IDevicePose hmdPose = OPENVR->getTrackedDevicePose(0);
-
-	if (!pose.connected && !mPose.connected)
-		return;
-
-	MatrixF offsetMat = getBaseTrackingTransform();
-	//offsetMat.inverse();
-
-	Point3F pos = offsetMat.getPosition();
-	//Con::printf("Base offs == %f,%f,%f", pos.x, pos.y, pos.z);
-
-	const F32 CONTROLLER_SCALE = 0.1;
-
-	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 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;
-
-		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);
-
-		//DebugDrawer::get()->drawBox(center - Point3F(0.1), center + Point3F(0.1), ColorI::BLUE);
-
-		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);
-	}
-
-	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<OpenVRTrackedObject*>(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;
-
-		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);
-
-		//DebugDrawer::get()->drawBox(center - Point3F(0.1), center + Point3F(0.1), ColorI::BLUE);
-
-		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);
-	}
-
-	// Controller matrix base
-	MatrixF trackedMat = getTrackedTransform();
-	MatrixF invTrackedMat(1);
-
-	invTrackedMat = trackedMat;
-	invTrackedMat.inverse(); // -> world mat (as opposed to world -> tracked pos)
-
-	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;
-
-		// Set up the LOD for the shape
-		F32 invScale = (1.0f / getMax(getMax(mObjScale.x, mObjScale.y), mObjScale.z));
-
-		mShapeInstance->setDetailFromDistance(state, dist * invScale);
-
-		// 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;
-
-		// 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);
-
-		// Set the world matrix to the objects render transform
-		MatrixF mat = trackedMat;
-
-		mat.scale(mObjScale);
-		GFX->setWorldMatrix(mat);
-
-		// 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;
-
-		vr::IVRSystem* vrs = vr::VRSystem();
-
-		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;
-
-			modeState.bScrollWheelVisible = false;
-
-			if (models->GetComponentState(mModelName, slot.componentName, &mCurrentControllerState, &modeState, &componentState))
-			{
-				MeshRenderInst *ri = renderPass->allocInst<MeshRenderInst>();
-
-				// 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;
-				}
-
-				MatrixF newTransform = trackedMat;
-				MatrixF controllerOffsMat = OpenVRUtil::convertSteamVRAffineMatrixToMatrixFPlain(componentState.mTrackingToComponentRenderModel);
-				MatrixF offComponentMat(1);
-				OpenVRUtil::convertTransformFromOVR(controllerOffsMat, offComponentMat);
-
-				newTransform = offComponentMat * newTransform;
-
-				newTransform.inverse();
-
-				//DebugDrawer::get()->drawBox(newTransform.getPosition() - Point3F(0.001), newTransform.getPosition() + Point3F(0.001), ColorI::BLUE);
-
-				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);
-
-				// 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<MeshRenderInst>();
-
-		// 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;
-		}
-
-		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);
-		}
-
-		// Draw model
-		mBasicModel->draw(state, ri);
-		state->getRenderPass()->addInst(ri);
-	}
+   RenderPassManager *renderPass = state->getRenderPass();
+
+   // debug rendering for now
+
+   if (mDeviceIndex < 0)
+      return;
+
+   // Current pose
+   IDevicePose pose = OPENVR->getTrackedDevicePose(mDeviceIndex);
+   IDevicePose hmdPose = OPENVR->getTrackedDevicePose(0);
+
+   if (!pose.connected && !mPose.connected)
+      return;
+
+   MatrixF offsetMat = getBaseTrackingTransform();
+   //offsetMat.inverse();
+
+   Point3F pos = offsetMat.getPosition();
+   //Con::printf("Base offs == %f,%f,%f", pos.x, pos.y, pos.z);
+
+   const F32 CONTROLLER_SCALE = 0.1;
+
+   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 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;
+
+      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);
+
+      //DebugDrawer::get()->drawBox(center - Point3F(0.1), center + Point3F(0.1), ColorI::BLUE);
+
+      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);
+   }
+
+   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<OpenVRTrackedObject*>(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;
+
+      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);
+
+      //DebugDrawer::get()->drawBox(center - Point3F(0.1), center + Point3F(0.1), ColorI::BLUE);
+
+      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);
+   }
+
+   // Controller matrix base
+   MatrixF trackedMat = getTrackedTransform();
+   MatrixF invTrackedMat(1);
+
+   invTrackedMat = trackedMat;
+   invTrackedMat.inverse(); // -> world mat (as opposed to world -> tracked pos)
+
+   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;
+
+      // Set up the LOD for the shape
+      F32 invScale = (1.0f / getMax(getMax(mObjScale.x, mObjScale.y), mObjScale.z));
+
+      mShapeInstance->setDetailFromDistance(state, dist * invScale);
+
+      // 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;
+
+      // 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);
+
+      // Set the world matrix to the objects render transform
+      MatrixF mat = trackedMat;
+
+      mat.scale(mObjScale);
+      GFX->setWorldMatrix(mat);
+
+      // 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;
+
+      vr::IVRSystem* vrs = vr::VRSystem();
+
+      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;
+
+         modeState.bScrollWheelVisible = false;
+
+         if (models->GetComponentState(mModelName, slot.componentName, &mCurrentControllerState, &modeState, &componentState))
+         {
+            MeshRenderInst *ri = renderPass->allocInst<MeshRenderInst>();
+
+            // 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;
+            }
+
+            MatrixF newTransform = trackedMat;
+            MatrixF controllerOffsMat = OpenVRUtil::convertSteamVRAffineMatrixToMatrixFPlain(componentState.mTrackingToComponentRenderModel);
+            MatrixF offComponentMat(1);
+            OpenVRUtil::convertTransformFromOVR(controllerOffsMat, offComponentMat);
+
+            newTransform = offComponentMat * newTransform;
+
+            newTransform.inverse();
+
+            //DebugDrawer::get()->drawBox(newTransform.getPosition() - Point3F(0.001), newTransform.getPosition() + Point3F(0.001), ColorI::BLUE);
+
+            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);
+
+            // 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<MeshRenderInst>();
+
+      // 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;
+      }
+
+      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);
+      }
+
+      // 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<const ExtendedMove*>(move);
-	if (!emove)
-		return;
+   const ExtendedMove* emove = dynamic_cast<const ExtendedMove*>(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;
-
-	// 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++;
-	}
-
-	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;
+   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;
+
+   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->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();
-
-	Box3F realBox = box;
-	mWorldToObj.mul(realBox);
-	realBox.minExtents.convolveInverse(mObjScale);
-	realBox.maxExtents.convolveInverse(mObjScale);
-
-	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;
-
-	// 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;
+   // These should really come out of a pool
+   mConvexList->collectGarbage();
+
+   Box3F realBox = box;
+   mWorldToObj.mul(realBox);
+   realBox.minExtents.convolveInverse(mObjScale);
+   realBox.maxExtents.convolveInverse(mObjScale);
+
+   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;
+
+   // 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;
 }
 
 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);
 }

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<TSShape> mShape; ///< Torque model
+   StringTableEntry mShapeFile;
+   Resource<TSShape> 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<RenderModelSlot> mRenderComponents;
-	/// }
+   /// @name Rendering
+   /// {
+   TSShapeInstance *mShapeInstance; ///< Shape used to render controller (uses native model otherwise)
+   StringTableEntry mModelName;
+   OpenVRRenderModel *mBasicModel; ///< Basic model
+   Vector<RenderModelSlot> 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<SceneObject> mCollisionObject; ///< Object we're currently colliding with
-	SimObjectPtr<SceneObject> mInteractObject;  ///< Object we've designated as important to interact with
+   SimObjectPtr<SceneObject> mCollisionObject; ///< Object we're currently colliding with
+   SimObjectPtr<SceneObject> 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);
 
 };