C++ Clock::Reset方法代码示例

int main(int argc, char* argv[])
{


    char filename[] = "doom-e1m1.mid";
      RtMidiOut *midiout = new RtMidiOut();
    string portName;
    
    nPorts = midiout->getPortCount();
 
    if(argc < 2)    {
        if ( nPorts == 0 )     cout << "No ports available!\n";
        for ( unsigned int i=0; i<nPorts; i++ ) {
            try { portName = midiout->getPortName(i);    }
             catch (RtError &error) {error.printMessage(); }
            cout << "  Output Port #" << i+1 << ": " << portName << '\n';
        }
    }else{
        int port = atoi(argv[1]);
          //midiout->openPort( port );

        cout << "Opening midi" << endl;    
        char *filef = argv[2];
        if(argc == 3)
            parser.Open(filef);
        else
            parser.Open(filename);
    
        tickspersecond = ( (parser.bpm / 30.0) * ( parser.tpb));
        cout << " Ticks per second: " << tickspersecond << endl;
        
        (void) signal(SIGINT, finish);
        tickcount = 0;

        Sequencer sequencers[parser.numtracks];
        SequencerRunning = true;
        for(int i=0;i<parser.numtracks;i++)    {
            sequencers[i].StartSequencer(i, &parser.mididata.tracks[i], port);
            sf::Sleep(0.01f);
        }
        sf::Sleep(1);
        timer.Reset();
        while(run)    {
            timecount = timer.GetElapsedTime();
            tickcount += timecount * tickspersecond;
            timer.Reset();
            //sf::Sleep(0.0001f);
        }
    }
    delete midiout;    
    finish(0);
    return 0;
}

void Train::Update(const sf::Input &input) {
    
        static sf::Clock clock;
        static bool waiting = false;

        acceleration = (1/mass) *(push_force - speed * brakes_factor);
        speed += acceleration;
        position.z += speed;

        if (position.z > 900 || position.z < -900) {
            position.z = -position.z;
            //comingSound.SetPosition(this->position);
            comingSound.Play();
            StopGas();
        }
    if (!user_controlled){
        if (position.z < -250 && position.z > -300){
            StopGas();
            Brakes();
        }
        if (IsStopped() && !waiting){
            clock.Reset();
            alarm=false;
            waiting = true;
            printf("\n\n\n                         waiting\n");        

        }
        if (waiting && clock.GetElapsedTime() > waiting_time) {
            Gas();        
            waiting = false;        
            printf("                         timed out\n");
        }
        if (waiting && clock.GetElapsedTime() > waiting_time-4 && !alarm) {
            alarm=true;
                sound.SetBuffer(Buffer);             
                //sound.SetPitch(0.6);
                //sound.SetAttenuation(0.4);
                sound.SetRelativeToListener(true);
                sound.SetPosition(this->position);
                sound.SetMinDistance(100);
                sound.Play();
                //movmetnSound.SetPosition(this->position);
                movmetnSound.Play();
        }


        light->position = sf::Vector3f(-40.900002,10,position.z + 5) ;

        if(camera !=NULL)
            camera->SetOrigin(position.x+8.3,position.y+15,position.z);
    }else {
        if (input.IsKeyDown(sf::Key::Z)) {
            push_force = 0.1f;
        }else if (input.IsKeyDown(sf::Key::X)){
            brakes_factor = 0.05f;
        }
        
    }

}

 // called every couple of lines. Use it to check for events
 void Turing_StdlibSFML_PeriodicCallback() {
     // check every quarter of a second. This does make input delayed.
     // It only stops the system from deeming us unresponsive
     if(WinMan && eventClock.GetElapsedTime() > 0.5) {
         WinMan->surface();
         eventClock.Reset();
     }
 }

int main(int argc, const char **argv)
{	
	init(argc, argv);
	loadAssets();
	while (window.IsOpened()) {
		clockdiff = clck.GetElapsedTime();
		elapsed += clockdiff;
		clck.Reset();
		inputFn();
		renderFn();
		window.Display();
	}
	return 0;
}

