/** Find the closest point on target_ray to mouse_ray.
* @returns false if rays are effectively parallel, true otherwise.
*/
bool InteractiveMarkerControl::findClosestPoint( const Ogre::Ray& target_ray,
const Ogre::Ray& mouse_ray,
Ogre::Vector3& closest_point )
{
// Find the closest point on target_ray to any point on mouse_ray.
//
// Math taken from http://paulbourke.net/geometry/lineline3d/
// line P1->P2 is target_ray
// line P3->P4 is mouse_ray
Ogre::Vector3 v13 = target_ray.getOrigin() - mouse_ray.getOrigin();
Ogre::Vector3 v43 = mouse_ray.getDirection();
Ogre::Vector3 v21 = target_ray.getDirection();
double d1343 = v13.dotProduct( v43 );
double d4321 = v43.dotProduct( v21 );
double d1321 = v13.dotProduct( v21 );
double d4343 = v43.dotProduct( v43 );
double d2121 = v21.dotProduct( v21 );
double denom = d2121 * d4343 - d4321 * d4321;
if( fabs( denom ) <= Ogre::Matrix3::EPSILON )
{
return false;
}
double numer = d1343 * d4321 - d1321 * d4343;
double mua = numer / denom;
closest_point = target_ray.getPoint( mua );
return true;
}
VOID CEngineInterface::Camera_GetWindowToViewportRay(INT nX, INT nY, fRay& fRay)
{
Ogre::Ray ray = m_pFairySystem->getWindowToViewportRay(nX, nY);
fVector3 fGFX = fVector3(ray.getOrigin().x, ray.getOrigin().y, ray.getOrigin().z);
Axis_Trans(AX_GFX, fGFX, AX_GAME, fRay.mOrigin);
fRay.mDirection = fVector3(ray.getDirection().x, ray.getDirection().y, ray.getDirection().z);
}
void Selection3DDisplayCustom::raycastRequest(bool, int x, int y)
{
float win_width = render_panel_->width();
float win_height = render_panel_->height();
//then send a raycast straight out from the camera at the mouse's position
Ogre::Ray mouseRay = this->render_panel_->getCamera()->getCameraToViewportRay((float)x/win_width, (float)y/win_height);
// send ray data to other instances of OCS
publishOCSRayRequest(RAYCAST_SELECTION, mouseRay.getOrigin(), mouseRay.getDirection());
// send ray data to onboard
publishRayRequest(mouseRay.getOrigin(), mouseRay.getDirection());
}
//----------------------------------------------------------------------------------------
bool ObjectsViewWidget::OnDragMove(Ogre::Viewport *vp, unsigned int modifier, Ogre::Vector2& position)
{
if(mDragData.ObjectType == "")
return false;
if(!mDragData.Object)
return true;
Ogre::Ray mouseRay;
mouseRay = vp->getCamera()->getCameraToViewportRay(position.x, position.y);
Ogre::Vector3 vPos;
mDragData.Object->getProperties()->getValue("position", vPos);
bool hitfound = false;
if(modifier & Ogitors::DragDropShiftModifier)
{
hitfound = OgitorsRoot::getSingletonPtr()->GetViewport()->GetHitPosition(mouseRay, vPos, mDragData.Object->getName());
}
if(!hitfound)
{
if(vPos.x == 999999 && vPos.y == 999999 && vPos.z == 999999)
vPos = mouseRay.getOrigin() + (mouseRay.getDirection() * 40.0f);
else
vPos = OgitorsRoot::getSingletonPtr()->GetGizmoIntersectCameraPlane(mDragData.Object, mouseRay);
}
mDragData.Object->getProperties()->setValue("position", vPos);
return true;
}
gkCam2ViewportRay::gkCam2ViewportRay(gkScalar x, gkScalar y, gkScalar rayLength)
{
gkScene* pScene = gkEngine::getSingleton().getActiveScene();
GK_ASSERT(pScene);
gkCamera* pCamera = pScene->getMainCamera();
GK_ASSERT(pCamera);
gkVector2 pos(x, y);
gkWindow* pWindow = pScene->getDisplayWindow();
if (pWindow == 0)
pWindow = gkWindowSystem::getSingleton().getMainWindow();
GK_ASSERT(pWindow);
gkScalar width = pWindow->getWidth();
gkScalar height = pWindow->getHeight();
GK_ASSERT(width && height);
Ogre::Ray ray = pCamera->getCamera()->getCameraToViewportRay(pos.x / width, pos.y / height);
gkVector3 p0 = ray.getOrigin();
gkVector3 p1 = p0 + ray.getDirection() * rayLength;
setOrigin(p0);
setDirection(p1 - p0);
}
void OrientationControlet::injectMousePress(int _absx, int _absy, MyGUI::MouseButton _id)
{
if( _id == MyGUI::MouseButton::Left ){
string name = Game::getSingleton().pickMovableObject( _absx,_absy );
if( name == mName ){
mPick = true;
mMouseX = _absx;
mMouseY = _absy;
InputFilter::getSingleton().setCapture();
/*判断开始时候，控制球是在球的正面还是背面
*/
Game& game = Game::getSingleton();
int sx = game.getScreenWidth();
int sy = game.getScreenHeight();
Ogre::Ray B = game.getCamera()->getCameraToViewportRay(
(Ogre::Real)_absx/(Ogre::Real)sx,
(Ogre::Real)_absy/(Ogre::Real)sy
);
Ogre::Matrix3 m3 = mNode->getLocalAxes();
Ogre::Vector3 axis = m3.GetColumn(2);
if( axis.dotProduct(B.getDirection())>0 )
mNearFar = false;
else
mNearFar = true;
}
}
}
void InputListener::shootingMouvements(const Ogre::FrameEvent& evt)
{
if (this->_Game->getGun(this->_Game->getNextTeam()->getChoseGun()).getAfterEffect() == true)
{
if (this->_Game->getGun(this->_Game->getNextTeam()->getChoseGun()).afterEffect(evt.timeSinceLastFrame) == true)
{
this->changeTurn();
}
else
{
this->_Game->doDamageToWorms(this->_Game->
getGun(this->_Game->getNextTeam()->getChoseGun()).getExplosion(), this->_Game->
getGun(this->_Game->getNextTeam()->getChoseGun()).getScale() / 20);
}
}
else if (!this->_WormsApp->getSceneManager()->getScene("PlayScene")->getGame()
->getGun(this->_Game->getNextTeam()->getChoseGun()).getIsFree())
this->_Game->getGun(this->_Game->getNextTeam()->getChoseGun()).move(evt.timeSinceLastFrame, this->_CollisionMgr, this->_Game->getTeam());
if (this->_Mouse->getMouseState().buttonDown(OIS::MB_Left))
{
if (this->_Game->getTeleportActivated())
{
Ogre::Vector2 pos = this->_WormsApp->getUIManager()->teleportPressed();
pos.x = pos.x / this->_currentScene->getViewPort()->getActualWidth();
pos.y = pos.y / this->_currentScene->getViewPort()->getActualHeight();
Ogre::Ray ray = this->_currentScene->getCamera()->getCameraToViewportRay(pos.x, pos.y);
Ogre::Vector3 newRay= ray.getOrigin() + (ray.getDirection() * 3);
newRay.z = 0;
_current->getNode()->setPosition(newRay);
}
}
}
bool gkRayTest::collides(const Ogre::Ray& ray)
{
gkVector3 from = ray.getOrigin();
gkVector3 to = ray.getOrigin() + ray.getDirection();
gkRayTestFilter test;
return gkRayTest::collides(from, to,test);
}
// -------------------------------------------------------------------------
void OgreBulletListener::button1Pressed()
{
// small unique impulse under cursor.
Ogre::Vector3 pickPos;
Ogre::Ray rayTo;
OgreBulletDynamics::RigidBody * body =
getBodyUnderCursorUsingBullet(pickPos, rayTo);
//getBodyUnderCursorUsingOgre(pickPos, rayTo);
if (body)
{
if (!(body->isStaticObject()
|| body->isKinematicObject()
))
{
body->enableActiveState ();
const Ogre::Vector3 relPos (pickPos - body->getCenterOfMassPosition());
const Ogre::Vector3 impulse (rayTo.getDirection ());
body->applyImpulse (impulse * mImpulseForce, relPos);
}
getDebugLines();
mDebugRayLine->addLine (rayTo.getOrigin(), pickPos);
mDebugRayLine->draw();
}
}
void ProjectManager::onSelectActorAtClickpoint(float mouseX,
float mouseY)
{
assert(QThread::currentThread() == thread());
QOCamera* cameraNode = getCameraWithName("cam1");
if(!cameraNode)
{
qWarning("ProjectManager.onSelectActorAtClickpoint: Can't determine an actor to select "
"without a corresponding CameraNode.");
return;
}
Ogre::Camera* camera = cameraNode->camera();
if(!camera)
{
qWarning("ProjectManager.onSelectActorAtClickpoint: Can't determine an actor to select "
"without a corresponding ogre camera.");
return;
}
Ogre::Ray mouseRay = camera->getCameraToViewportRay(mouseX, mouseY);
Scene* current = mScenarioManager.getCurrentScene();
QSharedPointer<Actor> hitActor = current->raycast(mouseRay.getOrigin(),
mouseRay.getDirection()).actor.toStrongRef();
if(hitActor)
{
onActorChangeSelected(hitActor->getName(),
!hitActor->getSceneNode()->getShowBoundingBox());
}
}
std::pair<bool, Real>
doPicking(const Ogre::Ray& localRay, const CollisionModel& collisionModel, CullingMode cullingMode)
{
// Convert our ray to Opcode ray
IceMaths::Ray world_ray(
IceMaths::Point(localRay.getOrigin().x, localRay.getOrigin().y, localRay.getOrigin().z),
IceMaths::Point(localRay.getDirection().x, localRay.getDirection().y, localRay.getDirection().z));
// Be aware we store triangle as ccw in collision mode, and Opcode treat it as cw,
// so need to inverse cull mode here.
Opcode::CullMode cullMode;
switch (cullingMode)
{
default:
case CULL_NONE:
cullMode = Opcode::CULLMODE_NONE;
break;
case CULL_CLOCKWISE:
cullMode = Opcode::CULLMODE_CCW;
break;
case CULL_ANTICLOCKWISE:
cullMode = Opcode::CULLMODE_CW;
break;
}
// Cull mode callback for Opcode
struct Local
{
static Opcode::CullMode cullModeCallback(udword triangle_index, void* user_data)
{
return (Opcode::CullMode) (int) user_data;
}
};
std::pair<bool, Real> ret;
// Do picking
Opcode::CollisionFace picked_face;
ret.first = Opcode::Picking(picked_face,
world_ray, collisionModel.getOpcodeModel(), 0,
0, FLT_MAX,
world_ray.mOrig,
&Local::cullModeCallback, (void*) (int) cullMode);
ret.second = ret.first ? picked_face.mDistance : 0;
return ret;
}
Ogre::Ray OgreMesh::transformRay(Ogre::Node *node, const Ogre::Ray &ray) {
return ray;
const Ogre::Vector3 &position = node->_getDerivedPosition();
const Ogre::Quaternion &orient = node->_getDerivedOrientation();
const Ogre::Vector3 &scale = node->_getDerivedScale();
Ogre::Vector3 newStart = (orient.Inverse() * (ray.getOrigin() - position)) / scale;
Ogre::Vector3 newDirection = orient.Inverse() * ray.getDirection();
return Ogre::Ray(newStart, newDirection);
}
bool Panel::injectMouseMoved(const Ogre::Ray& ray)
{
Ogre::Matrix4 transform;
transform.makeTransform(mNode->getPosition(), mNode->getScale(), mNode->getOrientation());
Ogre::AxisAlignedBox aabb = mScreenRenderable->getBoundingBox();
aabb.transform(transform);
pair<bool, Ogre::Real> result = Ogre::Math::intersects(ray, aabb);
if (result.first == false)
{
unOverAllElements();
return false;
}
Ogre::Vector3 a,b,c,d;
Ogre::Vector2 halfSize = (mSize/100) * 0.5f;
a = transform * Ogre::Vector3(-halfSize.x,-halfSize.y,0);
b = transform * Ogre::Vector3( halfSize.x,-halfSize.y,0);
c = transform * Ogre::Vector3(-halfSize.x, halfSize.y,0);
d = transform * Ogre::Vector3( halfSize.x, halfSize.y,0);
result = Ogre::Math::intersects(ray, c, b, a);
if (result.first == false)
result = Ogre::Math::intersects(ray, c, d, b);
if (result.first == false)
{
unOverAllElements();
return false;
}
if (result.second > mDistanceFromPanelToInteractWith)
{
unOverAllElements();
return false;
}
Ogre::Vector3 hitPos = (ray.getOrigin() + (ray.getDirection() * result.second));
Ogre::Vector3 localPos = transform.inverse() * hitPos;
localPos.x += halfSize.x;
localPos.y -= halfSize.y;
localPos.x *= 100;
localPos.y *= 100;
// Cursor clip
localPos.x = Ogre::Math::Clamp<Ogre::Real>(localPos.x, 0, mSize.x - 10);
localPos.y = Ogre::Math::Clamp<Ogre::Real>(-localPos.y, 0, mSize.y - 18);
mInternalMousePos = Ogre::Vector2(localPos.x, localPos.y);
mMousePointer->position(mInternalMousePos);
// Let's actualize the "over" for each elements
for (size_t i=0; i < mPanelElements.size(); i++)
mPanelElements[i]->isOver(mInternalMousePos);
return true;
}
void CameraDragMove::_onDrag(const Point& pt)
{
if (!mTerrainHitInfo.hitted)
return;
Ogre::Ray ray = getSceneManipulator()->getWindowToViewportRay(pt);
if (!ray.getDirection().y)
return;
Ogre::Vector3 newPosition;
// 对正交投影和透视投影分开处理
if (getSceneManipulator()->getCamera()->getProjectionType() == Ogre::PT_ORTHOGRAPHIC)
{
Real offsetx = mRay.getOrigin().x - ray.getOrigin().x;
Real offsetz = mRay.getOrigin().z - ray.getOrigin().z;
newPosition.x = getSceneManipulator()->getCamera()->getRealPosition().x + offsetx;
newPosition.y = getSceneManipulator()->getCamera()->getRealPosition().y;
newPosition.z = getSceneManipulator()->getCamera()->getRealPosition().z + offsetz;
}
else
{
Real length = (mTerrainHitInfo.position.y - mTerrainHitInfo.hitPosition.y) / ray.getDirection().y;
newPosition = mTerrainHitInfo.hitPosition + ray.getDirection() * length;
if (getSceneManipulator()->getCameraHeightLocked())
{
newPosition.y +=
getTerrainData()->getHeightAt(newPosition.x, newPosition.z) -
getTerrainData()->getHeightAt(mTerrainHitInfo.position.x, mTerrainHitInfo.position.z);
}
}
getSceneManipulator()->setCameraPosition(newPosition);
}
// -------------------------------------------------------------------------
void OgreBulletListener::mouseMoved()
{
mGuiListener->setMousePosition(mInputListener->getAbsMouseX (), mInputListener->getAbsMouseY ());
if (mPickConstraint)
{
// dragging
//add a point to point constraint for picking
Ogre::Ray rayTo = mCamera->getCameraToViewportRay (mInputListener->getAbsMouseX(), mInputListener->getAbsMouseY());
//move the constraint pivot
OgreBulletDynamics::PointToPointConstraint * p2p = static_cast <OgreBulletDynamics::PointToPointConstraint *>(mPickConstraint);
//keep it at the same picking distance
const Ogre::Vector3 eyePos(mCamera->getDerivedPosition());
//Ogre::Vector3 dir = rayTo.getDirection () - eyePos;
//dir.normalise();
//dir *= mOldPickingDist;
Ogre::Vector3 dir = rayTo.getDirection () * mOldPickingDist;
dir.normalise();
const Ogre::Vector3 newPos (eyePos + dir);
p2p->setPivotB (newPos);
setDebugText ("Dragging");
getDebugLines();
mDebugRayLine->addLine (mPickedBody->getWorldPosition (), newPos);
mDebugRayLine->draw();
mGuiListener->showMouse();
}
if (mGuiListener->getGui()->injectMouse(mInputListener->getAbsMouseX ()*mWindow->getWidth(),
mInputListener->getAbsMouseY ()*mWindow->getHeight(), mInputListener->getButton0Pressed()))
{
mGuiListener->hideMouse();
}
else
{
mGuiListener->showMouse();
}
if (mInputListener->getButton2Pressed())
{
mCameraRotX = Degree(-mInputListener->getRelMouseX () * 0.13);
mCameraRotY = Degree(-mInputListener->getRelMouseY () * 0.13);
}
}
/**
* Calcula dirección del disparo
*/
Vector3 StandLatas::calculateDirShoot() {
Vector3 dirShoot;
_rayScnQuery->setSortByDistance(true);
_rayScnQuery->setQueryMask(COL_STAND|COL_CAN);
Ogre::Ray ray = _camera->
getCameraToViewportRay(_mousex/float(1024),
_mousey/float(768));
dirShoot = ray.getDirection();
std::cout << "Factor de Potencia "<< (_timeLoadingShoot/0.1) << " tiempo Pulsado " <<_timeLoadingShoot << std::endl;
return dirShoot*(_timeLoadingShoot/0.05);
}
bool
GenericMousePicker::cast(
const OIS::MouseEvent &e,
const CEGUI::Point& mousePos,
const Ogre::Camera *mCamera,
Ogre::MovableObject **out,
Ogre::uint32 mask)
{
Ogre::Ray mouseRay =
mCamera->getCameraToViewportRay(
mousePos.d_x/float(e.state.width),
mousePos.d_y/float(e.state.height)
);
return cast(mouseRay.getOrigin(), mouseRay.getDirection(), out, mask);
}
void AIRayPathFinderStrategy::CalcLines(Ogre::Ray &line)
{
Vector3 start;
Vector3 direction = line.getDirection();
Ogre::Quaternion quat;
for (int i=0;i<LinesNumber-1;++i)
{
start = LineOrigins[i];
quat = start.getRotationTo(direction);
start = quat*start; //matr.rotateVect(lines[i].start);
Lines[i].setOrigin(start+line.getOrigin()); //lines[i].start += line.start;
Lines[i].setDirection(start+direction); //lines[i].end = lines[i].start+v;
}
Lines[LinesNumber-1] = line;
}
void NxOgreSample_SoftBodyApp::frameRenderingQueued(const Ogre::FrameEvent &evt)
{
mWorld->advance(evt.timeSinceLastFrame);
if (mSelectedVertex != -1)
{
Ogre::Vector2 point(CEGUI::MouseCursor::getSingleton().getPosition().d_x/mWindow->getWidth(),CEGUI::MouseCursor::getSingleton().getPosition().d_y/mWindow->getHeight());
Ogre::Ray ogreRay = mCameraMan->getCamera()->getCameraToViewportRay(point.x,point.y);
NxOgre::Ray nxRay;
nxRay.mDirection.from(ogreRay.getDirection());
nxRay.mOrigin.from(ogreRay.getOrigin());
NxVec3 vec3 = (nxRay.mOrigin + 45 * nxRay.mDirection).as<NxVec3>();
mSoftBody->getPhysXSoftBody()->attachVertexToGlobalPosition(mSelectedVertex,vec3);
}
}
//-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
Math::Ray
Camera::getViewportRay(int _x, int _y)
{
// Convert the values to Real
Ogre::Real x((Ogre::Real)_x);
Ogre::Real y((Ogre::Real)_y);
// Normalise them based on the size of the screen.
x = x / m_canvas.getWidth();
y = y / m_canvas.getHeight();
const Ogre::Ray ray = m_camera.getCameraToViewportRay(x, y);
return Math::Ray(
Math::Point3(ray.getOrigin().ptr()),
Math::Vector3(ray.getDirection().ptr())
);
}
void SkyStar::followMouseRay(const Ogre::Ray& mouseRay)
{
std::pair<bool, Real> intersectPlane = Math::intersects(mouseRay, *_waterPlane);
if (!intersectPlane.first)
{
std::pair<bool, Real> intersectR = Math::intersects(mouseRay, *_skyPlane);
Vector3 pos = mouseRay.getOrigin() + mouseRay.getDirection() * intersectR.second;
if (pos.x < -50)
pos.x = -50;
if (pos.x > 50)
pos.x = 50;
if (pos.z > 50)
pos.z = 50;
if (pos.z < -50)
pos.z = - 50;
_node->_setDerivedPosition(pos);
}
}
void OrbitCamera( ::Ogre::Camera* a_pCam, const::Ogre::Sphere& a_subjSphr,
const Ogre::Vector2& a_curTouch, const Ogre::Vector2& a_oldTouch )
{
const ::Ogre::Vector3& center = a_subjSphr.getCenter() ;
const ::Ogre::Vector3& camPos = a_pCam->getPosition() ;
// gets the current looked-at point.
const ::Ogre::Vector3 camDir = a_pCam->getDirection().normalisedCopy() ;
const ::Ogre::Vector3 lookAt = camDir.dotProduct(center - camPos) * camDir + camPos ;
// makes the ray from the subjet's center to the camera.
const ::Ogre::Ray rayToCam( center, (camPos - center).normalisedCopy() ) ;
// makes the tangent plane to the sphere whose normal is toward the camera.
::Ogre::Real fDist = center.distance( camPos ) ;
if( a_subjSphr.getRadius() < fDist )
fDist = a_subjSphr.getRadius() ;
const ::Ogre::Plane touchPlane( rayToCam.getDirection(), fDist ) ;
// gets the touch points on the plane.
::Ogre::Ray ray ;
a_pCam->getCameraToViewportRay( a_curTouch.x, a_curTouch.y, &ray ) ;
const ::Ogre::Vector3 curPoint = ray.getPoint( ray.intersects( touchPlane ).second ) ;
a_pCam->getCameraToViewportRay( a_oldTouch.x, a_oldTouch.y, &ray ) ;
const ::Ogre::Vector3 oldPoint = ray.getPoint( ray.intersects( touchPlane ).second ) ;
// gets the quaternion.
const ::Ogre::Quaternion qtnn = (curPoint - center).getRotationTo( oldPoint - center ) ;
// gets the new camera position.
::Ogre::Vector3 newCamPos = camPos - center ;
newCamPos = qtnn * newCamPos ;
newCamPos += center ;
// gest the new look-at.
::Ogre::Vector3 newLookAt = lookAt - center ;
newLookAt = qtnn * newLookAt ;
newLookAt += center ;
// sets the camera to the new properties.
a_pCam->setPosition( newCamPos ) ;
a_pCam->lookAt( newLookAt ) ;
}
bool XYOrbitViewController::intersectGroundPlane( Ogre::Ray mouse_ray, Ogre::Vector3 &intersection_3d )
{
//convert rays into reference frame
mouse_ray.setOrigin( target_scene_node_->convertWorldToLocalPosition( mouse_ray.getOrigin() ) );
mouse_ray.setDirection( target_scene_node_->convertWorldToLocalOrientation( Ogre::Quaternion::IDENTITY ) * mouse_ray.getDirection() );
Ogre::Plane ground_plane( Ogre::Vector3::UNIT_Z, 0 );
std::pair<bool, Ogre::Real> intersection = mouse_ray.intersects(ground_plane);
if (!intersection.first)
{
return false;
}
intersection_3d = mouse_ray.getPoint(intersection.second);
return true;
}
ray::ray(const Ogre::Ray &vec)
: mOrigin(vec.getOrigin())
, mDirection(vec.getDirection())
{
;
}
bool NxOgreSample_SoftBodyApp::mousePressed(const OIS::MouseEvent &arg, OIS::MouseButtonID id)
{
if (arg.state.buttonDown(OIS::MB_Left))
{
if (mSelectedVertex != -1)
{
mSoftBody->getPhysXSoftBody()->freeVertex(mSelectedVertex);
mSelectedVertex = -1;
}
Ogre::Vector2 point(arg.state.X.abs,arg.state.Y.abs);
Ogre::Ray ogreRay = mCameraMan->getCamera()->getCameraToViewportRay(point.x/arg.state.width,point.y/arg.state.height);
NxRay nxRay(NxVec3(ogreRay.getOrigin().x,ogreRay.getOrigin().y,ogreRay.getOrigin().z),NxVec3(ogreRay.getDirection().x,ogreRay.getDirection().y,ogreRay.getDirection().z));
NxVec3 hit;
if (!mSoftBody->getPhysXSoftBody()->raycast(nxRay,hit,mSelectedVertex))
mSelectedVertex = -1;
}
return true;
}
std::pair<bool, Real>
rayCollide(const Ogre::Ray& ray,
Ogre::MovableObject* movable,
bool accurate,
CullingMode cullingMode,
bool allowAnimable)
{
// Get local space axis aligned bounding box
const Ogre::AxisAlignedBox& aabb = movable->getBoundingBox();
// Matrix4 to transform local space to world space
const Ogre::Matrix4& localToWorld = movable->_getParentNodeFullTransform();
// Matrix4 to transform world space to local space
Ogre::Matrix4 worldToLocal = localToWorld.inverse();
// Matrix3 to transform world space normal to local space
Ogre::Matrix3 worldToLocalN;
worldToLocal.extract3x3Matrix(worldToLocalN);
// Convert world space ray to local space ray
// Note:
// By preserving the scale between world space and local space of the
// direction, we don't need to recalculate the distance later.
Ogre::Ray localRay;
localRay.setOrigin(worldToLocal * ray.getOrigin());
localRay.setDirection(worldToLocalN * ray.getDirection());
// Intersect with axis aligned bounding box, but because we transformed
// ray to local space of the bounding box, so this test just like test
// with oriented bounding box.
std::pair<bool, Real> ret = localRay.intersects(aabb);
// Do accurate test if hitted bounding box and user required.
if (ret.first && accurate)
{
if (movable->getMovableType() == Ogre::EntityFactory::FACTORY_TYPE_NAME ||
allowAnimable && movable->getMovableType() == Ogre::AutoAnimationEntityFactory::FACTORY_TYPE_NAME)
{
Ogre::Entity* entity = static_cast<Ogre::Entity*>(movable);
if (!entity->_isAnimated())
{
// Static entity
// Get the entity mesh
const Ogre::MeshPtr& mesh = entity->getMesh();
// Get the collision mode
CollisionModelPtr collisionModel = CollisionModelManager::getSingleton().getCollisionModel(mesh);
ret = doPicking(localRay, *collisionModel, cullingMode);
}
else if (allowAnimable)
{
// Animation entity
bool addedSoftwareAnimation = false;
if (entity->getSoftwareAnimationRequests() <= 0)
{
entity->addSoftwareAnimationRequest(false);
entity->_updateAnimation();
addedSoftwareAnimation = true;
}
CollisionModel collisionModel;
collisionModel.addEntity(entity);
collisionModel.build(true);
ret = doPicking(localRay, collisionModel, cullingMode);
if (addedSoftwareAnimation)
{
entity->removeSoftwareAnimationRequest(false);
}
}
}
}
return ret;
}
void gkPickNode::CreatePick()
{
ReleasePick();
Ogre::Ray ray = GetRay();
gkRayTest rayTest;
if (rayTest.collides(ray))
{
const btCollisionObject* pCol = rayTest.getCollisionObject();
gkPhysicsController* pObj = static_cast<gkPhysicsController*>(pCol->getUserPointer());
m_pickedBody = dynamic_cast<gkRigidBody*>(pObj);
if (m_pickedBody && !(pCol->isStaticObject() || pCol->isKinematicObject()))
{
btRigidBody* body = m_pickedBody->getBody();
m_angularFactor = gkVector3(body->getAngularFactor());
if (GET_SOCKET_VALUE(DISABLE_ROTATION))
{
body->setAngularFactor(0);
}
m_activationState = body->getActivationState();
body->setActivationState(DISABLE_DEACTIVATION);
const gkVector3& hitPointWorld = rayTest.getHitPoint();
btVector3 hitPos(hitPointWorld.x, hitPointWorld.y, hitPointWorld.z);
btVector3 localPivot = body->getCenterOfMassTransform().inverse() * hitPos;
m_constraint = new btPoint2PointConstraint(*body, localPivot);
static btScalar mousePickClamping = 30.f;
m_constraint->m_setting.m_impulseClamp = mousePickClamping;
btDynamicsWorld* pWorld = m_scene->getDynamicsWorld()->getBulletWorld();
GK_ASSERT(pWorld);
pWorld->addConstraint(m_constraint, false);
Vector3 from = ray.getOrigin();
Vector3 to = ray.getOrigin() + ray.getDirection();
btVector3 rayFrom(from.x, from.y, from.z);
btVector3 rayTo(to.x, to.y, to.z);
//save mouse position for dragging
m_oldPickingPos = rayTo;
m_oldPickingDist = (hitPos - rayFrom).length();
//very weak constraint for picking
m_constraint->m_setting.m_tau = 0.1f;
SET_SOCKET_VALUE(PICKED_OBJ, m_pickedBody->getObject());
SET_SOCKET_VALUE(CAUGHT_TRUE, true);
SET_SOCKET_VALUE(CAUGHT_FALSE, false);
}
else
{
m_pickedBody = 0;
}
}
}
bool
PolyMousePicker::cast(
const OIS::MouseEvent &e,
const CEGUI::Point& mousePos,
const Ogre::Camera *mCamera,
Ogre::MovableObject **out,
Ogre::uint32 mask)
{
using Ogre::Vector2;
using Ogre::Vector3;
std::map<Ogre::MovableObject*, int> objects;
// cast 9 rays against every point in the box
// and return the object that got the most hits
for (int i=0; i < 9; ++i)
{
Ogre::Ray mRay =
mCamera->getCameraToViewportRay(
(mousePos.d_x + mCorners[i].x)/float(e.state.width),
(mousePos.d_y + mCorners[i].y)/float(e.state.height)
);
//~ Ogre::Ray mRay(
//~ Vector3(inOrigin.x + mCorners[i].x, inOrigin.y + mCorners[i].y, inOrigin.z),
//~ inDirection);
Ogre::Vector3 resultPoint;
Ogre::MovableObject* resultObj = 0;
bool result =
RaycastFromPoint(
mRay.getOrigin(),
mRay.getDirection(),
resultPoint,
&resultObj,
mask);
if (result)
{
if (objects.find(resultObj) == objects.end())
objects.insert(std::make_pair(resultObj, 1));
else
objects.find(resultObj)->second++;
}
}
if (objects.empty())
return false;
// find the best hit
int max = 0;
Ogre::MovableObject* bestHit = 0;
for (std::map<Ogre::MovableObject*, int>::const_iterator object = objects.begin();
object != objects.end();
++object)
{
if (object->second > max)
{
max = object->second;
bestHit = object->first;
}
}
(*out) = bestHit;
return true;
}