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);
}
Exemple #4
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:*/
        }
    }
}
Exemple #5
0
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));
}
Exemple #6
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();
}
Exemple #8
0
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);
}
Exemple #9
0
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);

    }
}
Exemple #10
0
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;
}
Exemple #11
0
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();
}
Exemple #15
0
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);
}
Exemple #17
0
//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);
}
Exemple #18
0
			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();
    }
}
Exemple #20
0
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()));
		}
	}
Exemple #22
0
//************** 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;
}
Exemple #24
0
//! [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();
}
Exemple #25
0
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();
}
Exemple #27
0
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;
		}
	}
}
Exemple #28
0
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
  }
}