bool Config::init()
{
if( !_animation.isValid( ))
_animation.loadAnimation( _initData.getPathFilename( ));
// init distributed objects
if( !_initData.useColor( ))
_frameData.setColorMode( COLOR_WHITE );
_frameData.setRenderMode( _initData.getRenderMode( ));
registerObject( &_frameData );
_frameData.setAutoObsolete( getLatency( ));
_initData.setFrameDataID( _frameData.getID( ));
registerObject( &_initData );
// init config
if( !eq::Config::init( _initData.getID( )))
{
_deregisterData();
return false;
}
_loadModels();
_registerModels();
const eq::Canvases& canvases = getCanvases();
if( canvases.empty( ))
_currentCanvas = 0;
else
_currentCanvas = canvases.front();
_setMessage( "Welcome to eqPly\nPress F1 for help" );
return true;
}
bool Config::init()
{
// init distributed objects
LBCHECK(registerObject(&_frameData));
_frameData.setOrtho(_initData.getOrtho());
_initData.setFrameDataID(_frameData.getID());
_frameData.setAutoObsolete(getLatency());
LBCHECK(registerObject(&_initData));
// init config
if (!eq::Config::init(_initData.getID()))
{
_deregisterData();
return false;
}
const eq::Canvases& canvases = getCanvases();
if (canvases.empty())
_currentCanvas = 0;
else
_currentCanvas = canvases.front();
_setMessage("Welcome to eVolve\nPress F1 for help");
return true;
}
void Config::deregisterObject( co::Object* object )
{
EQASSERT( object )
EQASSERT( object->isMaster( ));
if( !object->isAttached( )) // not registered
return;
const uint32_t latency = getLatency();
ClientPtr client = getClient();
if( latency == 0 || !_running || !object->isBuffered( )) // OPT
{
client->deregisterObject( object );
return;
}
// Keep a distributed object latency frames.
// Replaces the object with a dummy proxy object using the
// existing master change manager.
ConfigSwapObjectPacket packet;
packet.requestID = getLocalNode()->registerRequest();
packet.object = object;
send( client, packet );
client->waitRequest( packet.requestID );
}
bool Config::registerObject( co::Object* object )
{
if( !getClient()->registerObject( object ))
return false;
object->setAutoObsolete( getLatency() + 1 );
return true;
}
void Config::setLatency( const uint32_t latency )
{
if( getLatency() == latency )
return;
Super::setLatency( latency );
changeLatency( latency );
}
void Config::_frameStart()
{
_frameTimes.push_back( _clock.getTime64( ));
while( _frameTimes.size() > getLatency() )
{
const int64_t age = _frameTimes.back() - _frameTimes.front();
getClient()->expireInstanceData( age );
_frameTimes.pop_front();
}
}
bool Config::init()
{
if( !_animation.isValid( ))
_animation.loadAnimation( _initData.getPathFilename( ));
// init distributed objects
if( !_initData.useColor( ))
_frameData.setColorMode( COLOR_WHITE );
_frameData.setRenderMode( _initData.getRenderMode( ));
registerObject( &_frameData );
_frameData.setAutoObsolete( getLatency( ));
_initData.setFrameDataID( _frameData.getID( ));
registerObject( &_initData );
// init config
if( !eq::Config::init( _initData.getID( )))
{
_deregisterData();
return false;
}
_loadModels();
_registerModels();
// init tracker
if( !_initData.getTrackerPort().empty( ))
{
if( !_tracker.init( _initData.getTrackerPort() ))
LBWARN << "Failed to initialize tracker" << std::endl;
else
{
// Set up position of tracking system wrt world space
// Note: this depends on the physical installation.
eq::Matrix4f m( eq::Matrix4f::IDENTITY );
m.scale( 1.f, 1.f, -1.f );
_tracker.setWorldToEmitter( m );
m = eq::Matrix4f::IDENTITY;
m.rotate_z( -M_PI_2 );
_tracker.setSensorToObject( m );
LBINFO << "Tracker initialized" << std::endl;
}
}
const eq::Canvases& canvases = getCanvases();
if( canvases.empty( ))
_currentCanvas = 0;
else
_currentCanvas = canvases.front();
_setMessage( "Welcome to eqPly\nPress F1 for help" );
return true;
}
void Config::changeLatency( const uint32_t latency )
{
if( getLatency() == latency )
return;
setLatency( latency );
// update latency on all frames and barriers
ChangeLatencyVisitor visitor( latency );
accept( visitor );
}
uint32_t Config::finishFrame()
{
ClientPtr client = getClient();
const uint32_t latency = getLatency();
const uint32_t frameToFinish = (_currentFrame >= latency) ?
_currentFrame - latency : 0;
ConfigStatistics stat( Statistic::CONFIG_FINISH_FRAME, this );
stat.event.data.statistic.frameNumber = frameToFinish;
{
ConfigStatistics waitStat( Statistic::CONFIG_WAIT_FINISH_FRAME, this );
waitStat.event.data.statistic.frameNumber = frameToFinish;
// local draw sync
if( _needsLocalSync( ))
while( _unlockedFrame < _currentFrame )
client->processCommand();
// local node finish (frame-latency) sync
const Nodes& nodes = getNodes();
if( !nodes.empty( ))
{
EQASSERT( nodes.size() == 1 );
const Node* node = nodes.front();
while( node->getFinishedFrame() < frameToFinish )
client->processCommand();
}
// global sync
const uint32_t timeout = getTimeout();
co::base::Clock time;
const int64_t pingTimeout = co::Global::getKeepaliveTimeout();
while( !_finishedFrame.timedWaitGE( frameToFinish, pingTimeout ))
{
if( time.getTime64() >= timeout || !getLocalNode()->pingIdleNodes())
{
EQWARN << "Timeout waiting for nodes to finish frame "
<< frameToFinish << std::endl;
break;
}
}
}
handleEvents();
_updateStatistics( frameToFinish );
_releaseObjects();
EQLOG( co::base::LOG_ANY ) << "---- Finished Frame --- " << frameToFinish
<< " (" << _currentFrame << ')' << std::endl;
return frameToFinish;
}
void Config::_verifyFrameFinished( const uint32_t frameNumber )
{
const Nodes& nodes = getNodes();
for( Nodes::const_iterator i = nodes.begin(); i != nodes.end(); ++i )
{
Node* node = *i;
if( node->isRunning() &&
node->getFinishedFrame() + getLatency() < frameNumber )
{
NodeFailedVisitor nodeFailedVisitor;
node->accept( nodeFailedVisitor );
}
}
}
bool Config::init()
{
_frameData.setCameraTransformation(_cameraFrame.getTransform());
registerObject(&_frameData);
_frameData.setAutoObsolete(getLatency());
_initData.setFrameDataId(_frameData.getID());
registerObject(&_initData);
if (!eq::Config::init(_initData.getID())) {
return false;
}
return true;
}
status_t AudioSystem::getOutputLatency(uint32_t* latency, audio_stream_type_t streamType)
{
audio_io_handle_t output;
if (streamType == AUDIO_STREAM_DEFAULT) {
streamType = AUDIO_STREAM_MUSIC;
}
output = getOutput(streamType);
if (output == 0) {
return PERMISSION_DENIED;
}
return getLatency(output, streamType, latency);
}
bool Config::_cmdSwapObject( co::Command& command )
{
const ConfigSwapObjectPacket* packet =
command.get<ConfigSwapObjectPacket>();
EQVERB << "Cmd swap object " << packet << std::endl;
co::Object* object = packet->object;
LatencyObject* latencyObject = new LatencyObject( object->getChangeType(),
object->chooseCompressor(),
_currentFrame + getLatency() + 1 );
getLocalNode()->swapObject( object, latencyObject );
{
co::base::ScopedFastWrite mutex( _latencyObjects );
_latencyObjects->push_back( latencyObject );
}
EQASSERT( packet->requestID != EQ_UNDEFINED_UINT32 );
getLocalNode()->serveRequest( packet->requestID );
return true;
}
int getInputLatencyInSamples() override { return getLatency (kAudioSessionProperty_CurrentHardwareInputLatency); }
