/** 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; }