void OgreWidget::mouseMoveEvent(QMouseEvent * e)
{
if (m_oldPos != InvalidMousePoint)
{
Ogre::Real deltaX = e->pos().x() - m_oldPos.x();
Ogre::Real deltaY = e->pos().y() - m_oldPos.y();
if (m_mouseButtonsPressed.testFlag(Qt::MiddleButton))
{
if(e->modifiers().testFlag(Qt::ControlModifier))
m_camera->zoom(-deltaY);
else if (e->modifiers().testFlag(Qt::ShiftModifier))
m_camera->rotate(deltaX, -deltaY);
else
m_camera->shift(-deltaX, -deltaY);
}
else if (m_mouseButtonsPressed.testFlag(Qt::LeftButton) && !m_selectionManager.isEmpty())
{
if (m_constraintedX && e->modifiers().testFlag(Qt::ShiftModifier))
m_selectionManager.pitch(Ogre::Degree(deltaX));
else if (m_constraintedY && e->modifiers().testFlag(Qt::ShiftModifier))
m_selectionManager.yaw(Ogre::Degree(deltaX));
else if (m_constraintedZ && e->modifiers().testFlag(Qt::ShiftModifier))
m_selectionManager.roll(Ogre::Degree(deltaX));
else
{
Ogre::Plane plane;
if (m_constraintedX)
plane.redefine(Ogre::Vector3(1, 0, 0), m_selectionManager.getPosition());
else if (m_constraintedY)
plane.redefine(Ogre::Vector3(0, 1, 0), m_selectionManager.getPosition());
else if (m_constraintedZ)
plane.redefine(Ogre::Vector3(0, 0, 1), m_selectionManager.getPosition());
Ogre::Ray oldRay = m_camera->getCamera()->getCameraToViewportRay(e->pos().x() / (float)width(), e->pos().y() / (float)height());
Ogre::Ray ray = m_camera->getCamera()->getCameraToViewportRay(m_oldPos.x() / (float)width(), m_oldPos.y() / (float)height());
std::pair<bool, Ogre::Real> oldResult = oldRay.intersects(plane);
std::pair<bool, Ogre::Real> result = ray.intersects(plane);
if (result.first && oldResult.first)
{
Ogre::Vector3 point;
point = oldRay.getPoint(oldResult.second) - ray.getPoint(result.second);
m_selectionManager.translate(point.x, point.y, point.z);
}
}
emit itemMoved();
}
m_oldPos = e->pos();
update();
e->accept();
}
else
{
e->ignore();
}
}
bool InteractiveMarkerControl::intersectSomeYzPlane( const Ogre::Ray& mouse_ray,
const Ogre::Vector3& point_on_plane,
const Ogre::Quaternion& plane_orientation,
Ogre::Vector3& intersection_3d,
Ogre::Vector2& intersection_2d,
float& ray_t )
{
Ogre::Vector3 normal = plane_orientation * control_orientation_.xAxis();
Ogre::Vector3 axis_1 = plane_orientation * control_orientation_.yAxis();
Ogre::Vector3 axis_2 = plane_orientation * control_orientation_.zAxis();
Ogre::Plane plane(normal, point_on_plane);
Ogre::Vector2 origin_2d(point_on_plane.dotProduct(axis_1), point_on_plane.dotProduct(axis_2));
std::pair<bool, Ogre::Real> intersection = mouse_ray.intersects(plane);
if (intersection.first)
{
intersection_3d = mouse_ray.getPoint(intersection.second);
intersection_2d = Ogre::Vector2(intersection_3d.dotProduct(axis_1), intersection_3d.dotProduct(axis_2));
intersection_2d -= origin_2d;
ray_t = intersection.second;
return true;
}
ray_t = 0;
return false;
}
//-------------------------------------------------------------------------------
bool CEditableMeshEditor::_pickVertex(Ogre::Ray& ray)
{
Ogre::Real distance = 999999.0f;
mCurrentVertex = 0;
Ogre::Vector3 nodePos = mHandle->_getDerivedPosition();
Ogre::Vector3 vertexPos;
for(unsigned int i = 0;i < mVertexes.size();i++)
{
vertexPos = nodePos + mVertexes[i];
Ogre::AxisAlignedBox box(vertexPos.x - 0.1f, vertexPos.y - 0.1f, vertexPos.z - 0.1f, vertexPos.x + 0.1f, vertexPos.y + 0.1f, vertexPos.z + 0.1f);
std::pair<bool, Ogre::Real> result = ray.intersects(box);
if(result.first && result.second < distance)
{
distance = result.second;
mCurrentVertex = &(mVertexes[i]);
}
}
if(distance < 999999.0f)
return true;
return false;
}
void GodRaysManager::_updateProjector()
{
const Ogre::Vector3& SunPosition = mHydrax->getSunPosition();
const Ogre::Vector3& CameraPosition = mHydrax->getCamera()->getDerivedPosition();
Ogre::Plane WaterPlane = Ogre::Plane(Ogre::Vector3(0, 1, 0), mHydrax->getPosition());
Ogre::Ray SunToCameraRay = Ogre::Ray(SunPosition, CameraPosition - SunPosition);
Ogre::Vector3 WaterProjectionPoint = SunToCameraRay.getPoint(SunToCameraRay.intersects(WaterPlane).second);
Ogre::Vector3 WaterPosition = Ogre::Vector3(WaterProjectionPoint.x, mHydrax->getHeigth(WaterProjectionPoint), WaterProjectionPoint.z);
mProjectorSN->setPosition(WaterProjectionPoint);
mProjectorCamera->setFarClipDistance((WaterProjectionPoint - CameraPosition).length());
mProjectorSN->setDirection(-(WaterProjectionPoint - CameraPosition).normalisedCopy(), Ogre::Node::TS_WORLD);
}
//-------------------------------------------------------
std::pair<bool, Ogre::Vector3> Ground::GetIntersectionLocalSpace(const Ogre::Ray & ray) const
{
if (ray.intersects(mGlobalBoundingBox).first)
{
float intersection = -1.0f;
for (const auto & region : mEntities)
{
auto hit = ray.intersects(region->getBoundingBox());
if (hit.first)
{
auto meshHit = GetVertexIntersection(ray, region->getMesh()->getSubMesh(0));
if (meshHit.first && (intersection < 0.0f || meshHit.second < intersection))
{
intersection = meshHit.second;
}
}
}
if (intersection >= 0.0f)
{
return std::make_pair(true, ray.getPoint(intersection));
}
}
return std::make_pair(false, Ogre::Vector3::ZERO);
}
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;
}
Vector3 TransformInventoryUtil::getOriginPositionPlane()
{
Camera* player_camera = GameFramework::getSingletonPtr()->camera;
Plane far_plane = player_camera->getFrustumPlane(1);
float x_percent = 0.5; //((float)x / player_camera->getViewport()->getActualWidth());
float y_percent = 0.5; //((float)y / player_camera->getViewport()->getActualHeight());
Ogre::Ray ray = player_camera->getCameraToViewportRay(x_percent, y_percent);
std::pair<bool, Real> result = ray.intersects(far_plane);
if (result.first)
{
Vector3 origin_plane = /*ray.getOrigin() + ray.getDirection() * 1000*/ray.getPoint(result.second * 0.9);
return origin_plane;
}
return Vector3::ZERO;
}
void ClientGame::UpdateTileUnderCursor(Ogre::Ray aRay)
{
Ogre::Real radius = mTiles[0]->GetPosition().length();
Ogre::Sphere sphere(Ogre::Vector3::ZERO, radius);
std::pair<bool, Ogre::Real> res = aRay.intersects(sphere);
if (res.first)
{
Ogre::Vector3 position(aRay.getPoint(res.second));
mTileUnderCursor = mTileUnderCursor->GetTileAtPosition(position);
if (mSelectionMarker->getParent())
{
mSelectionMarker->getParent()->removeChild(mSelectionMarker);
}
if (mTileUnderCursor->GetTile())
{
mTileUnderCursor->GetTile()->GetNode().addChild(mSelectionMarker);
}
}
mSelectionMarker->setVisible(res.first);
}
void HeadsUpDisplay::tick(Ogre::Real timeDelta)
{
// window dimensions may have changed
Application &app = Application::getSingleton();
Ogre::Real windowWidth = (Ogre::Real)app.getWindowWidth();
Ogre::Real windowHeight = (Ogre::Real)app.getWindowHeight();
// get mouse cursor and update absolute position from relative change
OIS::Mouse *mouse = app.getMouse();
if (mouse != nullptr)
{
OIS::MouseState mouseState = mouse->getMouseState();
m_cursorX += mouseState.X.rel;
m_cursorY += mouseState.Y.rel;
m_cursorX = Math::clamp(m_cursorX, 0, windowWidth);
m_cursorY = Math::clamp(m_cursorY, 0, windowHeight);
// normalize cursor position and size from 0 to 1
Ogre::Real cursorX = m_cursorX / windowWidth;
Ogre::Real cursorY = m_cursorY / windowHeight;
m_cursorContainer->setPosition(cursorX, cursorY);
m_cursorContainer->setWidth(CURSOR_WIDTH / windowWidth);
m_cursorContainer->setHeight(CURSOR_HEIGHT / windowHeight);
m_cursorContainer->show();
// project cursor ray into scene and get query results
if (!m_mouseLeftLastDown && mouseState.buttonDown(OIS::MouseButtonID::MB_Left))
{
Ogre::Ray mouseRay;
getCamera()->getCameraToViewportRay(cursorX, cursorY, &mouseRay);
m_rayQuery->setRay(mouseRay);
m_objectFound = false;
m_rayQuery->execute(this);
if (!m_objectFound && (m_currentSelection != nullptr))
{
// user selected nothing so clear current selection
m_currentSelection->onDeselect();
}
}
if ((m_currentSelection != nullptr) && !m_mouseRightLastDown && mouseState.buttonDown(OIS::MouseButtonID::MB_Right))
{
Ogre::Ray mouseRay;
getCamera()->getCameraToViewportRay(cursorX, cursorY, &mouseRay);
Ogre::Plane plane(Ogre::Vector3(0, 1, 0), Ogre::Vector3::ZERO);
auto intersectResult = mouseRay.intersects(plane);
if (intersectResult.first)
{
Ogre::Vector3 destination = mouseRay.getPoint(intersectResult.second);
m_currentSelection->onMoveOrder(destination);
}
}
m_mouseLeftLastDown = mouseState.buttonDown(OIS::MouseButtonID::MB_Left);
m_mouseRightLastDown = mouseState.buttonDown(OIS::MouseButtonID::MB_Right);
}
else
{
m_cursorContainer->hide();
}
}
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;
}
bool LagomPlayerBase::CheckHover(const Ogre::Ray& ray)
{
return ray.intersects( Ogre::Sphere(getIntFactory().ConstructionOffset, getIntFactory().ConstructingTriggerSize) ).first;
}