bool Player::rotate(const Ogre::Vector3 &rot, bool adjust)
{
if (mVanity.enabled) {
toggleVanityMode(false);
}
Ogre::Vector3 trueRot = rot;
/// \note rotate player on forced vanity
if (mVanity.forced) {
if (mFreeLook) {
float diff = (adjust) ? rot.z : mMainCam.yaw - rot.z;
mVanity.enabled = false;
rotateCamera(rot, adjust);
mVanity.enabled = true;
compensateYaw(diff);
}
trueRot.z = 0.f;
}
if (mFreeLook || mVanity.enabled || mPreviewMode) {
rotateCamera(trueRot, adjust);
}
/// \note if vanity mode is forced by TVM then rotate player
return (!mVanity.enabled && !mPreviewMode) || mVanity.forced;
}
void processMouseEvents(float factor)
{
int x;
int y;
int cx = scene->context->w / 2;
int cy = scene->context->h / 2;
float sensitivity = 0.05f;
float dx, dy;
glfwGetMousePos(&x, &y);
dx = sensitivity * ((float) cx - (float) x);
dy = sensitivity * ((float) cy - (float) y);
if (dx == 0.0f && dy == 0.0f)
{
return;
}
if (glfwGetKey(GLFW_KEY_LSHIFT) == GLFW_PRESS ||
glfwGetKey(GLFW_KEY_RSHIFT) == GLFW_PRESS)
{
float slide = SLIDE_STEP * factor;
dx *= slide;
dy *= slide;
slideCamera(scene->camera, -dx, dy, 0.0f);
}
else
{
float rotate = ROTATE_STEP * factor;
dx *= rotate;
dy *= rotate;
rotateCamera(scene->camera, dx, 0.0f, 0.0f);
rotateCamera(scene->camera, 0.0f, -dy, 0.0f);
}
if (scene->world != NULL)
{
setupCamera(scene->world->sp, scene->camera);
}
if (scene->water != NULL)
{
setupCameraAlter(scene->water->modifySP, scene->camera);
setupCamera(scene->water->drawSP, scene->camera);
}
glfwSetMousePos(cx, cy);
}
void Camera::mouseMovement(int x, int y){
rotateCamera(-changeX,-changeY);
changeX = (float) (startX-x);
changeY = (float) (startY-y);
if(!(changeX == 0 && changeY == 0)){
//New
rotateCamera(changeX,changeY);
}
}
bool Camera::toggleVanityMode(bool enable)
{
// Changing the view will stop all playing animations, so if we are playing
// anything important, queue the view change for later
if (!mPreviewMode)
{
mVanityToggleQueued = true;
return false;
}
if(!mVanity.allowed && enable)
return false;
if(mVanity.enabled == enable)
return true;
mVanity.enabled = enable;
processViewChange();
float offset = mPreviewCam.offset;
Ogre::Vector3 rot(0.f, 0.f, 0.f);
if (mVanity.enabled) {
rot.x = Ogre::Degree(-30.f).valueRadians();
mMainCam.offset = mCamera->getPosition().z;
} else {
rot.x = getPitch();
offset = mMainCam.offset;
}
rot.z = getYaw();
mCamera->setPosition(0.f, 0.f, offset);
rotateCamera(rot, false);
return true;
}
void Camera::update(float duration, bool paused)
{
if (mAnimation->allowSwitchViewMode())
{
// Now process the view changes we queued earlier
if (mVanityToggleQueued)
{
toggleVanityMode(!mVanity.enabled);
mVanityToggleQueued = false;
}
if (mViewModeToggleQueued)
{
togglePreviewMode(false);
toggleViewMode();
mViewModeToggleQueued = false;
}
}
updateListener();
if (paused)
return;
// only show the crosshair in game mode and in first person mode.
MWBase::WindowManager *wm = MWBase::Environment::get().getWindowManager();
wm->showCrosshair(!wm->isGuiMode() && (mFirstPersonView && !mVanity.enabled && !mPreviewMode));
if(mVanity.enabled)
{
Ogre::Vector3 rot(0.f, 0.f, 0.f);
rot.z = Ogre::Degree(3.f * duration).valueRadians();
rotateCamera(rot, true);
}
}
void Camera::update(float duration, bool paused)
{
if (mAnimation->upperBodyReady())
{
// Now process the view changes we queued earlier
if (mVanityToggleQueued)
{
toggleVanityMode(!mVanity.enabled);
mVanityToggleQueued = false;
}
if (mViewModeToggleQueued)
{
togglePreviewMode(false);
toggleViewMode();
mViewModeToggleQueued = false;
}
}
if (paused)
return;
// only show the crosshair in game mode and in first person mode.
MWBase::WindowManager *wm = MWBase::Environment::get().getWindowManager();
wm->showCrosshair(!wm->isGuiMode() && (mFirstPersonView && !mVanity.enabled && !mPreviewMode));
if(mVanity.enabled)
{
rotateCamera(0.f, osg::DegreesToRadians(3.f * duration), true);
}
}
bool Player::toggleVanityMode(bool enable, bool force)
{
if ((mVanity.forced && !force) ||
(!mVanity.allowed && (force || enable)))
{
return false;
} else if (mVanity.enabled == enable) {
return true;
}
mVanity.enabled = enable;
mVanity.forced = force && enable;
float offset = mPreviewCam.offset;
Ogre::Vector3 rot(0.f, 0.f, 0.f);
if (mVanity.enabled) {
rot.x = Ogre::Degree(-30.f).valueRadians();
mMainCam.offset = mCamera->getPosition().z;
setLowHeight(true);
} else {
rot.x = getPitch();
offset = mMainCam.offset;
setLowHeight(!mFirstPersonView);
}
rot.z = getYaw();
mCamera->setPosition(0.f, 0.f, offset);
rotateCamera(rot, false);
return true;
}
void rotatePlayer(player_s* p, vect3Df_s v)
{
if(!p)return;
p->tempAngle = vaddf(p->tempAngle, v);
rotateCamera(&p->camera, v);
}
///
/// \brief GlFrame::keyPressEvent
/// Key Event handler, for translation and rotation
/// ZS : move along Z
/// QD : move along X
/// RF : move along Y
///
/// Arrow keys : rotate camera
///
/// \param event
///
void GlFrame::keyPressEvent( QKeyEvent* event )
{
switch( event->key())
{
case Qt::Key_Left:
rotateCamera( m_rotateSpeed * m_timeSinceLastFrame, 0 );
break;
case Qt::Key_Right:
rotateCamera( -m_rotateSpeed * m_timeSinceLastFrame, 0);
break;
case Qt::Key_Up:
rotateCamera( 0, m_rotateSpeed * m_timeSinceLastFrame );
break;
case Qt::Key_Down:
rotateCamera( 0, -m_rotateSpeed * m_timeSinceLastFrame);
break;
case Qt::Key_D:
translateCamera(0, m_moveSpeed * m_timeSinceLastFrame);
break;
case Qt::Key_Q:
translateCamera(0, -m_moveSpeed * m_timeSinceLastFrame);
break;
case Qt::Key_Z:
translateCamera(m_moveSpeed * m_timeSinceLastFrame, 0);
break;
case Qt::Key_S:
translateCamera(-m_moveSpeed * m_timeSinceLastFrame, 0);
break;
case Qt::Key_R:
m_Camera->translateY(m_moveSpeed * m_timeSinceLastFrame);
break;
case Qt::Key_F:
m_Camera->translateY(-m_moveSpeed * m_timeSinceLastFrame);
break;
}
}
void myKeyHandler(unsigned char ch, int x, int y)
{
switch (ch)
{
case '/':
rotateCamera(5, Y_AXIS);
break;
case '?':
rotateCamera(-5, Y_AXIS);
break;
case 'q':
endCanvas(0);
break;
case 'a':
if (_iterations < 10)
{
++_iterations;
}
break;
case 's':
if (_iterations > 0)
{
--_iterations;
}
break;
case 'p':
break;
case 'w':
setSeason();
break;
default:
return;
break;
}
display ();
}
bool myApp::processInput(unsigned int nMsg, int wParam, long lParam)
{
// Handle input
switch (nMsg)
{
// Process mouse move message
case WM_MOUSEMOVE:
{
// Get mouse x & y (to the upper-left corner of the client area)
int xPos = GET_X_LPARAM(lParam);
int yPos = GET_Y_LPARAM(lParam);
if ((wParam & MK_LBUTTON) != 0 && m_nPrevMouseX >= 0) //
{
rotateCamera(s_rMouseMove2Rotate*(xPos - m_nPrevMouseX),
s_rMouseMove2Rotate*(yPos - m_nPrevMouseY));
}
m_nPrevMouseX = xPos;
m_nPrevMouseY = yPos;
break;
}
// Process mouse wheel message
case WM_MOUSEWHEEL:
{
int zDelta = (int)((signed short)(HIWORD(wParam)));
zoom(zDelta * s_rMouseWheel2Zoom);
break;
}
case WM_KEYDOWN:
{
// Save flags for continuous controls
if (wParam < MAX_KEYS)
m_keysPressed[wParam] = true;
break;
}
case WM_KEYUP:
{
// Save flags for continuous controls
if (wParam < MAX_KEYS)
m_keysPressed[wParam] = false;
// Process switch controls
switch (wParam)
{
case '1': /* do something */ break;
case '2': /* do something */ break;
case '3': /* do something */ break;
}
break;
}
}
return cglApp::processInput(nMsg, wParam, lParam);
}
void QgsCameraController::onPositionChanged( Qt3DInput::QMouseEvent *mouse )
{
int dx = mouse->x() - mMousePos.x();
int dy = mouse->y() - mMousePos.y();
bool hasShift = ( mouse->modifiers() & Qt::ShiftModifier );
bool hasCtrl = ( mouse->modifiers() & Qt::ControlModifier );
bool hasLeftButton = ( mouse->buttons() & Qt::LeftButton );
bool hasMiddleButton = ( mouse->buttons() & Qt::MiddleButton );
bool hasRightButton = ( mouse->buttons() & Qt::RightButton );
if ( ( hasLeftButton && hasShift && !hasCtrl ) || ( hasMiddleButton && !hasShift && !hasCtrl ) )
{
// rotate/tilt using mouse (camera moves as it rotates around its view center)
float pitch = mCameraPose.pitchAngle();
float yaw = mCameraPose.headingAngle();
pitch += dy;
yaw -= dx / 2;
mCameraPose.setPitchAngle( pitch );
mCameraPose.setHeadingAngle( yaw );
updateCameraFromPose();
}
else if ( hasLeftButton && hasCtrl && !hasShift )
{
// rotate/tilt using mouse (camera stays at one position as it rotates)
float diffPitch = 0.2f * dy;
float diffYaw = 0.2f * -dx / 2;
rotateCamera( diffPitch, diffYaw );
updateCameraFromPose( true );
}
else if ( hasLeftButton && !hasShift && !hasCtrl )
{
// translation works as if one grabbed a point on the plane and dragged it
// i.e. find out x,z of the previous mouse point, find out x,z of the current mouse point
// and use the difference
float z = mLastPressedHeight;
QPointF p1 = screen_point_to_point_on_plane( QPointF( mMousePos.x(), mMousePos.y() ), mViewport, mCamera, z );
QPointF p2 = screen_point_to_point_on_plane( QPointF( mouse->x(), mouse->y() ), mViewport, mCamera, z );
QgsVector3D center = mCameraPose.centerPoint();
center.set( center.x() - ( p2.x() - p1.x() ), center.y(), center.z() - ( p2.y() - p1.y() ) );
mCameraPose.setCenterPoint( center );
updateCameraFromPose( true );
}
else if ( hasRightButton && !hasShift && !hasCtrl )
{
// zoom in/out
float dist = mCameraPose.distanceFromCenterPoint();
dist -= dist * dy * 0.01f;
mCameraPose.setDistanceFromCenterPoint( dist );
updateCameraFromPose();
}
mMousePos = QPoint( mouse->x(), mouse->y() );
}
void mouseTrack(int x, int y)
{
double x_change = x - _x_pos;
_x_pos = (double)x;
cout << "entered mouseTrack " << x_change << endl;
if(x_change > 0 && _counter%3 ==0) //mouse moved right - counter clockwise
{
rotateCamera(x_change/2,Y_AXIS);
}
else if(x_change < 0 && _counter%3 ==0) //mouse moved left - clockwise
{
rotateCamera(x_change/2,Y_AXIS);
}
_counter++;
display ();
}
void CameraController3rd::update(float delta)
{
//Modificar la distancia al objetivo si conviene
checkCameraDistance();
if(_lockOn)
{
//Shadow mira hacia donde mira la camara
TransformComponent * player_trans = EntityManager::get().getComponent<TransformComponent>(World::instance()->getPlayer());
btVector3 cam_front; CameraSystem::get().getPlayerCamera().getFront(cam_front);
cam_front.setY(0);
player_trans->approximateFront_v(cam_front, 10*delta);
//Si hay enemigo fijado, hacer que el player mire hacia el
if(_lockedEntity)
{
btVector3 dir = EntityManager::get().getComponent<TransformComponent>(_lockedEntity)->getPosition() - player_trans->getPosition();
lookTo(dir, 0.8f); //Camara mira hacia la entity fijada
}
else
{
lookForEnemies();
if(!CameraSystem::get().isLockedCamera3rd()) rotateCamera(delta); //Rotar camara segun input
}
}
else
{
if(!CameraSystem::get().isLockedCamera3rd()) rotateCamera(delta); //Rotar camara segun input
}
//Centrar camara
checkCenterCamera();
//Se resitua la camara en una posicion guay
btVector3 targetPos = _targetTransform->getOrigin();
targetPos.setY(targetPos.getY() + _upDist);
btVector3 left = btVector3(0,1,0).cross(_front); left.normalize();
targetPos = targetPos + _sideDist*left;
placeByCollisionsPosition(delta, targetPos);
_camera->lookAt( _position, targetPos, btVector3(0,1,0));
}
void Display() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
setupLights();
setupCamera();
drawBanana(30,cameraY+90,0);
if (coins >= 5) {
win = true;
//sound for winning
}
if (cinematic)
rotateCamera();
glColor3f(1,1,1);
Draw_Skybox(cameraX, cameraY, cameraZ, 400, 800, 400);
if (Levels.size() > 0) {
if (Levels[0].y <cameraY - 100) {
printf("deleting level");
Levels.erase(Levels.begin());
// for (int j = 0; j<Levels.size() - 1; j++) {
// Levels[j] = Levels[j + 1];
// }
// Levels.pop_back();
if (Levels.size()>0) {
Levels[0].levelBefore = NULL;
}
}
}
char result[10];
sprintf(result, "%i", coins);
//std::string name = "Score: ", result;
displayText(50, cameraY + 110, 0, 1, 1, 1, result);
if (!lost&!win) {
createScene();
character.drawCharacter();
//std::string name = "Score: ";
// char numstr[2];
/// result = name + numstr;
}
else {
if (lost)
displayText(-20, cameraY + 100, 0, 1, 1, 1, "GAME OVER!");
if (win)
displayText(-20, cameraY + 100, 0, 1, 1, 1, "YOU WON :)");
}
glFlush();
}
void performanceTest(void) {
int start, end;
int i;
int curr_width, curr_height;
/* Give a warning if the window has been resized */
curr_width = glutGet(GLUT_WINDOW_WIDTH);
curr_height = glutGet(GLUT_WINDOW_HEIGHT);
if ((curr_width != win_width) || (curr_height != win_height)) {
printf("*** Warning ***\n");
printf("The window has been resized and results may be inaccurate.\n");
printf("First press 'z' to restore the default window size.\n");
printf("*** Warning ***\n");
}
resetCamera();
printf("Initiating Performance Test\n");
start = glutGet(GLUT_ELAPSED_TIME);
/* For every rotation, the display loop will be recalled */
for (i = 0; i < 360; i++) {
rotateCamera(1.0, X_AXIS);
myDisplay(); /* refresh the screen */
}
for (i = 0; i < 360; i++) {
rotateCamera(1.0, Y_AXIS);
myDisplay(); /* refresh the screen */
}
for (i = 0; i < 360; i++) {
rotateCamera(1.0, Z_AXIS);
myDisplay(); /* refresh the screen */
}
end = glutGet(GLUT_ELAPSED_TIME);
/* Return the number of milliseconds elapsed */
printf("Performance Test completed in %.2f sec\n",
(end - start) / 1000.0f);
}
static void special(int key, int x, int y)
{
switch (key) {
case GLUT_KEY_UP:
/* move forward */
translateCamera(0.15f);
break;
case GLUT_KEY_DOWN:
/* move backward */
translateCamera(-0.15f);
break;
case GLUT_KEY_RIGHT:
/* rotate to the right */
rotateCamera(5.0f);
break;
case GLUT_KEY_LEFT:
/* rotate to the left */
rotateCamera(-5.0f);
break;
}
}
/// Make movement step of manipulator. Returns true if any movement was made.
bool OrbitCameraManipulator::performMovement( const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa )
{
// return if less then two events have been added
if( _ga_t0.get() == nullptr || _ga_t1.get() == nullptr )
{
return false;
}
// get delta time
double eventTimeDelta = _ga_t0->getTime() - _ga_t1->getTime();
if( eventTimeDelta < 0. )
{
OSG_WARN << "Manipulator warning: eventTimeDelta = " << eventTimeDelta << std::endl;
eventTimeDelta = 0.;
}
// get deltaX and deltaY
float dx = _ga_t0->getXnormalized() - _ga_t1->getXnormalized();
float dy = _ga_t0->getYnormalized() - _ga_t1->getYnormalized();
float scale = getThrowScale( eventTimeDelta );
dx = dx*scale;
dy = dy*scale;
// return if there is no movement.
if( dx == 0. && dy == 0. )
{
return false;
}
// call appropriate methods
int buttonMask = _ga_t1->getButtonMask();
if( buttonMask == osgGA::GUIEventAdapter::LEFT_MOUSE_BUTTON )
{
rotateCamera( dx, dy );
return true;
}
else if( buttonMask == osgGA::GUIEventAdapter::MIDDLE_MOUSE_BUTTON || buttonMask == (osgGA::GUIEventAdapter::LEFT_MOUSE_BUTTON | osgGA::GUIEventAdapter::RIGHT_MOUSE_BUTTON) )
{
// pan model
//float scale = getThrowScale( eventTimeDelta );
panCamera( dx, dy, ea, aa );
return true;
}
else if( buttonMask == osgGA::GUIEventAdapter::RIGHT_MOUSE_BUTTON )
{
zoomCamera( dy );
return true;
}
return false;
}
void checkInput(){
if(keyDown[27]){
exit(0);
}
if (specialKeyDown[GLUT_KEY_LEFT]){
rotateCamera(LEFT);
}
if (specialKeyDown[GLUT_KEY_RIGHT]){
rotateCamera(RIGHT);
}
if (specialKeyDown[GLUT_KEY_UP]){
zoomCamera(IN);
}
if (specialKeyDown[GLUT_KEY_DOWN]){
zoomCamera(OUT);
}
//Nomlet control
vector<Nomlet> &nomlets = manager->getNomlets();
if (nomlets.size() > 0){
Nomlet &nomlet = nomlets[0];
if(keyDown['w']){
nomlet.accelerate();
}
if(keyDown['a']){
nomlet.turn(NOMLET_TURN_SPEED);
}
if(keyDown['d']){
nomlet.turn(-NOMLET_TURN_SPEED);
}
if(keyDown['1']){
nomlet.giveEnergy(500);
}
}
}
Camera * newCamera(int w, int h)
{
Camera * camera = (Camera *) malloc(sizeof(Camera));
camera->pos[0] = 2.0f;
camera->pos[1] = 2.0f;
camera->pos[2] = 3.0f;
camera->q[0] = 1.0f;
camera->q[1] = 0.0f;
camera->q[2] = 0.0f;
camera->q[3] = 0.0f;
rotateCamera(camera, 0.0f, -90.0f, 0.0f);
rotateCamera(camera, 135.0f, 0.0f, 0.0f);
rotateCamera(camera, 0.0f, -45.0f, 0.0f);
camera->viewAngleY = 45.0f;
camera->aspect = ((float) w) / ((float) h);
camera->znear = 0.001f;
camera->zfar = 100.0f;
return camera;
}
void Viewer::update(){
GLfloat elapsedTime = glfwGetTime() - _lastAccessedTime;
_lastAccessedTime = glfwGetTime();
changeElevation(_elevation_velocity * elapsedTime);
_velocity = _velocity - glm::vec3(0,_fall_speed,0);
_direction.y = 0;
glm::vec3 displacement = _velocity * elapsedTime;
GLfloat cameraRotation = _cameraRotationVelocity * elapsedTime;
rotateCamera(cameraRotation);
move(displacement.x, displacement.y, - displacement.z);
}
///
/// \brief GlFrame::mouseMoveEvent
/// Rotate camera with mouse when in fullscreen mode
/// \param event
///
void GlFrame::mouseMoveEvent(QMouseEvent *event)
{ if(!isFullScreen())
return;
float disX = (event->globalX() - m_lastPos.x()) * m_rotateSpeed;
float disY = (event->globalY() - m_lastPos.y()) * m_rotateSpeed;
// cout << "Souris y " << disY << endl;
// cout << "Souris x " << disX << endl;
rotateCamera(-disX, -disY);
QPoint glob = mapToGlobal(QPoint(width()/2,height()/2));
QCursor::setPos(glob);
m_lastPos = QPoint(width()/2,height()/2);
}
void myMouseMotion(int x, int y) {
init();
double d_x, d_y; /* The change in x and y since the last callback */
d_x = x - m_last_x;
d_y = y - m_last_y;
m_last_x = x;
m_last_y = y;
d_x /= 2.0;
rotateCamera(d_x); /* y-axis rotation */
/* Redraw the screen */
glutPostRedisplay();
}
void key(unsigned char key, int x, int y) {
if (key == ' ' &(!character.fall||character.x>60 || character.x<-70)&&jumpVelocity<30) {
// sound for jumping
character.angleOfLooking = 0;
jump = true;
if (jumpVelocity < 35){
//sound for double jump
jumpVelocity = 1.2*jumpVelocity;
//cameraAcceleration = 4*cameraAcceleration;
cameraY += jumpVelocity/8;
eyeY += jumpVelocity/8;
}
else{
jump = false;
}
jumpTime = clock();
jumpBeginX = character.x;
jumpBeginY = character.y;
jumpEndY = character.y;
}
if (key == 'd') {
characterSpeed = fabs(characterSpeed);
character.x += characterSpeed;
character.angleOfLooking = 90;
}
if (key == 'a') {
characterSpeed = fabs(characterSpeed)*-1;
character.x += characterSpeed;
character.angleOfLooking = -90;
}
if (key == 'v'&!lost&!win){
cinematic = true;
rotateCamera();
}
if (key == 'c') {
eyeY--;
cameraY--;
}
}
void drawKinectData() {
getKinectData();
rotateCamera();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glBindBuffer(GL_ARRAY_BUFFER, vboId);
glVertexPointer(3, GL_FLOAT, 0, NULL);
glBindBuffer(GL_ARRAY_BUFFER, cboId);
glColorPointer(3, GL_FLOAT, 0, NULL);
glPointSize(1.f);
glDrawArrays(GL_POINTS, 0, width*height);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
// Draw some arms
const Vector4& lh = skeletonPosition[NUI_SKELETON_POSITION_HAND_LEFT];
const Vector4& le = skeletonPosition[NUI_SKELETON_POSITION_ELBOW_LEFT];
const Vector4& ls = skeletonPosition[NUI_SKELETON_POSITION_SHOULDER_LEFT];
const Vector4& rh = skeletonPosition[NUI_SKELETON_POSITION_HAND_RIGHT];
const Vector4& re = skeletonPosition[NUI_SKELETON_POSITION_ELBOW_RIGHT];
const Vector4& rs = skeletonPosition[NUI_SKELETON_POSITION_SHOULDER_RIGHT];
glBegin(GL_LINES);
glColor3f(1.f, 0.f, 0.f);
if (lh.w > 0 && le.w > 0 && ls.w > 0) {
glVertex3f(lh.x, lh.y, lh.z);
glVertex3f(le.x, le.y, le.z);
glVertex3f(le.x, le.y, le.z);
glVertex3f(ls.x, ls.y, ls.z);
}
if (rh.w > 0 && re.w > 0 && rs.w > 0) {
glVertex3f(rh.x, rh.y, rh.z);
glVertex3f(re.x, re.y, re.z);
glVertex3f(re.x, re.y, re.z);
glVertex3f(rs.x, rs.y, rs.z);
}
glEnd();
}
void Player::update(float duration)
{
updateListener();
// only show the crosshair in game mode and in first person mode.
MWBase::Environment::get().getWindowManager ()->showCrosshair
(!MWBase::Environment::get().getWindowManager ()->isGuiMode () && (mFirstPersonView && !mVanity.enabled && !mPreviewMode));
/// \fixme We shouldn't hide the whole model, just certain components of the character (head, chest, feet, etc)
mPlayerNode->setVisible(mVanity.enabled || mPreviewMode || !mFirstPersonView);
if (mFirstPersonView && !mVanity.enabled) {
return;
}
if (mVanity.enabled) {
Ogre::Vector3 rot(0.f, 0.f, 0.f);
rot.z = Ogre::Degree(3.f * duration).valueRadians();
rotateCamera(rot, true);
}
}
void Player::togglePreviewMode(bool enable)
{
if (mPreviewMode == enable) {
return;
}
mPreviewMode = enable;
float offset = mCamera->getPosition().z;
if (mPreviewMode) {
mMainCam.offset = offset;
offset = mPreviewCam.offset;
setLowHeight(true);
} else {
mPreviewCam.offset = offset;
offset = mMainCam.offset;
setLowHeight(!mFirstPersonView);
}
mCamera->setPosition(0.f, 0.f, offset);
rotateCamera(Ogre::Vector3(getPitch(), 0.f, getYaw()), false);
}
void GLWidget::mouseMoveEvent(QMouseEvent *event) {
int dx = event->x() - last_mouse_x;
int dy = event->y() - last_mouse_y;
if (event->buttons() & Qt::LeftButton) {
rotateCamera(dx, dy);
}
else if (event->buttons() & Qt::MidButton) {
moveCamera(dx, dy);
}
else if (event->buttons() & Qt::RightButton) {
zoomCamera(dy);
}
if (user_motion_func) {
user_motion_func(int(event->x()), int(event->y()));
}
last_mouse_x = event->x();
last_mouse_y = event->y();
requestRedraw();
}
void SimObjectRenderer::moveCamera(float x, float y)
{
if(cameraMode == SimRobotCore2::Renderer::targetCam)
{
if(x != 0.f)
rotateCamera(x, 0);
if(y != 0.f)
{
Vector3<> v = cameraPos - cameraTarget;
float len = v.abs() + y;
if(len < 0.0001f)
len = 0.0001f;
v.normalize(len);
cameraPos = cameraTarget + v;
}
}
else // if(cameraMode == SimRobotCore2::Renderer::FREECAM)
{
if(x != 0.f)
{
Vector3<> v = cameraTarget - cameraPos;
Vector3<> v2 = v ^ Vector3<>(0.f, 0.f, 1.f);
v2.normalize(x);
cameraTarget += v2;
cameraPos += v2;
}
if(y != 0.f)
{
Vector3<> v = cameraTarget - cameraPos;
v.normalize(y);
cameraTarget -= v;
cameraPos -= v;
}
}
updateCameraTransformation();
}
/*Render all the objects into the scene. With appropriate
*transformations applied.*/
void renderScene()
{
if(!global.split)
{
drawStarBackground();
showTextDisplay(FALSE);
}
/*Save matrix for rotation before calculating
how far to zoom in.*/
glMatrixMode(GL_PROJECTION);
glScalef(cameraVar.zoom, cameraVar.zoom, cameraVar.zoom);
glMatrixMode(GL_MODELVIEW);
if(!global.split)
rotateCamera();
drawSceneWorld();
drawSceneProjectiles();
drawSceneBases();
/*Print any errors that may pop up.*/
int error = glGetError();
if(error != GL_NO_ERROR)
{
printf("%s\n", gluErrorString(error));
exit(1);
}
/*Reset projection matrix to default
*so the text and star background does not
*get scaled next iteration.*/
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
}
