00001 #include "Camera.h"
00002 #include "Application.h"
00003 #include "SelectableObject.h"
00004
00005 int Camera::s_nextID = 0;
00006
00007 Camera::Camera()
00008 {
00009 m_targetNode = 0;
00010 m_sceneNode = 0;
00011
00012 m_moveSpeed = 100;
00013
00014 m_rotateSpeed = 36;
00015 setID();
00016 setState(CAMERA_FREE);
00017 m_desiredDirection = Ogre::Vector3::NEGATIVE_UNIT_Z;
00018 m_lastDirection = Ogre::Vector3::NEGATIVE_UNIT_Z;
00019 m_currentDirection = Ogre::Vector3::NEGATIVE_UNIT_Z;
00020
00021 m_cameraVelocity = Ogre::Vector3::ZERO;
00022 m_cameraOffset = Ogre::Vector3(0,1.5,10);
00023 }
00024
00025 int Camera::getID() const
00026 {
00027 return m_ID;
00028 }
00029
00030 void Camera::setID()
00031 {
00032 m_ID = s_nextID;
00033 ++s_nextID;
00034 }
00035
00036 void Camera::setCamera(Ogre::Camera* _val)
00037 {
00038 m_camera = _val;
00039 }
00040
00041 Ogre::Camera* Camera::getCamera()
00042 {
00043 return m_camera;
00044 }
00045
00046 void Camera::move()
00047 {
00048
00049 Ogre::Real timeSinceLastFrame = Application::getSingleton()->getTimeSinceLastFrame();
00050
00051 Ogre::Real moveScale = m_moveSpeed * timeSinceLastFrame;
00052 Ogre::Degree rotateScale = m_rotateSpeed * timeSinceLastFrame;
00053
00054 if (m_cameraState == CAMERA_FREE)
00055 {
00056
00057 if (m_vector == Ogre::Vector3::ZERO)
00058 {
00059
00060 m_vector = m_lastMotion * 0.1f;
00061 }
00062 else
00063 {
00064
00065
00066
00067 m_vector.normalise();
00068
00069 }
00070
00071 if (m_currentSpeed > 1.0) m_currentSpeed = 1.0;
00072 if (m_currentSpeed < 0.0) m_currentSpeed = 0.0;
00073
00074 m_vector *= moveScale * 0.5f;
00075
00076
00077
00078
00079
00080
00081 m_desiredDirection = Ogre::Vector3::ZERO;
00082
00083 if (m_desiredDirection == Ogre::Vector3::ZERO)
00084 {
00085 Ogre::Quaternion targetOrientation = m_targetNode->getParentSceneNode()->getOrientation();;
00086 Ogre::Matrix3 matrix;
00087 targetOrientation.ToRotationMatrix(matrix);
00088 m_desiredDirection = -matrix.GetColumn(2);
00089 }
00090
00091 Ogre::Quaternion desiredRotation = m_lastDirection.getRotationTo(m_desiredDirection);
00092
00093
00094 m_currentDirection = (desiredRotation * 0.5) * m_lastDirection;
00095
00096 m_lastDirection = m_currentDirection;
00097
00098
00099 Ogre::Quaternion pitch = Ogre::Quaternion(m_pitch, m_currentDirection.normalisedCopy().crossProduct(Ogre::Vector3::UNIT_Y));
00100 Ogre::Quaternion yaw = Ogre::Quaternion(m_yaw, Ogre::Vector3::UNIT_Y);
00101
00102 m_currentDirection = -pitch * m_currentDirection;
00103 m_currentDirection = yaw * m_currentDirection;
00104
00105
00106 m_targetNode->setDirection(m_currentDirection, Ogre::Node::TS_WORLD);
00107
00108
00109 m_targetNode->translate(m_vector, Ogre::Node::TS_LOCAL);
00110
00111
00112 m_sceneNode->setPosition(0,0,0);
00113
00114
00115
00116
00117 m_desiredCameraPos = getSceneNode()->convertLocalToWorldPosition(getSceneNode()->getPosition());
00118
00119 Ogre::Vector3 vecBetween = (m_desiredCameraPos - m_lastCameraPos);
00120 if (vecBetween.squaredLength() > 1.0f)
00121 {
00122 m_currentCameraPos = m_lastCameraPos + (vecBetween * 0.5f);
00123 }
00124 else
00125 {
00126 m_currentCameraPos = m_desiredCameraPos;
00127 }
00128
00129 getSceneNode()->setPosition(getSceneNode()->convertWorldToLocalPosition(m_currentCameraPos));
00130 m_lastCameraPos = m_currentCameraPos;
00131
00132
00133 m_sceneNode->setPosition(0,0,m_zoomDist * m_zoomAmount);
00134
00135 }
00136 else
00137 {
00138
00139 m_desiredDirection = Ogre::Vector3::ZERO;
00140
00141
00142
00143
00144
00145
00146
00147 if (Ogre::any_cast<SelectableObject*>(m_targetNode->getParentSceneNode()->getUserAny()))
00148 {
00149
00150 SelectableObject* target = Ogre::any_cast<SelectableObject*>(m_targetNode->getParentSceneNode()->getUserAny());
00151 if (target->getPhysical())
00152 {
00153
00154 if (target->getRigidBody()->getLinearVelocity().squaredLength() > 1.0f)
00155 {
00156
00157 m_desiredDirection = target->getRigidBody()->getLinearVelocity().normalisedCopy();
00158 }
00159 }
00160 }
00161
00162
00163 if (m_desiredDirection == Ogre::Vector3::ZERO)
00164 {
00165 Ogre::Quaternion targetOrientation = m_targetNode->getParentSceneNode()->getOrientation();;
00166 Ogre::Matrix3 matrix;
00167 targetOrientation.ToRotationMatrix(matrix);
00168 m_desiredDirection = -matrix.GetColumn(2);
00169 }
00170
00171 Ogre::Quaternion desiredRotation = m_lastDirection.normalisedCopy().getRotationTo(m_desiredDirection);
00172
00173
00174 m_currentDirection = (desiredRotation * 0.25) * m_lastDirection;
00175
00176
00177 m_currentDirection.normalise();
00178
00179
00180 m_lastDirection = m_currentDirection;
00181
00182
00183 m_sceneNode->setPosition(0,0,0);
00184
00185
00186 m_targetNode->setDirection(m_currentDirection, Ogre::Node::TS_WORLD);
00187
00188
00189 m_sceneNode->setPosition(getSceneNode()->getPosition() + m_cameraOffset);
00190
00191 }
00192
00193 m_lastMotion = m_vector;
00194 m_vector = Ogre::Vector3::ZERO;
00195 }
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330 void Camera::forceUpdate()
00331 {
00332 m_targetNode->pitch(m_pitch);
00333 m_targetNode->yaw(m_yaw, Ogre::Node::TS_WORLD);
00334 }
00335
00336 void Camera::setCurrentSpeed(const Ogre::Real& _val)
00337 {
00338 m_currentSpeed = _val;
00339 }
00340
00341 Ogre::Real& Camera::getCurrentSpeed()
00342 {
00343 return m_currentSpeed;
00344 }
00345
00346 void Camera::setMoveSpeed(const Ogre::Real& _val)
00347 {
00348 m_moveSpeed = _val;
00349 }
00350
00351 Ogre::Real& Camera::getMoveSpeed()
00352 {
00353 return m_moveSpeed;
00354 }
00355
00356 void Camera::setRotateSpeed(const Ogre::Degree& _val)
00357 {
00358 m_rotateSpeed = _val;
00359 }
00360
00361 Ogre::Degree& Camera::getRotateSpeed()
00362 {
00363 return m_rotateSpeed;
00364 }
00365
00366 void Camera::setZoomAmount(const Ogre::Real& _val)
00367 {
00368 m_zoomAmount = _val;
00369 }
00370
00371 Ogre::Real& Camera::getZoomAmount()
00372 {
00373 return m_zoomAmount;
00374 }
00375
00376 void Camera::setZoomDist(const Ogre::Real& _val)
00377 {
00378 m_zoomDist = _val;
00379 }
00380
00381 Ogre::Real& Camera::getZoomDist()
00382 {
00383 return m_zoomDist;
00384 }
00385
00386 void Camera::setVector(const Ogre::Vector3& _val)
00387 {
00388 m_vector = _val;
00389 }
00390
00391 Ogre::Vector3& Camera::getVector()
00392 {
00393 return m_vector;
00394 }
00395
00396 void Camera::adjustYaw(const Ogre::Degree& _val)
00397 {
00398 m_yaw = m_yaw + _val;
00399 if (m_yaw.valueDegrees() > 160.0f) m_yaw = 160.0f;
00400 if (m_yaw.valueDegrees() < -160.0f) m_yaw = -160.0f;
00401 }
00402
00403 void Camera::setYaw(const Ogre::Degree& _val)
00404 {
00405 m_yaw = _val;
00406 }
00407
00408 Ogre::Degree& Camera::getYaw()
00409 {
00410 return m_yaw;
00411 }
00412
00413 void Camera::adjustPitch(const Ogre::Degree& _val)
00414 {
00415 m_pitch = m_pitch + _val;
00416 if (m_pitch.valueDegrees() > 80.0f) m_pitch = 80.0f;
00417 if (m_pitch.valueDegrees() < -80.0f) m_pitch = -80.0f;
00418 }
00419
00420 void Camera::setPitch(const Ogre::Degree& _val)
00421 {
00422 m_pitch = _val;
00423 }
00424
00425 Ogre::Degree& Camera::getPitch()
00426 {
00427 return m_pitch;
00428 }
00429
00430 void Camera::setPosition(const Ogre::Vector3& _val)
00431 {
00432 m_currentCameraPos = m_lastCameraPos = m_sceneNode->convertLocalToWorldPosition(_val);
00433 m_sceneNode->setPosition(_val);
00434 }
00435
00436 Ogre::Vector3 Camera::getPosition()
00437 {
00438 return m_sceneNode->getPosition();
00439 }
00440
00441 void Camera::setTargetPosition(const Ogre::Vector3& _val)
00442 {
00443 m_targetNode->setPosition(_val);
00444 }
00445
00446 Ogre::Vector3 Camera::getTargetPosition()
00447 {
00448 return m_targetNode->getPosition();
00449 }
00450
00451 void Camera::setTargetNode(Ogre::SceneNode* _val)
00452 {
00453 m_targetNode = _val;
00454 }
00455
00456 Ogre::SceneNode* Camera::getTargetNode()
00457 {
00458 return m_targetNode;
00459 }
00460
00461 void Camera::setSceneNode(Ogre::SceneNode* _val)
00462 {
00463 if (m_sceneNode != 0)
00464 {
00465 m_sceneNode->detachObject(m_camera);
00466 }
00467 if (_val != 0)
00468 {
00469 m_sceneNode = _val;
00470 m_sceneNode->attachObject(m_camera);
00471 }
00472 }
00473
00474 Ogre::SceneNode* Camera::getSceneNode()
00475 {
00476 return m_sceneNode;
00477 }
00478
00479 void Camera::zoomIn()
00480 {
00481 m_zoomAmount *= 0.9;
00482 }
00483
00484 void Camera::zoomOut()
00485 {
00486 m_zoomAmount *= 1.1;
00487 }
00488
00489 void Camera::setFollowNode(Ogre::SceneNode* _val)
00490 {
00491 if (_val == 0)
00492 {
00493 getTargetNode()->getParentSceneNode()->removeChild(getTargetNode()->getName());
00494 Application::getSingleton()->getViewerManager()->getRootSceneNode()->addChild(getTargetNode());
00495 setYaw(Ogre::Degree(0.0f));
00496 setPitch(Ogre::Degree(0.0f));
00497 setState(CAMERA_FREE);
00498 }
00499 else
00500 {
00501 if (_val != getTargetNode()->getParentSceneNode())
00502 {
00503 getTargetNode()->getParentSceneNode()->removeChild(getTargetNode()->getName());
00504 _val->addChild(getTargetNode());
00505 setYaw(Ogre::Degree(0.0f));
00506 setPitch(Ogre::Degree(0.0f));
00507 setState(CAMERA_CHASE);
00508
00509 m_currentDirection = Ogre::Vector3::ZERO;
00510
00511 if (Ogre::any_cast<SelectableObject*>(_val->getUserAny()))
00512 {
00513 SelectableObject* target = Ogre::any_cast<SelectableObject*>(_val->getUserAny());
00514 if (target->getPhysical())
00515 {
00516 if (target->getRigidBody()->getLinearVelocity().squaredLength() > 1.0f)
00517 {
00518 m_currentDirection = target->getRigidBody()->getLinearVelocity().normalisedCopy();
00519 }
00520 }
00521 }
00522
00523
00524 if (m_currentDirection == Ogre::Vector3::ZERO)
00525 {
00526 Ogre::Quaternion targetOrientation = _val->getOrientation();;
00527 Ogre::Matrix3 matrix;
00528 targetOrientation.ToRotationMatrix(matrix);
00529 m_currentDirection = -matrix.GetColumn(2);
00530 }
00531
00532
00533 m_currentCameraPos = m_lastCameraPos = _val->convertLocalToWorldPosition(Ogre::Vector3(0.0f,10.0f,-10.0f));
00534 }
00535 }
00536 }
00537
00538 void Camera::setState(camState _val)
00539 {
00540 m_cameraState = _val;
00541 }