void AppBase::privateUpdate__()
{
mFrameCount++;
// service asio::io_service
mIo->poll();
if( getNumWindows() > 0 ) {
WindowRef mainWin = getWindowIndex( 0 );
if( mainWin )
mainWin->getRenderer()->makeCurrentContext();
}
mSignalUpdate.emit();
update();
mTimeline->stepTo( static_cast<float>( getElapsedSeconds() ) );
double now = mTimer.getSeconds();
if( now > mFpsLastSampleTime + mFpsSampleInterval ) {
//calculate average Fps over sample interval
uint32_t framesPassed = mFrameCount - mFpsLastSampleFrame;
mAverageFps = (float)(framesPassed / (now - mFpsLastSampleTime));
mFpsLastSampleTime = now;
mFpsLastSampleFrame = mFrameCount;
}
}
void ViewerConfiguration::updateViewer(void)
{
if(viewer!=0)
{
/* Update the controlled viewer: */
Vector currentViewDirection=viewer->getHeadTransformation().inverseTransform(viewer->getViewDirection());
viewer->setEyes(currentViewDirection,eyePos[0],(eyePos[2]-eyePos[1])*Scalar(0.5));
/* Notify all VR windows that their viewers might have changed: */
int numWindows=getNumWindows();
for(int i=0;i<numWindows;++i)
getWindow(i)->updateViewerState(viewer);
}
}
/**********************************************************************************
Function Name = SecurityProjectDemoApp::createInfectedWindow
Descriptive Name = Create custom image with data inside.
Function =
This function is used to create windows based on the configuration that is passed in
to the function. Also supports adding images into the windows while creating the image.
Input =
std::string securityImageRef - The location of the image that needs to be displayed
int windowWidth - The width of the window
int windowHeight - The height of the window
int windowXPos - The x position where the window is to be placed
int windowYPos - The y position where the window is to be placed
Output =
Currently there are no outputs from this functions as it only performs the action.
******************************************************************************/
void SecurityProjectDemoApp::createInfectedWindow ( cinder::DataSourceRef securityImageRef, int windowWidth, int windowHeight, int windowXPos, int windowYPos )
{
// Load the image that was passed in into a proper format
gl::Texture securityImage = gl::Texture ( loadImage ( securityImageRef ) );
// Create the window of size passed in, set the image into the windowData object and set it as borderless and
app::WindowRef newWindow = createWindow ( Window::Format ().size ( windowWidth, windowHeight ) ) ;
newWindow->setUserData ( new WindowData ( securityImage ) );
newWindow->setBorderless ( true ) ;
newWindow->setPos ( windowXPos, windowYPos ) ;
newWindow->setTitle ( "SecurityProjectDemoApp" ) ;
// Get a unique id for the window that is used to identify the window
int uniqueId = getNumWindows () ;
// Set the unique number for the new window that was created
newWindow->getSignalClose ().connect (
[uniqueId, this]
{
this->console () << "You closed window #" << uniqueId << std::endl ; // Action performed when the window is closed
}
) ;
}
void InputDeviceAdapterPlayback::updateInputDevices(void)
{
/* Do nothing if at end of file: */
if(done)
return;
if(synchronizePlayback)
{
Misc::Time rt=Misc::Time::now();
double realTime=double(rt.tv_sec)+double(rt.tv_nsec)/1000000000.0;
if(firstFrame)
{
/* Calculate the offset between the saved timestamps and the system's wall clock time: */
timeStampOffset=nextTimeStamp-realTime;
}
else
{
/* Check if there is positive drift between the system's offset wall clock time and the next time stamp: */
double delta=nextTimeStamp-(realTime+timeStampOffset);
if(delta>0.0)
{
/* Block to correct the drift: */
vruiDelay(delta);
}
}
}
/* Update time stamp and synchronize Vrui's application timer: */
timeStamp=nextTimeStamp;
synchronize(timeStamp);
/* Start sound playback: */
if(firstFrame&&soundPlayer!=0)
soundPlayer->start();
/* Update all input devices: */
for(int device=0;device<numInputDevices;++device)
{
/* Update tracker state: */
if(inputDevices[device]->getTrackType()!=InputDevice::TRACK_NONE)
{
TrackerState::Vector translation;
inputDeviceDataFile.read(translation.getComponents(),3);
Scalar quat[4];
inputDeviceDataFile.read(quat,4);
inputDevices[device]->setTransformation(TrackerState(translation,TrackerState::Rotation::fromQuaternion(quat)));
}
/* Update button states: */
for(int i=0;i<inputDevices[device]->getNumButtons();++i)
{
int buttonState=inputDeviceDataFile.read<int>();
inputDevices[device]->setButtonState(i,buttonState);
}
/* Update valuator states: */
for(int i=0;i<inputDevices[device]->getNumValuators();++i)
{
double valuatorState=inputDeviceDataFile.read<double>();
inputDevices[device]->setValuator(i,valuatorState);
}
}
/* Read time stamp of next data frame: */
try
{
nextTimeStamp=inputDeviceDataFile.read<double>();
/* Request an update for the next frame: */
requestUpdate();
}
catch(Misc::File::ReadError)
{
done=true;
nextTimeStamp=Math::Constants<double>::max;
if(quitWhenDone)
{
/* Request exiting the program: */
shutdown();
}
}
if(saveMovie)
{
if(firstFrame)
{
/* Get a pointer to the window from which to save movie frames: */
if(movieWindowIndex>=0&&movieWindowIndex<getNumWindows())
movieWindow=getWindow(movieWindowIndex);
else
std::cerr<<"InputDeviceAdapterPlayback: Not saving movie due to invalid movie window index "<<movieWindowIndex<<std::endl;
}
if(movieWindow!=0)
{
/* Copy the last saved screenshot if multiple movie frames needed to be taken during the last Vrui frame: */
while(nextMovieFrameTime<timeStamp)
{
/* Copy the last saved screenshot: */
pid_t childPid=fork();
if(childPid==0)
{
/* Create the old and new file names: */
char oldImageFileName[1024];
snprintf(oldImageFileName,sizeof(oldImageFileName),movieFileNameTemplate.c_str(),nextMovieFrameCounter-1);
char imageFileName[1024];
snprintf(imageFileName,sizeof(imageFileName),movieFileNameTemplate.c_str(),nextMovieFrameCounter);
/* Execute the cp system command: */
char* cpArgv[10];
int cpArgc=0;
cpArgv[cpArgc++]=const_cast<char*>("/bin/cp");
cpArgv[cpArgc++]=oldImageFileName;
cpArgv[cpArgc++]=imageFileName;
cpArgv[cpArgc++]=0;
execvp(cpArgv[0],cpArgv);
}
else
{
/* Wait for the copy process to finish: */
waitpid(childPid,0,0);
}
/* Advance the frame counters: */
nextMovieFrameTime+=movieFrameTimeInterval;
++nextMovieFrameCounter;
}
if(nextTimeStamp>nextMovieFrameTime)
{
/* Request a screenshot from the movie window: */
char imageFileName[1024];
snprintf(imageFileName,sizeof(imageFileName),movieFileNameTemplate.c_str(),nextMovieFrameCounter);
movieWindow->requestScreenshot(imageFileName);
/* Advance the movie frame counters: */
nextMovieFrameTime+=movieFrameTimeInterval;
++nextMovieFrameCounter;
}
}
}
firstFrame=false;
}
bool InputDeviceAdapterMouse::keyPressed(int keyCode,int modifierMask,const char* string)
{
bool stateChanged=false;
if(keyCode==keyboardModeToggleKeyCode)
{
keyboardMode=!keyboardMode;
if(fakeMouseCursor)
{
/* Change the glyph renderer's cursor type to a text cursor: */
}
else if(keyboardMode)
{
/* Change the cursor in all windows to a text cursor: */
for(int i=0; i<getNumWindows(); ++i)
{
VRWindow* win=Vrui::getWindow(i);
if(win!=0)
{
Cursor cursor=XCreateFontCursor(win->getContext().getDisplay(),XC_xterm);
XDefineCursor(win->getContext().getDisplay(),win->getWindow(),cursor);
XFreeCursor(win->getContext().getDisplay(),cursor);
}
}
}
else
{
/* Change the cursor in all windows back to the regular: */
for(int i=0; i<getNumWindows(); ++i)
{
VRWindow* win=Vrui::getWindow(i);
if(win!=0)
XUndefineCursor(win->getContext().getDisplay(),win->getWindow());
}
}
}
else if(keyboardMode)
{
/* Process the key event: */
ControlKeyMap::Iterator ckmIt=controlKeyMap.findEntry(ControlKey(keyCode,modifierMask&(ShiftMask|ControlMask)));
if(!ckmIt.isFinished())
{
/* Store a text control event: */
textControlEvents.push_back(std::pair<int,GLMotif::TextControlEvent>(nextEventOrdinal,ckmIt->getDest()));
++nextEventOrdinal;
}
else if(string!=0&&string[0]!='\0')
{
/* Store a text event: */
textEvents.push_back(std::pair<int,GLMotif::TextEvent>(nextEventOrdinal,GLMotif::TextEvent(string)));
++nextEventOrdinal;
}
stateChanged=true;
}
else
{
/* Check if the key is a button key: */
int buttonIndex=getButtonIndex(keyCode);
if(buttonIndex>=0)
{
/* Set button state: */
int stateIndex=(numButtons+numButtonKeys)*modifierKeyMask+numButtons+buttonIndex;
stateChanged=changeButtonState(stateIndex,true);
}
/* Check if the key is a modifier key: */
int modifierIndex=getModifierIndex(keyCode);
if(modifierIndex>=0)
{
/* Change current modifier mask: */
changeModifierKeyMask(modifierKeyMask|(0x1<<modifierIndex));
stateChanged=true;
}
}
// requestUpdate();
return stateChanged;
}