sf::Vector2f cHero::getMovement(const sf::Input & theInput, sf::Clock & jumpClock)
{
    sf::Vector2f movementVector;
    xSpeed = 0;
    ySpeed = 0;

    // horizontal movement
    if (theInput.IsKeyDown(sf::Key::Left)) {
        xSpeed += -5;
        xAccel += -.2;
    }
    else if (theInput.IsKeyDown(sf::Key::Right)) {
        xSpeed += 5;
        xAccel += .2;
    }


    // vertical movement
    if (theInput.IsKeyDown(sf::Key::Up)) {
        if (isOnGround()) {
            jumpClock.Reset();
            //ySpeed = -8;
        }
        if (jumpClock.GetElapsedTime() < .3) {
            yAccel -= .12 / (jumpClock.GetElapsedTime());
            ySpeed = 30 * (jumpClock.GetElapsedTime() - .3);
        }
    }
    if (isOnGround()) {
        yAccel = 0;
        if (xAccel > .2)
            xAccel -= .05;
        else if (xAccel < -.2)
            xAccel += .05;
    }
    else {
        yAccel += 1 + (jumpClock.GetElapsedTime() / 20);
    }

    movementVector.x = xSpeed + xAccel;
    movementVector.y = ySpeed + yAccel;

    return movementVector;
}

void GameServer::update()
{
  static sf::Clock clock;

  if (clock.GetElapsedTime() > 150)
  {

    while (client_->commandAvailable())
    {
      client_->getCommand()->execute (this);
    }

    clock.Reset();
  }
  
  std::vector<ActionArray::iterator> to_remove;
  ActionArray to_add;

  for (ActionArray::iterator it = actions_.begin(); it != actions_.end(); it ++)
  {
    if ((*it)->isDone())
    {
      //if ((*it)->hasNextAction())
      
      to_remove.push_back(it);
    }
    else
    {
      if ((*it)->isActive())
        (*it)->update();
    }
      
    client_->sendData ((*it)->getUnit()->getStatus());
  }

  for (std::vector<ActionArray::iterator>::reverse_iterator it = to_remove.rbegin(); 
       it != to_remove.rend(); it ++)
  {
    delete (*(*it));
    actions_.erase(*it);
  }

}

void World::update(float time)
{
  static sf::Clock timer;
  static int flag = 0;
  if (timer.GetElapsedTime() > 1) {
      timer.Reset();
	  for ( vector<Dynamic*>::iterator i = dynamicList.begin(); i != dynamicList.end(); i++ ) {
	  	if ( !(*i)->echo() ) {
		  if ( !Manager::Instance()->check( (*i)->getPosition() , (*i)->getSize() ) ) {
		  	 Manager::Instance()->clearMatch();
			 Manager::Instance()->updatePath( (*i)->getPosition() , (*i)->getSize() );
		  	 for ( vector<Dynamic*>::iterator i = dynamicList.begin(); i != dynamicList.end(); i++ ) {
				 if ( !(*i)->echo() ) continue;
				 Manager::Instance()->collect( (*i)->getID() , (*i)->getPosition() );
			 }
			 Manager::Instance()->solve();
		  } else {
			 for ( vector<Dynamic*>::iterator i = dynamicList.begin(); i != dynamicList.end(); i++ ) {
			 	 if ( !(*i)->echo() ) {
					int t = -1;
					Manager::Instance()->updatePos( t , (*i)->getPosition() );
				 } else Manager::Instance()->updatePos( (*i)->getID() , (*i)->getPosition() );
			 }
			 Manager::Instance()->attack();
		  }
		  break;
		}
	  }
  }
  for (vector<Dynamic*>::iterator i = dynamicList.begin(); i != dynamicList.end(); ++ i)
    {
      (*i)->update(time);
    }
  

  Camera::Instance()->update(time);
}

