void Sample::think(double time)
{
  static bool oddStep = true;

  //
  // CUDA Compute
  //

  // PASS 0 (compute): compute the volume scalar field for the next time step
  simulateOpenCL( /*dt =*/ 0.5f, oddStep);  // 0.5 happens to be numerically stable for this simple explicit heat propagator


  //
  // OpenGL Visualize
  //

  // Update any camera changes
  viewUpdate();

  // PASS 1: Frontface distance
  renderGLFrontface();

  // PASS 2: Volume raycasting
  renderGLVolume(oddStep);
  oddStep = !oddStep;

  // ...Draw the UI

  renderUI(getWidth(), getHeight(), time - m_prevTime);
  m_prevTime = time;
}
bool WMTemplateRoiSelection::processCompute( WLEMMeasurement::SPtr emm )
{
    WLTimeProfiler tp( "WMTemplateRoiSelection", __func__ );

    // show process visualization
    WProgress::SPtr processComp( new WProgress( "Do the process." ) );
    m_progress->addSubProgress( processComp );

    // ---------- PROCESSING ----------
    viewUpdate( emm );

    // ---------- OUTPUT ----------
    WLEMMCommand::SPtr cmd( new WLEMMCommand( WLEMMCommand::Command::COMPUTE ) );
    cmd->setEmm( emm );
    m_output->updateData( cmd ); // update the output-connector after processing

    processComp->finish(); // finish the process visualization

    return true;
}
Esempio n. 3
0
bool MasterConfig::handleEvent( eq::EventCommand command )
{
    switch( command.getEventType( ))
    {
      case eq::Event::CHANNEL_POINTER_BUTTON_PRESS:
      {
          const eq::Event& event = command.get< eq::Event >();
          _currentViewID = event.context.view.identifier;
          return true;
      }

      case eq::Event::KEY_PRESS:
      case eq::Event::KEY_RELEASE:
          if( Config::handleEvent( command ))
          {
              _redraw = true;
              LBVERB << "Redraw: requested by eq::Config" << std::endl;
          }
          // no break;
      case eq::Event::CHANNEL_POINTER_BUTTON_RELEASE:
      case eq::Event::CHANNEL_POINTER_MOTION:
      case eq::Event::WINDOW_POINTER_WHEEL:
      case eq::Event::MAGELLAN_AXIS:
      {
          if( _currentViewID == uint128_t::ZERO )
              return false;

          View* view = static_cast<View*>( find<eq::View>( _currentViewID ));
          if( view->handleEvent( command ))
          {
              _redraw = true;
              LBVERB << "Redraw: requested by view event handler" << std::endl;
          }
          return true;
      }

      case eq::Event::STATISTIC:
      {
          Config::handleEvent( command );
          const eq::Event& event = command.get< eq::Event >();
          if( event.statistic.type != eq::Statistic::CONFIG_FINISH_FRAME )
              return false;

          ViewUpdateVisitor viewUpdate( _redraw );
          accept( viewUpdate );
          return _redraw;
      }

      case eq::Event::WINDOW_EXPOSE:
      case eq::Event::WINDOW_RESIZE:
      case eq::Event::WINDOW_CLOSE:
      case eq::Event::VIEW_RESIZE:
          _redraw = true;
          LBVERB << "Redraw: window change" << std::endl;
          break;

      default:
          break;
    }

    if( eq::Config::handleEvent( command ))
    {
        _redraw = true;
        LBVERB << "Redraw: requested by config event handler" << std::endl;
    }
    return _redraw;
}
Esempio n. 4
0
// Game Start Methode.
void Game::run()
{
	// Initalisierung einer Uhr
	sf::Time timeSinceLastUpdate = sf::Time::Zero;
	Player.setName(XMLDoc.loadPlayerName());
	Player.setPosition(200,200);
	begin = clock();

	// Solange das Fenster Offen ist.
	while (Window.isOpen())
	{
		sf::Time frameTime = frameClock.restart();
		timeSinceLastUpdate += frameTime;
		initPlayerPosition();

		// Überprüfung ob man gewonnen hat.
		if(World.checkGoal())
		{
			bool RankingSuccess = false;
			end = clock(); // Zeit messung ende.
			// Zeit in Sekunden ausrechnen.
			elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
			// Zum Zeit in Int umwandeln für die Sekunden.
			if(checkRanking((int)elapsed_secs))
			{
				RankingSuccess = true;
			}
			Window.close();
			InfoFenster.Window_Success(RankingSuccess);
		}

		// Game Over wenn 0 Leben.
		if(Player.getLeben() == 0)
		{
			Window.close();
			InfoFenster.Abspann(600, 600);
		}

		while (timeSinceLastUpdate > TimePerFrame)
		{
			timeSinceLastUpdate -= TimePerFrame;
			processEvents();
			update(TimePerFrame);
		}
	
		// Gravitation erstellen.
		GravityFall();
		GravityUp();
		
		// Auswertung Kollision.
		if(World.checkKollision())
		{
			Player.MinusLeben();
			movement.x =- 5000.f;
		}

		//Bewegung ausführen
		Player.AnimationTest(movement, frameTime, 0, PlayerModel);

		// View anpassen.
		viewUpdate();

		// Wenn keine Taste gedrückt, Animation stoppen.
		if (noKeyWasPressed)
        {
			Player.AnimationTest(movement, frameTime, 1, PlayerModel);
        }

		noKeyWasPressed = true;

		// Drawn des Games
		render();
	}
}
bool WMHeadPositionCorrection::processCompute( WLEMMeasurement::SPtr emm )
{
    if( !emm->hasModality( WLEModality::MEG ) )
    {
        errorLog() << "No MEG data available!";
        return false;
    }
    if( !emm->hasModality( WLEModality::HPI ) )
    {
        errorLog() << "No HPI data available!";
        return false;
    }
    if( !m_hasRefPos )
    {
        if( !emm->getHpiInfo()->getDevToHead()->empty() )
        {
            WLEMMHpiInfo::TransformationT::SPtr t = emm->getHpiInfo()->getDevToHead()->inverse();
            m_correction.setRefTransformation( *t );
            m_hasRefPos = true;
            m_propStatus->set( STATUS_REF_POS, true );
            infoLog() << "Set reference position from EMM: \n" << *t;
        }
        else
        {
            errorLog() << "No reference head position!";
            return false;
        }
    }

    WLTimeProfiler profiler( getName(), __func__, true );

    WLEMDMEG::SPtr meg = emm->getModality< WLEMDMEG >( WLEModality::MEG );
    WLEMDHPI::SPtr hpi = emm->getModality< WLEMDHPI >( WLEModality::HPI );
    WLEMDMEG::SPtr megOut( new WLEMDMEG( *meg ) );

    if( !m_correction.isInitialzied() )
    {
        WLEMDMEG::createCoilInfos( meg.get() );
        m_correction.setMegCoilInfos( meg->getCoilInformation() );
        m_correction.setMovementThreshold( m_propMvThreshold->get( false ) );
        m_correction.setSphereRadius( m_propRadius->get( false ) );
        m_correction.init();
    }

    if( !m_correction.process( megOut.get(), *meg, *hpi ) )
    {
        errorLog() << "Error in correcting head position!";
        return false;
    }

    WLEMMeasurement::SPtr emmOut = emm->clone();
    std::vector< WLEMData::SPtr > mods = emm->getModalityList();
    for( size_t i = 0; i < mods.size(); ++i )
    {
        if( mods[i]->getModalityType() == WLEModality::MEG )
        {
            mods[i] = megOut;
            break;
        }
    }
    emmOut->setModalityList( mods );
    viewUpdate( emmOut );

    WLEMMCommand::SPtr cmdOut( new WLEMMCommand( WLEMMCommand::Command::COMPUTE ) );
    cmdOut->setEmm( emmOut );
    m_output->updateData( cmdOut );

    return true;
}