Implementing an ArcbAll MovementController

    This site uses cookies. By continuing to browse this site, you are agreeing to our Cookie Policy.

    • Implementing an ArcbAll MovementController

      Hello,

      After messing with the latest version of the GCC Source Code i am trying to program a custom Model Viewer using the framework.

      I checked in the DXUT10 an implementation of a ModelViewer Camera class based on Quaternions and i wanted to adapt this implementation to an ArcBall MovementController inside the framework, but im unable to get the camera to rotate around the target object as it should...

      Some time ago i managed to implement a camera system based on UVN vectors (I dont know if this is the correct name) which worked flawlessly, so im not sure if it would be better to try the DXUT system or adapt what i already had...

      Any suggestion?

      Regards,

      C Source Code

      1. #pragma once
      3. #include "Geometry.h"
      6. // Forward declarations
      7. class SceneNode;
      8. class MovementController;
      11. class ArcBallCamMovementController : public MovementController
      12. {
      13. public:
      14. ArcBallCamMovementController (shared_ptr<SceneNode> object, float initialYaw, float initialPitch, bool rotateWhenLButtonDown);
      15. void Reset();
      17. virtual void OnUpdate(DWORD const elapsedMs);
      18. virtual bool VOnLButtonDown(const CPoint &mousePos);
      19. bool VOnMouseMove(const CPoint &mousePos);
      21. Vec3 ScreenToVector( float fScreenPtX, float fScreenPtY );
      22. Quaternion QuatFromBallPoints( Vec3 &vFrom, Vec3 &vTo );
      24. virtual void SetObject(shared_ptr<SceneNode> newObject);
      26. private:
      28. bool m_bUpdateObject;
      30. shared_ptr<CameraNode> m_pSceneCam;
      32. shared_ptr<SceneNode> m_pCamTarget;
      34. //from MovController
      35. //CRect m_WindowClientRect;
      37. Quaternion m_qDown; // Quaternion before button down
      38. Quaternion m_qNow; // Composite quaternion for current drag
      40. float m_fRadius; // arc ball's radius in screen coords
      41. float m_fRadiusTranslation; // arc ball's radius for translating the target
      43. Vec3 m_vDownPt; // starting point of rotation arc
      44. Vec3 m_vCurrentPt; // current point of rotation arc
      46. Vec3 m_vEye; // Camera eye position
      47. Vec3 m_vLookAt; // LookAt position
      48. Mat4x4 m_CameraRotLast;
      49. };
      50. -----------
      53. #include "u3dVisorStd.h"
      55. #include "..\GameCode.h"
      56. #include "..\Actors.h"
      58. #include "SceneNodes.h"
      59. #include "u3dSceneNodes.h"
      63. /*
      64. MovementController::MovementController(shared_ptr<SceneNode> object, float initialYaw, float initialPitch, bool rotateWhenLButtonDown)
      65. : m_object(object)
      66. {
      67. m_object->VGet()->Transform(&m_matToWorld, &m_matFromWorld);
      70. }
      71. */
      72. ArcBallCamMovementController ::ArcBallCamMovementController (shared_ptr<SceneNode> object, float initialYaw, float initialPitch, bool rotateWhenLButtonDown)
      73. :MovementController(object, initialYaw, initialPitch,rotateWhenLButtonDown),
      74. m_pSceneCam((CameraNode*)(&*m_object))
      75. {
      76. Reset();
      78. assert(m_object);
      80. m_pCamTarget = m_pSceneCam->GetTarget();
      82. //eye and lookat from the camera
      83. m_vEye = m_pSceneCam->GetPosition();
      84. m_vLookAt = Vec3(m_matToWorld._31, m_matToWorld._32, m_matToWorld._33);
      86. //Build quat from the camera object
      87. m_qNow.Build(m_matToWorld);
      89. // Set the radius according to the distance
      90. if(m_pCamTarget)
      91. {
      92. Vec3 v(m_pCamTarget->GetPosition() - m_vEye);
      93. m_fRadius = v.Length();
      94. }
      96. m_bUpdateObject = false;
      97. }
      99. void ArcBallCamMovementController::SetObject(shared_ptr<SceneNode> newObject)
      100. {
      101. // Set the radius according to the distance
      102. m_pCamTarget = m_pSceneCam->GetTarget();
      103. m_vLookAt = m_pCamTarget->GetPosition();
      104. Vec3 v(m_vLookAt - m_vEye);
      105. m_fRadius = v.Length();
      106. }
      108. //--------------------------------------------------------------------------------------
      109. void ArcBallCamMovementController::Reset()
      110. {
      111. m_qDown.Build(Mat4x4::g_Identity);
      112. m_qNow.Build(Mat4x4::g_Identity);
      113. m_fRadiusTranslation = 1.0f;
      114. m_fRadius = 1.0f;
      115. }
      119. //--------------------------------------------------------------------------------------
      120. Vec3 ArcBallCamMovementController::ScreenToVector( float fScreenPtX, float fScreenPtY )
      121. {
      122. // Scale to screen
      123. float x = -(fScreenPtX - m_WinOffset.x - m_nWidth/2) / (m_fRadius*m_nWidth/2);
      124. float y = (fScreenPtY - m_WinOffset.y - m_nHeight/2) / (m_fRadius*m_nHeight/2);
      126. float z = 0.0f;
      127. float mag = x*x + y*y;
      129. if( mag > 1.0f )
      130. {
      131. FLOAT scale = 1.0f/sqrtf(mag);
      132. x *= scale;
      133. y *= scale;
      134. }
      135. else
      136. z = sqrtf( 1.0f - mag );
      138. // Return vector
      139. return Vec3( x, y, z );
      140. }
      141. //--------------------------------------------------------------------------------------
      142. Quaternion ArcBallCamMovementController::QuatFromBallPoints( Vec3 &vFrom, Vec3 &vTo )
      143. {
      144. Vec3 vPart;
      145. float fDot = vFrom.Dot(vTo);
      146. vPart = vFrom.Cross(vTo);
      148. return Quaternion(D3DXQUATERNION(vPart.x, vPart.y, vPart.z, fDot));
      149. }
      150. //--------------------------------------------------------------------------------------
      151. #define MAX(a, b) ((a) >= (b) ? (a) : (b))
      152. #define MIN(a, b) ((a) < (b) ? (a) : (b))
      154. #define RADIANS_TO_DEGREES(x) ((x) * 180.0f / D3DX_PI)
      155. #define DEGREES_TO_RADIANS(x) ((x) * D3DX_PI / 180.0f)
      156. //--------------------------------------------------------------------------------------
      157. bool ArcBallCamMovementController::VOnLButtonDown(const CPoint &mousePos)
      158. {
      159. m_mouseLButtonDown = true;
      161. // We want mouise movement to be relative to the position
      162. // the cursor was at when the user first presses down on
      163. // the left button
      165. if( mousePos.x >= m_WinOffset.x &&
      166. mousePos.x < m_WinOffset.x + m_nWidth &&
      167. mousePos.y >= m_WinOffset.y &&
      168. mousePos.y < m_WinOffset.y + m_nHeight )
      169. {
      170. m_qDown = m_qNow;
      171. m_vDownPt = ScreenToVector( mousePos.x, mousePos.y );
      172. m_lastMousePos = mousePos;
      173. }
      175. return true;
      176. }
      178. bool ArcBallCamMovementController::VOnMouseMove(const CPoint &mousePos)
      179. {
      180. if (m_bRotateWhenLButtonDown)
      181. {
      182. // Mode 1 - rotate the view only when the left mouse button is down
      183. // Only look around if the left button is down
      184. if(m_lastMousePos!=mousePos && m_mouseLButtonDown)
      185. {
      186. m_vCurrentPt = ScreenToVector( mousePos.x, mousePos.y );
      187. m_qNow = m_qDown * QuatFromBallPoints( m_vDownPt, m_vCurrentPt );
      188. //m_qNow.Normalize();
      189. m_bUpdateObject = true;
      191. //m_fTargetYaw = m_fTargetYaw + (m_lastMousePos.x - mousePos.x);
      192. //m_fTargetPitch = m_fTargetPitch + (mousePos.y - m_lastMousePos.y);
      193. m_fTargetYaw = (m_lastMousePos.x - mousePos.x);
      194. m_fTargetPitch = (mousePos.y - m_lastMousePos.y);
      196. m_lastMousePos = mousePos;
      198. }
      199. }
      200. else if(m_lastMousePos!=mousePos)
      201. {
      202. m_vCurrentPt = ScreenToVector( mousePos.x, mousePos.y );
      203. m_qNow = m_qDown * QuatFromBallPoints( m_vDownPt, m_vCurrentPt );
      204. //m_qNow.Normalize();
      206. m_bUpdateObject = true;
      208. // Mode 2 - rotate the controller when the mouse buttons are up
      209. //m_fTargetYaw = m_fTargetYaw + (m_lastMousePos.x - mousePos.x);
      210. //m_fTargetPitch = m_fTargetPitch + (mousePos.y - m_lastMousePos.y);
      211. m_fTargetYaw = (m_lastMousePos.x - mousePos.x);
      212. m_fTargetPitch = (mousePos.y - m_lastMousePos.y);
      213. m_lastMousePos = mousePos;
      214. }
      215. return true;
      217. }
      219. void ArcBallCamMovementController::OnUpdate(DWORD const deltaMilliseconds)
      220. {
      221. if(!m_bUpdateObject)
      222. return;
      224. float elapsedTime = (float)deltaMilliseconds / 1000.0f;
      225. // Ramp the acceleration by the elapsed time.
      226. float numberOfSeconds = 5.f;
      227. m_currentSpeed += m_maxSpeed * ( (elapsedTime*elapsedTime) / numberOfSeconds);
      229. if (m_currentSpeed > m_maxSpeed)
      230. m_currentSpeed = m_maxSpeed;
      232. //Vec3 direction(m_fTargetYaw, m_fTargetPitch, 0.f),
      233. Vec3 direction(m_fTargetYaw, m_fTargetPitch, 0.f),
      234. posDelta;
      236. //Calculate delta position
      237. posDelta = direction * m_currentSpeed;
      239. // Get the inverse of the arcball's rotation matrix = camera rotation matrix
      240. Mat4x4 CameraRot;
      242. CameraRot.BuildRotationQuat(m_qNow);
      243. CameraRot.Inverse();
      245. Vec3 atToWorld(CameraRot.Xform(g_Forward4)),
      246. upToWorld(CameraRot.Xform(g_Up4)),
      247. vposDeltaWorld( CameraRot.Xform(posDelta));//,
      248. //vLookAt;
      250. //??
      251. //D3DXVec3TransformCoord(&temp, &v, this);
      253. // Move the lookAt position
      254. m_vLookAt += vposDeltaWorld;
      256. // Update the eye point based on a radius away from the lookAt position
      257. m_vEye = m_vLookAt - atToWorld * m_fRadius;
      259. // Update the view matrix
      260. D3DXMATRIX mView;
      261. D3DXMatrixLookAtLH( &mView, &m_vEye, &m_vLookAt, &upToWorld );
      263. Mat4x4 mMView(mView), InvmMView(mMView.Inverse());
      265. InvmMView._41 = InvmMView._42 = InvmMView._43 = 0.f;
      266. //-------------
      267. Mat4x4 matToWorld, matLastToWorldInv(m_matLastToWorld.Inverse()), CameraRotLastInv(m_CameraRotLast.Inverse());
      268. //equals to the camera??????????
      269. matToWorld.BuildRotationQuat(m_qNow);
      271. matToWorld = matToWorld * mMView * matLastToWorldInv * matToWorld * InvmMView;
      273. //??????
      274. //Update world??? according to target-model movement?
      275. matToWorld = matToWorld * CameraRotLastInv * CameraRot;
      277. m_CameraRotLast = CameraRot;
      278. m_matLastToWorld = matToWorld;
      280. Vec3 XBasis(matToWorld._11, matToWorld._12, matToWorld._13),
      281. YBasis(matToWorld._21, matToWorld._22, matToWorld._23),
      282. ZBasis(matToWorld._31, matToWorld._32, matToWorld._33);
      284. XBasis.Normalize();
      285. YBasis.Normalize();
      286. ZBasis.Normalize();
      288. matToWorld._11 = XBasis.x; matToWorld._12 = XBasis.y; matToWorld._13 = XBasis.z;
      289. matToWorld._21 = YBasis.x; matToWorld._22 = YBasis.y; matToWorld._23 = YBasis.z;
      290. matToWorld._31 = ZBasis.x; matToWorld._32 = ZBasis.y; matToWorld._33 = ZBasis.z;
      291. matToWorld.SetPosition(m_vLookAt);
      292. //matToWorld.SetPosition(m_vEye);
      294. //m_matPosition.BuildTranslation(m_vEye * -1.0f);
      295. m_matPosition.BuildTranslation(m_vEye);
      297. m_matToWorld = m_matPosition * matToWorld;
      299. m_matFromWorld = m_matToWorld.Inverse();
      300. m_object->VSetTransform(&m_matToWorld, &m_matFromWorld);
      301. //m_object->VSetTransform(&mMView, NULL);
      304. m_bUpdateObject = false;
      Display All

    • I've only quickly glanced at the code, so I don't know how much help I can be now, but do you see any sort of rotation when you run the app? And are you sure the target of the camera and the other external data is valid?
      "There are of course many problems connected with life, of which some of the most popular are: Why are people born? Why do they die? Why do they want to spend so much of the intervening time wearing digital watches?"
      -Douglas Adams

    • Yeah, sorry if it wasnt well explained... I was running a bit mad, :(...

      - I am sure that the camera target is correctly setup, i made some modifications on the SetViewTransform and viewlistener handling functions to attach the target... Right now, the camera makes like a strafing movement when applying yaw and it pitches a bit but very slowly...

      - Basically, based on the dxut code, i am using a quaternion generated from the movement of the mouse to generate the rotation matrix and applying it to the same mouse movement vector to obtain the camera view direction movement, after that i create a new camera view matrix using Lookatlh. After that i am losing a bit, because it seems to generate a new world matrix using basis change... This is all implemented in the OnUpdate function.

      - Anyway ill try to relax a bit and try to validate all the data, maths isnt my strengh and i overreact when dealing with all these...

      Regards,

      @B^)>

    • talking to myself

      Well finally it worked somehow. I didnt use the dxut version but adopted another from the a arcball opengl version i found....

      I presume this is enough for a simple model viewer, now ill try to load and display some models using a custom model exporter...

      @B^)>

      Brainfuck Source Code

      1. class ArcBallCamMovementController : public MovementController
      2. {
      3. public:
      4. ArcBallCamMovementController (shared_ptr<SceneNode> object, float initialYaw, float initialPitch, bool rotateWhenLButtonDown);
      5. void Reset();
      7. virtual void OnUpdate(DWORD const elapsedMs);
      8. virtual bool VOnLButtonDown(const CPoint &mousePos);
      9. bool VOnMouseMove(const CPoint &mousePos);
      11. Vec3 ScreenToVector( float fScreenPtX, float fScreenPtY );
      13. virtual void SetObject(shared_ptr<SceneNode> newObject);
      15. Vec3 PlanarCoord(float posX, float posY);
      17. private:
      19. bool m_bUpdateObject, m_bViewRotation;
      21. shared_ptr<CameraNode> m_pSceneCam;
      23. shared_ptr<SceneNode> m_pCamTarget;
      26. Quaternion m_qLast, m_qDown, m_qNow;
      28. float m_fZoom, m_fZoom2; // current radius
      29. float m_fRadius, m_fRadius2; // arc ball's radius
      31. float m_fEdge; // the distance from the origin of the plane that intersects
      32. // the edge of the visible sphere (tangent to a ray from the eye)
      34. // whether we are using a sphere or plane
      35. bool m_bPlanar;
      37. Vec3 m_vEye; // Camera eye position
      38. Vec3 m_vLookAt; // LookAt position
      39. Vec3 m_vUptoWorld; // LookAt position
      40. Vec3 m_vRighttoWorld; // LookAt position
      42. Mat4x4 m_CameraRotLast;
      43. //
      46. //CHECK!!!!!!!!!! Windows bounds and projection from MovController!!!!!
      47. //CRect m_WindowClientRect;
      48. //int m_nWidth; // arc ball's window width
      49. //int m_nHeight; // arc ball's window height
      50. Mat4x4 m_matProjection;
      52. Vec3 m_vDownPt; // starting point of rotation arc
      53. Vec3 m_vCurrentPt; // current point of rotation arc
      57. };
      59. ArcBallCamMovementController ::ArcBallCamMovementController (shared_ptr<SceneNode> object, float initialYaw, float initialPitch, bool rotateWhenLButtonDown)
      60. :MovementController(object, initialYaw, initialPitch,rotateWhenLButtonDown),
      61. m_pSceneCam((CameraNode*)(&*m_object))
      62. {
      63. Reset();
      65. assert(m_object);
      67. m_matLastToWorld = m_matToWorld;
      69. m_pCamTarget = m_pSceneCam->GetTarget();
      71. //eye and lookat from the camera
      72. m_vEye = m_pSceneCam->GetPosition();
      74. //NOT VALID, SetObject should be called!!
      75. m_vLookAt = Vec3(m_matToWorld._31, m_matToWorld._32, m_matToWorld._33);
      76. m_vRighttoWorld = Vec3(m_matToWorld._11, m_matToWorld._12, m_matToWorld._13);
      77. m_vUptoWorld = Vec3(m_matToWorld._21, m_matToWorld._22, m_matToWorld._23);
      80. //Build quat from the camera object
      81. m_qNow.Build(m_matToWorld);
      83. // Set the radius according to the distance
      84. if(m_pCamTarget)
      85. {
      86. Vec3 v(m_pCamTarget->GetPosition() - m_vEye);
      87. m_fRadius = v.Length();
      88. }
      90. m_matProjection = m_pSceneCam->GetProjection();
      92. m_bUpdateObject = false;
      94. //TODO: this case is planar rotation
      95. m_bViewRotation = true;
      96. }
      97. //--------------------------------------------------------------------------------------
      98. void ArcBallCamMovementController::SetObject(shared_ptr<SceneNode> newObject)
      99. {
      100. //Case m_bViewRotation = true!!
      101. // Set the radius according to the distance eye-object
      102. m_pCamTarget = m_pSceneCam->GetTarget();
      104. m_vLookAt = m_pCamTarget->GetPosition() - m_vEye;
      106. m_fRadius = m_vLookAt.Length();
      108. //should be equal to toworld._3x??
      109. m_vLookAt.Normalize();
      111. // m_vLookAt = Vec3(m_matToWorld._31, m_matToWorld._32, m_matToWorld._33);
      112. m_vRighttoWorld = Vec3(m_matToWorld._11, m_matToWorld._12, m_matToWorld._13);
      113. m_vUptoWorld = Vec3(m_matToWorld._21, m_matToWorld._22, m_matToWorld._23);
      115. m_qNow.Build(m_matToWorld);
      116. m_qLast = m_qNow;
      118. //TODO:ARG!!!
      119. m_matProjection = m_pSceneCam->GetProjection();
      122. //TODO:Case m_bViewRotation = false!!
      124. }
      126. //--------------------------------------------------------------------------------------
      127. void ArcBallCamMovementController::Reset()
      128. {
      129. m_qLast.Build(Mat4x4::g_Identity);
      130. m_qDown.Build(Mat4x4::g_Identity);
      131. m_qNow.Build(Mat4x4::g_Identity);
      132. m_fZoom = 1.0f;
      133. m_fRadius = 1.0f;
      135. m_fEdge = 1.0f;
      136. m_bPlanar = false;
      137. }
      141. //--------------------------------------------------------------------------------------
      142. Vec3 ArcBallCamMovementController::ScreenToVector( float fScreenPtX, float fScreenPtY )
      143. {
      144. float projx = m_matProjection._11,
      145. projy = m_matProjection._22;
      147. Vec3 vInvProj( (((2.0f * fScreenPtX)/m_nWidth)-1) / projx,
      148. -(((2.0f * fScreenPtY)/m_nHeight)-1) / projy,
      149. 1.0f);
      151. vInvProj = m_matToWorld.Xform(vInvProj);
      153. return vInvProj;
      154. }
      155. //--------------------------------------------------------------------------------------
      156. Vec3 ArcBallCamMovementController::PlanarCoord(float posX, float posY)
      157. {
      158. Vec3 DownPt(ScreenToVector( posX, posY )),
      159. vecEyeDownPt(DownPt - m_vEye),
      160. d;
      162. // intersect the point with the trackball plane
      163. float intersect = (0.0f - m_fRadius) / (m_vLookAt.Dot(vecEyeDownPt));
      165. d = m_vEye + vecEyeDownPt*intersect;
      167. return Vec3(m_vUptoWorld.Dot(d), m_vRighttoWorld.Dot(d), 0.0);
      169. }
      170. //--------------------------------------------------------------------------------------
      171. bool ArcBallCamMovementController::VOnLButtonDown(const CPoint &mousePos)
      172. {
      173. m_mouseLButtonDown = true;
      176. m_vDownPt = PlanarCoord( mousePos.x, mousePos.y );
      177. m_lastMousePos = mousePos;
      179. return true;
      180. }
      181. //--------------------------------------------------------------------------------------
      182. bool ArcBallCamMovementController::VOnMouseMove(const CPoint &mousePos)
      183. {
      184. if (m_bRotateWhenLButtonDown)
      185. {
      186. // Mode 1 - rotate the view only when the left mouse button is down
      187. // Only look around if the left button is down
      188. if(m_lastMousePos!=mousePos && m_mouseLButtonDown)
      189. {
      190. m_vCurrentPt = PlanarCoord( mousePos.x, mousePos.y );
      191. m_lastMousePos = mousePos;
      192. m_bUpdateObject = true;
      193. }
      194. }
      195. else if(m_lastMousePos!=mousePos)
      196. {
      197. m_vCurrentPt = PlanarCoord( mousePos.x, mousePos.y );
      198. //m_qNow = m_qDown * QuatFromBallPoints( m_vDownPt, m_vCurrentPt );
      199. //m_qNow.Normalize();
      201. m_bUpdateObject = true;
      203. // Mode 2 - rotate the controller when the mouse buttons are up
      204. //m_fTargetYaw = m_fTargetYaw + (m_lastMousePos.x - mousePos.x);
      205. //m_fTargetPitch = m_fTargetPitch + (mousePos.y - m_lastMousePos.y);
      206. //m_fTargetYaw = (m_lastMousePos.x - mousePos.x);
      207. //m_fTargetPitch = (mousePos.y - m_lastMousePos.y);
      208. m_lastMousePos = mousePos;
      209. }
      210. return true;
      212. }
      213. //--------------------------------------------------------------------------------------
      214. void ArcBallCamMovementController::OnUpdate(DWORD const deltaMilliseconds)
      215. {
      216. if(!m_bUpdateObject)
      217. return;
      219. if(m_vDownPt == m_vCurrentPt)
      220. return;
      222. // d is motion since the last position, note z=0!
      223. Vec3 d = m_vCurrentPt - m_vDownPt;
      225. //float angle = d.Length() * 0.5;
      226. float angle = d.Length() * 0.5;
      228. float cosa = cos( angle );
      229. float sina = sin( angle );
      231. Vec3 p = ((m_vRighttoWorld*d.x)-(m_vUptoWorld*d.y));
      233. p.Normalize();
      234. p *= sina;
      236. m_qDown.BuildAxisAngle(p, cosa*(float)deltaMilliseconds / 1000.0f);
      237. m_qNow = m_qNow * m_qDown;
      239. Mat4x4 mq;
      240. mq.BuildRotationQuat(m_qNow);
      242. //CORRECTO???
      243. m_matToWorld= mq;
      245. m_vRighttoWorld = Vec3(m_matToWorld._11, m_matToWorld._12, m_matToWorld._13);
      246. m_vUptoWorld = Vec3(m_matToWorld._21, m_matToWorld._22, m_matToWorld._23);
      247. m_vLookAt = Vec3(m_matToWorld._31, m_matToWorld._32, m_matToWorld._33);
      248. m_vEye = m_pCamTarget->GetPosition() - (m_vLookAt * m_fRadius);
      250. m_matLastToWorld = mq;
      251. m_matLastToWorld.SetPosition(m_vEye);
      252. m_matFromWorld = m_matLastToWorld.Inverse();
      253. m_object->VSetTransform(&m_matLastToWorld, &m_matFromWorld);
      255. m_vDownPt = m_vCurrentPt;
      256. m_bUpdateObject = false;
      257. }
      Display All