void init()
{
	// Create the main window
	App = new sf::Window(sf::VideoMode(RESOLUTION_X, RESOLUTION_Y, 32), "Modeling Program");
		
	// Create a clock for measuring time elapsed
	Clock = sf::Clock();
		
	__glewInit();

	currentRes[0] = RESOLUTION_X;
	currentRes[1] = RESOLUTION_Y;

	transM = TRANS_TRANSLATION;
	axisM = X_AXIS;

	selected = 0;
	idCounter = 1;

	//Initial light position
	lightPos[0] = 2.0f;
	lightPos[1] = 2.0f;
	lightPos[2] = 2.0f;

	//Initial camera position
	cameraPos[0] = 0.0f;
	cameraPos[1] = 0.0f;
	cameraPos[2] = 0.0f;

	//Perspective setup
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(45.0,currentRes[0]/currentRes[1], 0.5, 50.0);
	glMatrixMode(GL_MODELVIEW);
	
	//Camera setup
	camera = Camera();
	camera.translate(0.0,0.0,20.0);
	camera.rotate(60.0, 1.0, 0.0, 0.0);
	camera.rotate(30.0, 0.0, 0.0, 1.0);
	camera.apply_transformations();
	
	//setup render target texture
	//this will eventually hald the rendered scene and be
	//rendered to a quad for post process effects
	/*int numTex = 1;
	glGenTextures(numTex, &textureTarget);
	setupTargetTexture();*/

	//setup the shader programs
	//the first set is the vertex and fragment shaders for the 3D render
	//the second set is the shaders for the texture post process effects
	ShaderManager shaders;
	shaders.GL20Support = GL20Support;
	char const * drawVert = "Shaders/Render3dModel.vert";
	char const * drawFrag = "Shaders/Render3dModel.frag";
	shaderProg = shaders.buildShaderProgram(&drawVert, &drawFrag, 1, 1);
		
	/*char const * texVert = "Shaders/RenderTexture.vert";
	char const * texFrag = "Shaders/RenderTexture.frag";
	texProg = shaders.buildShaderProgram(&texVert, &texFrag, 1, 1);*/

	char const * noLightVert = "Shaders/NoLighting.vert";
	char const * noLightFrag = "Shaders/NoLighting.frag";
	noLightProg = shaders.buildShaderProgram(&noLightVert, &noLightFrag, 1, 1);

	//this object helps draw textures that fill the viewport
	/*texRender = ShowTexture(texProg);
	texRender.GL20Support = GL20Support;*/

	// Bind custom attributes
	glBindAttribLocation(shaderProg, 1, "ambient");

	// Start render loop
	while (App->IsOpened())
	{
		Clock.Reset();
		// Process events
		handleEvents();
		
		// Set the active window before using OpenGL commands
		// It's useless here because active window is always the same,
		// but don't forget it if you use multiple windows or controls
		App->SetActive();
			
		//render 3D scene, then put 2D output in texture, render texture
		renderScene();
						
		// Finally, display rendered frame on screen
		App->Display();
		float diff = 1.0/FPS-Clock.GetElapsedTime();
		if(diff > 0)
			sf::Sleep(diff);
	}
}

int main()
{
    // Open the serial port for reading:
    ardu.Open(PORT);    
    ardu.SetBaudRate(SerialStreamBuf::BAUD_115200);  
    ardu.SetCharSize(SerialStreamBuf::CHAR_SIZE_8);

    char str[8];
    // ardu << out;
    ardu >> str;
    std::cout << str;

    //sscanf(str,"%d",&res);


    //sleep(1);
    //serial_send(fd, 'A');
    sleep(1);
    //while(result != 'A')
    return 1;

    while(true)
    {
    ardu >> str;
    std::cout << str;
	//int test = read(fd, &byte, 1);
        //serial_send(fd, 'A');
        //printf("%i %i %c\n", test, byte, byte); 
        //sleep(1);
    }

    // Set the last signalled state of the system as sent by the opto signal over USB.
    // "t" is top-dead-center, and "b" is bottom-dead-center.
    char system_state = 'B';
    int image_counter = image_counter_min;    

    // Create the main rendering window
    sf::RenderWindow App(sf::VideoMode(800, 600, 32), "SFML Graphics");

    // Use v-sync (make it so that we sync with the monitor, and don't draw more than 60fps.
    App.UseVerticalSync(false);
    // App.SetFramerateLimit(60); // Limit to 60 frames per second
    // App.SetFramerateLimit(0);  // No limit

    // Start game loop
    while (App.IsOpened())
    {
        // Process events
        sf::Event Event;
        while (App.GetEvent(Event))
        {
            // Close window : exit
            if (Event.Type == sf::Event::Closed)
                App.Close();

            // A key has been pressed
            if (Event.Type == sf::Event::KeyPressed)
            {
                // Escape key : exit
                if (Event.Key.Code == sf::Key::Escape)
                    App.Close();
            }
        }

        // Read from the USB port.
        uint8_t input_state; //= serial_recv(fd);
        printf("%i ", input_state);
        if (input_state != system_state && (input_state == 'B' || input_state == 'T'))
        {   // Start the appropriate image sequence.

            // Change the system state.
            system_state = input_state;
            //printf("%c\n", system_state);
            
            // Reset the image counter.
            image_counter = 0; 
        }

        // Get the elapsed time.
        float elapsed = Clock.GetElapsedTime();
        if (elapsed > refresh_rate)
        {
            // Update the image.
            printf("%i %f\n", image_counter, elapsed);
            Clock.Reset();

            // Increment or decrement the image counter.
            if (system_state == 'B') image_counter++;
            else if (system_state == 'T') image_counter++;
            
            // Make sure the counter doesn't go out of bounds.
            if (image_counter > image_counter_max) image_counter = image_counter_max;
            if (image_counter < image_counter_min) image_counter = image_counter_min;

            // Draw the appropriate colour:
            switch( image_counter ) 
            {
                case 0:
                    App.Clear(sf::Color(0, 0, 0));
                    break;
//.........这里部分代码省略.........