bool Renderer::RaycastPickScreen(const Vec2& screenPosition, float depth, Camera* camera,
RendererRaycastResult& result)
{
// Set up the ray query object
Ogre::Camera* ogreCamera = camera->GetOgreCamera();
Ogre::Ray ray = ogreCamera->getCameraToViewportRay(screenPosition.x, screenPosition.y);
mRaySceneQuery->setRay(ray);
mRaySceneQuery->setQueryMask(~UNIVERSE_OBJECT);
// Execute the ray query
Ogre::RaySceneQueryResult& rayQuery = mRaySceneQuery->execute();
for (auto i = rayQuery.begin(); i != rayQuery.end(); ++i)
{
Ogre::Entity* entity = dynamic_cast<Ogre::Entity*>((*i).movable);
if (entity && (*i).distance > 0.0f)
{
result.hit = true;
result.entity = entity;
result.position = Position::FromCameraSpace(camera, ray.getPoint((*i).distance));
result.normal = Vec3::zero;
return true;
}
}
// At this point - the ray didn't hit anything of interest
result.hit = false;
result.entity = nullptr;
result.position = Position::FromCameraSpace(camera, ray.getPoint(depth));
result.normal = Vec3::zero;
return false;
}
bool gkMouseSensor::rayTest(void)
{
// cannot test no movable data,
if (m_type == MOUSE_MOUSE_OVER && (m_object->getType() == GK_OBJECT || m_object->getType() == GK_SKELETON))
return false;
GK_ASSERT(m_object);
gkCamera* cam = m_object->getOwner()->getMainCamera();
Ogre::Camera* oc = cam->getCamera();
gkMouse* mse = gkWindowSystem::getSingleton().getMouse();
gkScalar ncx = mse->position.x / mse->winsize.x;
gkScalar ncy = mse->position.y / mse->winsize.y;
Ogre::Ray dest;
oc->getCameraToViewportRay(ncx, ncy, &dest);
if (m_rayQuery == 0)
{
Ogre::SceneManager* mgr = m_object->getOwner()->getManager();
m_rayQuery = mgr->createRayQuery(dest);
}
else m_rayQuery->setRay(dest);
// do the test
Ogre::RaySceneQueryResult& res = m_rayQuery->execute();
bool result = false;
for (Ogre::RaySceneQueryResult::iterator it = res.begin(); it != res.end(); ++it)
{
Ogre::RaySceneQueryResultEntry ent = (*it);
if (ent.movable == oc)
continue;
if (ent.movable)
{
if (m_type == MOUSE_MOUSE_OVER)
{
if (ent.movable == m_object->getMovable())
{
result = true;
break;
}
}
else
{
result = true;
break;
}
}
}
return result;
}
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());
}
}
//-----------------------------------------------------------------------------------------
void CPGInstanceManager::OnMouseLeftDown (CViewportEditor *viewport, Ogre::Vector2 point, unsigned int buttons)
{
Ogre::Camera *cam = viewport->getCameraEditor()->getCamera();
Ogre::Viewport *vp = static_cast<Ogre::Viewport*>(viewport->getHandle());
float width = vp->getActualWidth();
float height = vp->getActualHeight();
Ogre::Ray mRay = cam->getCameraToViewportRay(point.x / width, point.y / height);
Ogre::Vector3 vPos;
if(viewport->GetHitPosition(mRay, vPos))
{
float yaw = (mMaxYaw->get() - mMinYaw->get()) * Ogre::Math::UnitRandom() + mMinYaw->get();
float scale = (mMaxScale->get() - mMinScale->get()) * Ogre::Math::UnitRandom() + mMinScale->get();
int index = addInstance(vPos, scale, yaw);
OgitorsUndoManager::getSingletonPtr()->BeginCollection("Add Instance");
_createChildEditor(index , vPos, scale, yaw);
OgitorsUndoManager::getSingletonPtr()->AddUndo(OGRE_NEW AddInstanceUndo(mObjectID->get(), index));
OgitorsUndoManager::getSingletonPtr()->EndCollection(true);
}
}
std::vector<Unite *> RTSState::getUnitesInRectangleUnderCamera(const Rectangle<float> &rectangle) const
{
Ogre::PlaneBoundedVolume vol;
Ogre::Camera *camera = m_gameEngine->cameraManager()->camera();
Ogre::Ray topLeft = camera->getCameraToViewportRay(rectangle.left, rectangle.top);
Ogre::Ray topRight = camera->getCameraToViewportRay(rectangle.left + rectangle.width, rectangle.top);
Ogre::Ray bottomLeft = camera->getCameraToViewportRay(rectangle.left, rectangle.top + rectangle.height);
Ogre::Ray bottomRight = camera->getCameraToViewportRay(rectangle.left + rectangle.width, rectangle.top + rectangle.height);
vol.planes.push_back(Ogre::Plane(topLeft.getPoint(1), topRight.getPoint(1), bottomRight.getPoint(1))); // front plane
vol.planes.push_back(Ogre::Plane(topLeft.getOrigin(), topLeft.getPoint(100), topRight.getPoint(100))); // top plane
vol.planes.push_back(Ogre::Plane(topLeft.getOrigin(), bottomLeft.getPoint(100), topLeft.getPoint(100))); // left plane
vol.planes.push_back(Ogre::Plane(bottomLeft.getOrigin(), bottomRight.getPoint(100), bottomLeft.getPoint(100))); // bottom plane
vol.planes.push_back(Ogre::Plane(topRight.getOrigin(), topRight.getPoint(100), bottomRight.getPoint(100))); // right plane
Ogre::PlaneBoundedVolumeList volList;
volList.push_back(vol);
EngineManager *mng = m_gameEngine->getManager();
Ogre::PlaneBoundedVolumeListSceneQuery *query = mng->getGraphic()->getSceneManager()->createPlaneBoundedVolumeQuery(volList);
Ogre::SceneQueryResult result = query->execute();
std::vector<Unite *> foundUnits;
std::for_each(result.movables.begin(), result.movables.end(), [&foundUnits](Ogre::MovableObject * obj)
{
try
{
WorldObject *worldObj = Ogre::any_cast<WorldObject *>(obj->getUserObjectBindings().getUserAny());
Unite *unite = dynamic_cast<Unite *>(worldObj);
foundUnits.push_back(unite);
}
catch (...)
{
}
});
return foundUnits;
}
Ogre::Vector3& PhysicsManager::getMouseWorldPosition(float x, float y){
Ogre::Camera* cam = _sceneManager->getCamera("PlayState");
Ogre::Ray ray = cam->getCameraToViewportRay(x, y);
Ogre::Vector3 position;
OgreBulletCollisions::CollisionClosestRayResultCallback cQuery = OgreBulletCollisions::CollisionClosestRayResultCallback(ray, _world, 10000);
_world->launchRay(cQuery);
if (cQuery.doesCollide()) {
position = cQuery.getCollisionPoint();
}
return position;
}
bool
ZWorkspaceController::onMouseMove(const OIS::MouseEvent &evt)
{
if(_workspace->getToolsetController()->isCursorMode())
{
//Get voxel position.
//Just pass in the 3d position of where the user clicked. This is predefined to be a certain distance into the screen.
Ogre::Camera* cam = _workspace->getCinematicController()->getCinematicManager()->getRootCam();
Ogre::Real x, y;
x = evt.state.X.abs / _windowWidth;
y = evt.state.Y.abs / _windowHeight;
Ogre::Ray rayTo;
Ogre::Vector3 position;
Ogre::Real searchDistance = 64.0f;
rayTo = cam->getCameraToViewportRay(x, y);
//Shift modifies cursor to be constraint to a plane.
if(_modifierState & OIS::Keyboard::Shift)
{
Ogre::Plane constraintPlane;
bool hit = _workspace->getToolsetController()->getConstraintPlane(rayTo, constraintPlane);
if(hit)
_workspace->getWorldController()->getCursor3dPosition(rayTo, position, constraintPlane);
else
_workspace->getWorldController()->getCursor3dPosition(rayTo, position, searchDistance);
}
else
{
_workspace->getWorldController()->getCursor3dPosition(rayTo, position, searchDistance);
}
_workspace->getToolsetController()->onCursorPosition3d(position);
_workspace->getCinematicController()->onDisableOneFrame();
}
return true;
}
//Ogre::Camera::getCameraToViewportRay(float, float, Ogre::Ray*) const
void camera_get_camera_to_viewport_ray(CameraHandle handle, coiReal screenx, coiReal screeny, RayHandle result)
{
Ogre::Camera* camera = static_cast<Ogre::Camera*>(handle);
Ogre::Ray* ray = static_cast<Ogre::Ray*>(result);
camera->getCameraToViewportRay(screenx, screeny, ray);
}