void BaseApp::controls(){ // Compute directional vectors from euler angles float cosX = cosf(wx), sinX = sinf(wx), cosY = cosf(wy), sinY = sinf(wy); vec3 dx(cosY, 0, sinY); vec3 dy(-sinX * sinY, cosX, sinX * cosY); vec3 dz(-cosX * sinY, -sinX, cosX * cosY); vec3 dir(0, 0, 0); if (keys[leftKey]) dir -= dx; if (keys[rightKey]) dir += dx; if (keys[downKey]) dir -= dy; if (keys[upKey]) dir += dy; if (keys[backwardKey]) dir -= dz; if (keys[forwardKey]) dir += dz; float lenSq = dot(dir, dir); if (lenSq > 0){ moveCamera(dir * (1.0f / sqrtf(lenSq))); } dir = vec3(0, 0, 0); if (xStrafeAxis >= 0) dir += joystickAxes[xStrafeAxis] * (invertXStrafeAxis? -dx : dx); if (yStrafeAxis >= 0) dir += joystickAxes[yStrafeAxis] * (invertYStrafeAxis? -dy : dy); if (zStrafeAxis >= 0) dir += joystickAxes[zStrafeAxis] * (invertZStrafeAxis? -dz : dz); if (dot(dir, dir) > 0){ moveCamera(dir); } if (xTurnAxis >= 0) wx += (invertXTurnAxis? -2.0f : 2.0f) * joystickAxes[xTurnAxis] * frameTime; if (yTurnAxis >= 0) wy += (invertYTurnAxis? -2.0f : 2.0f) * joystickAxes[yTurnAxis] * frameTime; }
void Functions:: Control(float movevel,float mousevel, bool mi) { int tmpx,tmpy; int midX = 320; int midY = 240; if(mi) { SDL_ShowCursor(SDL_DISABLE); SDL_GetMouseState(&tmpx,&tmpy);//SDL Command to get mouse x and y pos camYaw += mousevel *(midX-tmpx); camPitch += mousevel* (midY - tmpy); lockCamera(); SDL_WarpMouse(midX,midY);//set cursor back to center Uint8* state = SDL_GetKeyState(NULL); if(state[SDLK_w]) { //if(camPitch != 90 && camPitch != -90) // lock the camera from moving off into space moveCamera(movevel,0.0); //moveCameraUp(movevel,0.0); // lock the camera from moving off into space } else if(state[SDLK_s]) { //if(camPitch != 90 && camPitch != -90) // lock the camera from moving off into space comment here moveCamera(movevel,180.0); // moveCameraUp(movevel,180.0); // lock the camera from moving off into space comment this line } if (state[SDLK_a]) moveCamera(movevel,90); else if(state[SDLK_d]) moveCamera(movevel,270); } glRotatef(-camPitch,1.0,0.0,0.0); glRotatef(-camYaw,0.0,1.0,0.0); };
void Control(float movevel,float mousevel,bool mi) { if(mi) { int MidX=320; int MidY=240; SDL_ShowCursor(SDL_DISABLE); int tmpx,tmpy; SDL_GetMouseState(&tmpx,&tmpy); camYaw+=mousevel*(MidX-tmpx); camPitch+=mousevel*(MidY-tmpy); lockCamera(); SDL_WarpMouse(MidX,MidY); Uint8* state=SDL_GetKeyState(NULL); if(state[SDLK_w]) { // if(camPitch!=90 && camPitch!=-90) moveCamera(movevel,0.0); // moveCameraUp(movevel,0.0); }else if(state[SDLK_s]) { // if(camPitch!=90 && camPitch!=-90) moveCamera(movevel,180.0); // moveCameraUp(movevel,180.0); } if(state[SDLK_a]) moveCamera(movevel,90.0); else if(state[SDLK_d]) moveCamera(movevel,270); } glRotatef(-camPitch,1.0,0.0,0.0); glRotatef(-camYaw,0.0,1.0,0.0); }
static void key_callback(GLFWwindow *window, int key, int scancode, int action, int mods) { if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) glfwSetWindowShouldClose(window, GL_TRUE); if (action == GLFW_PRESS || action == GLFW_REPEAT) { switch (key) { case GLFW_KEY_W: moveCamera(1.f, 0.f, 0.f); break; case GLFW_KEY_S: moveCamera(-1.f, 0.f, 0.f); break; case GLFW_KEY_A: moveCamera(0.f, -1.f, 0.f); break; case GLFW_KEY_D: moveCamera(0.f, 1.f, 0.f); break; case GLFW_KEY_Z: moveCameraGlobal(0.f, 0.f, -1.f); break; case GLFW_KEY_Q: moveCameraGlobal(0.f, 0.f, 1.f); break; case GLFW_KEY_I: turnCamera(1.f, 0.f, 0.f); break; case GLFW_KEY_K: turnCamera(-1.f, 0.f, 0.f); break; case GLFW_KEY_L: turnCamera(0.f, -1.f, 0.f); break; case GLFW_KEY_J: turnCamera(0.f, 1.f, 0.f); break; case GLFW_KEY_T: changeFOV(-1.f); break; case GLFW_KEY_Y: changeFOV(1.f); break; case GLFW_KEY_M: light = camera_pos; break; case GLFW_KEY_P: nextRenderMethod(); break; /*default:*/ } } }
void controlStrafeRight(player_struct* p, bool down, bool held) { if(!p)return; if(p->object->contact) { moveCamera(NULL, vect(PLAYERGROUNDSPEED,0,0)); p->walkCnt+=2500; changeAnimation(&p->playerModelInstance,4,false); idle=false; }else moveCamera(NULL, vect(PLAYERAIRSPEED,0,0)); }
void BattleScene::gameController(float dt) {//to drive the main logic GameMaster::getInstance()->update(dt); collisionDetect(dt); solveAttacks(dt); moveCamera(dt); }
void myinit() { g_iLineList = glGenLists(1); glNewList(g_iLineList, GL_COMPILE); makeLines(); glEndList(); initTexture(&g_iFloorName, g_pFloorTexture); g_iFloorList = glGenLists(2); glNewList(g_iFloorList, GL_COMPILE); makeFloor(); glEndList(); initTexture(&g_iSkyName, g_pSkyTexture); g_iSkyList = glGenLists(3); glNewList(g_iSkyList, GL_COMPILE); makeSky(); glEndList(); g_iTrackList = glGenLists(4); glNewList(g_iTrackList, GL_COMPILE); makeTracks(); glEndList(); glClearColor(0.0, 0.0, 0.0, 0.0); // set background color glEnable(GL_DEPTH_TEST); // enable depth buffering glShadeModel(GL_SMOOTH); // interpolate colors during rasterization moveCamera(); }
void Camera::headMovement(int usernum, double x, double y, double z) { //mm to meters and cast to float calculateTranslationVector(); getModelViewMatrix(); vec4 originCentric = modelViewMatrix * vec4(x/250.0,y/250.0,z/250.0,1.0); if (originCentric.z != 0) { float ysin = originCentric.x/originCentric.z; float xcos = originCentric.y/originCentric.z; if (ysin > 1) ysin = 1; else if (ysin < -1) ysin = -1; if (xcos > 1) xcos = 1; else if (xcos < -1) xcos = -1; yHeadAngle = -atan(ysin); xHeadAngle = -atan(xcos); } moveCamera(xHead-(float)(x/250.0), yHead -(float)(y/250.0), zHead +(float)(z/250.0)); xHead = (float)(x/250.0); yHead = (float)(y/250.0); zHead = -(float)(z/250.0); // printf("%d - (%6.2f, %6.2f, %6.2f) ==> (%6.2f,%6.2f,%6.2f), yaw=%f, pitch=%f\n", usernum,x,y,z,xHead, yHead, zHead, xHeadAngle, yHeadAngle); }
void render() { if (NULL != pd3dDevice) { pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0); pd3dDevice->BeginScene(); // create the camera createCamera(0.1f, 10.0f); // near clip plane, far clip plane // Position camera so cube is same projected size as in OpenGL version moveCamera(D3DXVECTOR3(0.0f, 0.0f, -1.6f)); pointCamera(D3DXVECTOR3(0.0f, 0.0f, 0.0f)); // draw the objects drawCube(); drawCursor(); pd3dDevice->EndScene(); pd3dDevice->Present(NULL, NULL, NULL, NULL); } }
int main(int argc, char **argv) { // init GLUT and create window glutInit(&argc, argv); glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); glutInitWindowPosition(100,100); glutInitWindowSize(320,320); windowWidth=320; windowHeight=320; glutCreateWindow("COMP 371 - Assignment 1"); // register callbacks glutDisplayFunc(renderScene); glutReshapeFunc(setView); glutKeyboardFunc(keyboard); glutSpecialFunc(specialKeyboard); glutIdleFunc(renderScene); moveCamera(); // enter GLUT event processing cycle glutMainLoop(); return 1; }
void display() { // clear buffers glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glLoadIdentity(); // reset transformation // look at the center of the image moveCamera(); gluLookAt(g_vCameraPos.x, g_vCameraPos.y, g_vCameraPos.z, g_vCameraPos.x + g_vCameraForward.x, g_vCameraPos.y + g_vCameraForward.y, g_vCameraPos.z + g_vCameraForward.z, g_vCameraUp.x, g_vCameraUp.y, g_vCameraUp.z); // apply transformations glTranslatef(g_vLandTranslate[0], g_vLandTranslate[1], g_vLandTranslate[2]); glRotatef(g_vLandRotate[0], 1, 0, 0); glRotatef(g_vLandRotate[1], 0, 1, 0); glRotatef(g_vLandRotate[2], 0, 0, 1); glScalef(g_vLandScale[0], g_vLandScale[1], g_vLandScale[2]); //glCallList(g_iLineList); glCallList(g_iFloorList); glCallList(g_iSkyList); glCallList(g_iTrackList); glutSwapBuffers(); }
void EG_FirstPersonPovCamera::Control(int mid_x, int mid_y) { if(m_mouseIn) { int MidX=mid_x; int MidY=mid_y; SDL_ShowCursor(SDL_DISABLE); int tmpx,tmpy; SDL_GetMouseState(&tmpx,&tmpy); m_yawDegrees += CAMERA_ROTATION_SPEED*(MidX-tmpx); m_pitchDegrees += CAMERA_ROTATION_SPEED*(MidY-tmpy); lockCamera(); SDL_WarpMouse(MidX,MidY); Uint8* state=SDL_GetKeyState(NULL); ismoved=false; if(state[SDLK_w]) { ismoved=true; if(m_pitchDegrees!=90 && m_pitchDegrees!=-90) moveCamera(0.0); moveCameraUp(0.0); }else if(state[SDLK_s]) { ismoved=true; if(m_pitchDegrees!=90 && m_pitchDegrees!=-90) moveCamera(180.0); moveCameraUp(180.0); } if(state[SDLK_a]) { ismoved=true; moveCamera(90.0); } else if(state[SDLK_d]) { ismoved=true; moveCamera(270); } } }
void idle(){ previousTime = currentTime; currentTime = clock(); float timeInterval = (double)(currentTime - previousTime) / CLOCKS_PER_SEC; if (keyLeft || leftButton){ moveCamera(timeInterval * cameraRotationPerSec); } if (keyRight || rightButton){ moveCamera(-timeInterval * cameraRotationPerSec); } moveLight(-timeInterval * lightRotationPerSec); glutPostRedisplay(); }
void Application::updateLogic(float elapsedTime) { m_MoveScale = m_MoveSpeed * 100; m_RotScale = m_RotateSpeed * elapsedTime; m_TranslateVector = Ogre::Vector3::ZERO; getInput(); moveCamera(); }
int main() { if (initWindow(1024, 768, "Mai First Play") != 0) { fprintf(stderr, "Error occurred, exiting main program\n"); glfwTerminate(); return -1; } glfwEnable(GLFW_STICKY_KEYS); // blue background glClearColor(0.0f, 0.0f, 0.4f, 0.0f); // create and bind vertex array GLuint vertexArrayID; glGenVertexArrays(1, &vertexArrayID); glBindVertexArray(vertexArrayID); // create and compile GLSL program from shaders GLuint glslProgramID = shader::LoadShaders( "shaders/simple.vert.glsl", "shaders/simple.frag.glsl"); // get a handle for our "MVP" uniform // only at initialisation time. GLuint matrixID = glGetUniformLocation(glslProgramID, "MVP"); // move camera glm::mat4 mvp = moveCamera(4,3,3); // define 3 vectors to represent 3 vertices static const GLfloat g_vertex_buffer_data[] = { -1.0f, -1.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f }; // create vertex buffer and pass it to OpenGL GLuint vertexbuffer; glGenBuffers(1, &vertexbuffer); glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW); // do the main loop mainLoop(vertexbuffer, glslProgramID, matrixID, mvp); glfwTerminate(); // cleanup VBO glDeleteBuffers(1, &vertexbuffer); glDeleteVertexArrays(1, &vertexArrayID); return 0; }
void FPSController::onFrameRenderingQueued(const App::FrameEventArgs* args) { const auto& leftStick = xboxCtrl->p1.getState().leftStick; const auto& rightStick = xboxCtrl->p1.getState().rightStick; accel = Ogre::Vector3(leftStick.x, 0, -leftStick.y).normalisedCopy(); rotX = Ogre::Degree(-rightStick.x); rotY = Ogre::Degree(rightStick.y); moveCamera(args->evt->timeSinceLastFrame); }
//Challenge: Create a rotation matrix and apply the rotations to "newDirection". void move(){ limitSpeed(); Vector3D newDirection = cubeForward; Vector3D delta = Math::multiply(newDirection, speed); cubePosition = Math::add(delta, cubePosition); glTranslatef(cubePosition.x, cubePosition.y, cubePosition.z); translateVertices(delta); moveCamera(delta); }
inline void onEvent(Node& node, Event& event) { switch(event.type) { case Event::FRAME_RENDERING: { const Ogre::Vector3 lastMotion = translateVector_; if(!event.mouse.buffered() || !event.keyboard.buffered()) { moveScale_ = moveSpeed_ * event.frameEvent.timeSinceLastFrame; rotateScale_ = rotateSpeed_ * event.frameEvent.timeSinceLastFrame; rotX_ = 0; rotY_ = 0; translateVector_ = Ogre::Vector3::ZERO; } if(!event.keyboard.buffered()){ processUnbufferedKeyInput(event); } if(!event.mouse.buffered()){ processUnbufferedMouseInput(event); } if(translateVector_ == Ogre::Vector3::ZERO) { currentSpeed_ -= event.frameEvent.timeSinceLastFrame * 0.3; translateVector_ = lastMotion; } else { currentSpeed_ += event.frameEvent.timeSinceLastFrame; } // Limit speed. if(currentSpeed_ > 1.0) { currentSpeed_ = 1.0; } else if(currentSpeed_ < 0.0) { currentSpeed_ = 0.0; } translateVector_ *= currentSpeed_; if(!event.mouse.buffered() || !event.keyboard.buffered()) { moveCamera(); } break; } default: { break; } } }
void CameraAnimator::timerEvent( QTimerEvent * te ) { if ( m_cameraIteration && ! m_cameraMoveTo ) { if ( ! m_cameraIterationTimer.isRunning() ) { m_cameraIterationTimer.restart(); } else { double currentTime = m_cameraIterationTimer.getTime(); if ( m_cameraIterationPauseDuration < currentTime ) { m_cameraIterationTimer.stop(); // move-to next camera dp::sg::core::FrustumCameraWeakPtr fsp = findNextIterationCamera(); if( fsp ) { moveToCamera( fsp ); } } } } else if ( m_cameraMoveTo ) { DP_ASSERT( m_cameraMoveTimer.isRunning() ); double currentTime = m_cameraMoveTimer.getTime(); double t; double realDuration = m_cameraMoveDuration * m_cameraMoveDurationFactor; if ( realDuration < currentTime ) { setCameraMoveTo( false ); t = 1.0; } else { t = currentTime / realDuration; t = 0.5 * ( sin( -dp::math::PI_HALF + t * dp::math::PI ) + 1.0 ); // smooth-in and -out using simple sine curve } moveCamera( t ); emit update(); } else if ( m_cameraOrbit ) { orbitCamera( m_cameraOrbitAxis, true, dp::math::degToRad(1.0f) ); emit update(); } }
void camera::control(int b, int x, int y) { std::cout << "move cam\n"; if(mi) { int MidX=320; int MidY=240; glutSetCursor(GLUT_CURSOR_NONE); // SDL_ShowCursor(SDL_DISABLE); int tmpx,tmpy; // SDL_GetMouseState(&tmpx,&tmpy); // camYaw+=mousespeed*(MidX-tmpx); // camPitch+=mousespeed*(MidY-tmpy); lockCamera(); glutWarpPointer(MidX,MidY); const Uint8* state=SDL_GetKeyboardState(NULL); if(b == GLUT_KEY_LEFT) { std::cout << "keyboard\n"; } if(state[SDLK_w]) { moveCamera(0.0); }else if(state[SDLK_s]) { moveCamera(180.0); } if(state[SDLK_a]) moveCamera(90.0); else if(state[SDLK_d]) moveCamera(270); } // glRotatef(-camPitch,1.0,0.0,0.0); // glRotatef(-camYaw,0.0,1.0,0.0); }
void PlatformerScene::editorTouchMoved(Touch* touch, Event*) { if (peekEnabled) { //peek mode auto dv = touch->getLocation() - touch->getPreviousLocation() + game->getPosition(); log("Current Cam: " + nToString(game->getPosition()) + " dv: " + nToString(dv)); moveCamera(dv.x, dv.y); } else { //paste mode //editorPasteItem(game->convertToNodeSpace(touch->getLocation())); } }
//************** TDDD04 FIX *********** void GameWorld::physicsSimulation(float deltaTime) { Player* player = m_gameObjectManager->getPlayer(); // Move camera view bool cameraMoved = moveCamera(deltaTime); // Add time not used before deltaTime += m_timeRest; // If enough time for a tick have passed if (deltaTime > GAME_WORLD_EPS) { // Break down elapsed time in smaller chucks to get a smouth experience. for(; deltaTime > GAME_WORLD_EPS; deltaTime -= GAME_WORLD_EPS) { // Move player along with camera if camera has moved if (cameraMoved) { player->offsetPosition(Coord(0.0f, -CAMERA_MOVING_SPEED*GAME_WORLD_EPS)); } // Move all objects m_physicsComponent->move(m_gameObjectManager, GAME_WORLD_EPS); // Move player back in view if outside camera view movePlayerBackIntoView(player); // Check for collisions checkForCollisions(); //PLAYER DEAD //TDDD04 FIX if (player->isDead()) { m_eventPlayerDied->run(); return; } } // Store any unused time m_timeRest = deltaTime; } else { m_timeRest = deltaTime; } }
/** The FrameStarted implementation * * \param evt The FrameEvet got from Ogre * * \return \c true to continue rendering, \c false to stop Ogre main loop */ bool RainbruRPG::Core::ExampleFrameListener:: frameStarted(const FrameEvent& evt){ if(mWindow->isClosed()) return false; // if (!mInputTypeSwitchingOn){ // mInputDevice->capture(); // } if ( !mUseBufferedInputMouse || !mUseBufferedInputKeys){ // one of the input modes is immediate, so setup what is // needed for immediate mouse/key movement if (mTimeUntilNextToggle >= 0) mTimeUntilNextToggle -= evt.timeSinceLastFrame; // If this is the first frame, pick a speed if (evt.timeSinceLastFrame == 0){ mMoveScale = 1; mRotScale = 0.1; } // Otherwise scale movement units by time passed since last frame else{ // Move about 100 units per second, mMoveScale = mMoveSpeed * evt.timeSinceLastFrame; // Take about 10 seconds for full rotation mRotScale = mRotateSpeed * evt.timeSinceLastFrame; } mRotX = 0; mRotY = 0; mTranslateVector = Ogre::Vector3::ZERO; } if (processUnbufferedKeyInput(evt) == false){ return false; } if (processUnbufferedMouseInput(evt) == false){ return false; } moveCamera(); return true; }
//! [10] void GLWidget::mouseMoveEvent(QMouseEvent *event) { const Qt::KeyboardModifiers modifiers = event->modifiers(); if(modifiers == Qt::AltModifier) { moveCamera(event); } else { Vector3F injp(16, 16, 16); fCamera->intersection(event->x(), event->y(), injp); int dx = event->x() - lastPos.x(); int dy = event->y() - lastPos.y(); Vector3F injv; fCamera->screenToWorld(dx, dy, injv); //qDebug() << "screen hit:" << event->x() << " " << event->y(); //qDebug() << "hit:" << injv.x << " " << injv.y << " " << injv.z; } lastPos = event->pos(); }
void updateEditorCamera(float interval, Vector3 marker) { static float distance = 5.0f; static float height = 2.0f; static Vector3 dest(0.0f, 0.0f, 0.0f); float angle; /* camera controls for editor */ /* zoom */ if (isKeyPressed('v')) distance += 0.1f; if (isKeyPressed('c') && distance > 0.5) distance -= 0.1f; /* rotation */ if (wasKeyPressed('b')) gCamAngle--; if (wasKeyPressed('n')) gCamAngle++; if (gCamAngle < 0) gCamAngle += 4; if (gCamAngle >= 4) gCamAngle -= 4; /* height */ if (isKeyPressed('x')) height += 0.1f; if (isKeyPressed('y')) height -= 0.1f; angle = gCamAngle * 90.0f; /* new camera position */ dest.x = sin(angle * M_PI / 180.0f) * distance + marker.x; dest.y = -cos(angle * M_PI / 180.0f) * distance + marker.y; dest.z = height + marker.z; moveCamera(interval, dest, marker); }
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 LLAgentPilot::startPlayback() { if (!mPlaying) { mPlaying = TRUE; mCurrentAction = 0; mTimer.reset(); if (mActions.count()) { llinfos << "Starting playback, moving to waypoint 0" << llendl; gAgent.startAutoPilotGlobal(mActions[0].mTarget); moveCamera(); mStarted = FALSE; } else { llinfos << "No autopilot data, cancelling!" << llendl; mPlaying = FALSE; } } }
bool Commands::config(void) { bool done = false; long ts = millis(); int diff = ts - mLastTS; if (diff >= 50) { switch (mCfgIdx) { case 0: setDate(); break; case 1: setTime(); break; case 2: requestStates(); break; case 3: requestSettings(); break; case 4: moveCamera(0, 0); break; case 5: enableVideoAutoRecording(0); break; case 6: enableVideoStreaming(0); done = true; break; } mCfgIdx++; mLastTS = ts; } return done; }
//键盘输入检测 void GLManager::keyPress(unsigned char key, int x, int y) { switch(key){ case VK_SPACE: //暂停和全局观察之间切换 if(state == GLOBAL){ state = PAUSE; } else if(state == PAUSE){ state = GLOBAL; } break; case VK_ESCAPE: //从细节模式返回全局模式 if(state == VIEW_DETAIL){ state = LEAVING; } break; //摄像机的移动 case 'w': moveCamera(UP); break; case 's': moveCamera(DOWN); break; case 'a': moveCamera(LEFT); break; case 'd': moveCamera(RIGHT); break; case 'q': moveCamera(FRONT); break; case 'e': moveCamera(BACK); break; } }
void SimObjectRenderer::draw() { // update a moving camera if(moving) { unsigned int now = System::getTime(); int x = 0; int y = 0; if(movingLeftStartTime) { x -= now - movingLeftStartTime; movingLeftStartTime = now; } if(movingRightStartTime) { x += now - movingRightStartTime; movingRightStartTime = now; } if(movingUpStartTime) { y -= now - movingUpStartTime; movingUpStartTime = now; } if(movingDownStartTime) { y += now - movingDownStartTime; movingDownStartTime = now; } moveCamera(float(x) * 0.001f, float(y) * 0.002f); } // set flags if(renderFlags & enableLights) glEnable(GL_LIGHTING); else glDisable(GL_LIGHTING); if(renderFlags & enableMultisample) glEnable(GL_MULTISAMPLE); else glDisable(GL_MULTISAMPLE); if(renderFlags & enableTextures) glEnable(GL_TEXTURE_2D); else glDisable(GL_TEXTURE_2D); // clear glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // load camera position glLoadMatrixf(cameraTransformation); // make sure transformations of movable bodies are up-to-date // note: a not-physical-object has a constant offset pose relative its parent. hence there is no transformation update required to draw not-physical-objects PhysicalObject* physicalObject = dynamic_cast<PhysicalObject*>(&simObject); GraphicalObject* graphicalObject = dynamic_cast<GraphicalObject*>(&simObject); if(physicalObject) Simulation::simulation->scene->updateTransformations(); // since each object will be drawn relative to its parent we need to shift the coordinate system when we want the object to be in the center if(&simObject != Simulation::simulation->scene && !(renderFlags & showAsGlobalView)) { const float* transformation = simObject.transformation; Pose3<> pose(Matrix3x3<>(Vector3<>(transformation[0], transformation[1], transformation[2]), Vector3<>(transformation[4], transformation[5], transformation[6]), Vector3<>(transformation[8], transformation[9], transformation[10])), Vector3<>(transformation[12], transformation[13], transformation[14])); float invTrans[16]; OpenGLTools::convertTransformation(pose.invert(), invTrans); glMultMatrixf(invTrans); } // draw origin if(renderFlags & showCoordinateSystem) { Simulation::simulation->scene->defaultSurface->set(); glBegin(GL_LINES); glNormal3f (0,0,1); glColor3f(1, 0, 0); glVertex3f(0, 0, 0); glVertex3f(1, 0, 0); glColor3f(0, 1, 0); glVertex3f(0, 0, 0); glVertex3f(0, 1, 0); glColor3f(0, 0, 1); glVertex3f(0, 0, 0); glVertex3f(0, 0, 1); glEnd(); Simulation::simulation->scene->defaultSurface->unset(); } // draw object / scene appearance if(graphicalObject && surfaceShadeMode != noShading) { switch(surfaceShadeMode) { case flatShading: glPolygonMode(GL_FRONT, GL_FILL); glShadeModel(GL_FLAT); break; case wireframeShading: glPolygonMode(GL_FRONT, GL_LINE); glShadeModel(GL_FLAT); break; case smoothShading: glPolygonMode(GL_FRONT, GL_FILL); glShadeModel(GL_SMOOTH); break; default: ASSERT(false); break; } graphicalObject->drawAppearances(); // check matrix stack size #ifdef _DEBUG int stackDepth; glGetIntegerv(GL_MODELVIEW_STACK_DEPTH, &stackDepth); ASSERT(stackDepth == 1); #endif } // draw object / scene physics if(physicalObject && (physicsShadeMode != noShading || renderFlags & showSensors)) { Simulation::simulation->scene->defaultSurface->set(); unsigned int renderFlags = (this->renderFlags | showPhysics) & ~showControllerDrawings; switch(physicsShadeMode) { case noShading: glPolygonMode(GL_FRONT, GL_LINE); glShadeModel(GL_FLAT); renderFlags &= ~showPhysics; break; case flatShading: glPolygonMode(GL_FRONT, GL_FILL); glShadeModel(GL_FLAT); break; case wireframeShading: glPolygonMode(GL_FRONT, GL_LINE); glShadeModel(GL_FLAT); break; case smoothShading: glPolygonMode(GL_FRONT, GL_FILL); glShadeModel(GL_SMOOTH); break; default: ASSERT(false); break; } physicalObject->drawPhysics(renderFlags); Simulation::simulation->scene->defaultSurface->unset(); // check matrix stack size #ifdef _DEBUG int stackDepth; glGetIntegerv(GL_MODELVIEW_STACK_DEPTH, &stackDepth); ASSERT(stackDepth == 1); #endif } // draw drag plane if(dragging && dragSelection) { Simulation::simulation->scene->defaultSurface->set(); glPolygonMode(GL_FRONT, GL_FILL); glShadeModel(GL_FLAT); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_SRC_ALPHA); glPushMatrix(); if(dragType == dragRotate || dragType == dragNormalObject) glMultMatrixf(dragSelection->transformation); else glTranslatef(dragSelection->pose.translation.x, dragSelection->pose.translation.y, dragSelection->pose.translation.z); switch(dragPlane) { case xyPlane: break; // do nothing case xzPlane: glRotatef(90.f, 1.f, 0.f, 0.f); break; case yzPlane: glRotatef(90.f, 0.f, 1.f, 0.f); break; } GLUquadricObj* q = gluNewQuadric(); glColor4f(0.5f, 0.5f, 0.5f, 0.5f); glNormal3f(0,0,1); gluDisk(q, 0.003f, 0.5f, 30, 1); glRotatef(180.f, 1.f, 0.f, 0.f); gluDisk(q, 0.003f, 0.5f, 30, 1); gluDeleteQuadric(q); glPopMatrix(); glDisable(GL_BLEND); Simulation::simulation->scene->defaultSurface->unset(); } // draw controller drawings if(physicalObject && drawingsShadeMode != noShading) { Simulation::simulation->scene->defaultSurface->set(); switch(drawingsShadeMode) { case flatShading: glPolygonMode(GL_FRONT, GL_FILL); glShadeModel(GL_FLAT); break; case wireframeShading: glPolygonMode(GL_FRONT, GL_LINE); glShadeModel(GL_FLAT); break; case smoothShading: glPolygonMode(GL_FRONT, GL_FILL); glShadeModel(GL_SMOOTH); break; default: ASSERT(false); break; } if(renderFlags & (enableDrawingsTransparentOcclusion | enableDrawingsOcclusion)) { physicalObject->drawPhysics(showControllerDrawings); if(renderFlags & enableDrawingsTransparentOcclusion) { glAccum(GL_LOAD, 0.5f); glClear(GL_DEPTH_BUFFER_BIT); physicalObject->drawPhysics(showControllerDrawings); glAccum(GL_ACCUM, 0.5f); glAccum(GL_RETURN, 1.f); } } else { glClear(GL_DEPTH_BUFFER_BIT); physicalObject->drawPhysics(showControllerDrawings); } Simulation::simulation->scene->defaultSurface->unset(); // check matrix stack size #ifdef _DEBUG int stackDepth; glGetIntegerv(GL_MODELVIEW_STACK_DEPTH, &stackDepth); ASSERT(stackDepth == 1); #endif } }