//------------------------------------------------------------ void ofxAppNoWindow::runAppViaInfiniteLoop(ofBaseApp * appPtr){ ofSetCurrentRenderer(ofPtr<ofBaseRenderer>(new ofNoopRenderer)); ofAppPtr = appPtr; #if defined TARGET_OSX || defined TARGET_LINUX // for keyboard //set_conio_terminal_mode(); #endif ofNotifySetup(); // ofLogNotice("ofxAppNoWindow") // << "***" << endl // << "***" << endl // << "*** running a headless (no window) app" << endl // << "***" << endl // << "*** keyboard input works here" << endl // << "***"<< endl // << "*** press Esc or Ctrl-C to quit" << endl // << "***" << endl; while (true) { /// listen for escape #ifdef TARGET_WIN32 if (GetAsyncKeyState(VK_ESCAPE)) ofNotifyKeyPressed(OF_KEY_ESC); #endif #if defined TARGET_OSX || defined TARGET_LINUX while ( kbhit() ) { int key = getch(); if ( key == 27 ) { ofNotifyKeyPressed(OF_KEY_ESC); } else if ( key == /* ctrl-c */ 3 ) { ofLogNotice("ofxAppNoWindow") << "Ctrl-C pressed" << endl; OF_EXIT_APP(0); } else { ofNotifyKeyPressed(key); } } #endif ofNotifyUpdate(); ofNotifyDraw(); } }
/* Call to render the next GL frame */ void Java_cc_openframeworks_OFAndroid_render( JNIEnv* env, jclass thiz ) { int beginFrameMillis = ofGetElapsedTimeMillis(); if(paused) return; //LOGI("update"); ofNotifyUpdate(); int width, height; width = sWindowWidth; height = sWindowHeight; height = height > 0 ? height : 1; // set viewport, clear the screen //glViewport( 0, 0, width, height ); ofViewport(0, 0, width, height, false); // used to be glViewport( 0, 0, width, height ); float * bgPtr = ofBgColorPtr(); bool bClearAuto = ofbClearBg(); if ( bClearAuto == true || nFrameCount < 3){ ofClear(bgPtr[0]*255,bgPtr[1]*255,bgPtr[2]*255, bgPtr[3]*255); } if(bSetupScreen) ofSetupScreen(); ofNotifyDraw(); /*timeNow = ofGetElapsedTimef(); double diff = timeNow-timeThen; if( diff > 0.00001 ){ fps = 1.0 / diff; frameRate *= 0.9f; frameRate += 0.1f*fps; } lastFrameTime = diff; timeThen = timeNow;*/ // -------------- int currTime = ofGetElapsedTimeMillis(); if(currTime - onesec>=1000){ frameRate = frames; frames = 0; onesec = currTime; } frames++; int frameMillis = currTime - beginFrameMillis; lastFrameTime = double(frameMillis)/1000.; previousFrameMillis = currTime; nFrameCount++; // increase the overall frame count*/ if(bFrameRateSet && frameMillis<oneFrameTime) ofSleepMillis(oneFrameTime-frameMillis); }
//------------------------------------------------------------ void ofxAppMacScreenSaver::display(void){ //-------------------------------- // when I had "glutFullScreen()" // in the initOpenGl, I was gettings a "heap" allocation error // when debugging via visual studio. putting it here, changes that. // maybe it's voodoo, or I am getting rid of the problem // by removing something unrelated, but everything seems // to work if I put fullscreen on the first frame of display. ///// MAREK HERE // set viewport, clear the screen ////ofViewport(0, 0, glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT)); // used to be glViewport( 0, 0, width, height ); float * bgPtr = ofBgColorPtr(); bool bClearAuto = ofbClearBg(); // to do non auto clear on PC for now - we do something like "single" buffering -- // it's not that pretty but it work for the most part if ( bClearAuto == true || nFrameCount < 3){ ofClear(bgPtr[0]*255,bgPtr[1]*255,bgPtr[2]*255, bgPtr[3]*255); } if( bEnableSetupScreen )ofSetupScreen(); ofNotifyDraw(); ofAppPtr->draw(); if (bClearAuto == false){ // in accum mode resizing a window is BAD, so we clear on resize events. if (nFramesSinceWindowResized < 3){ ofClear(bgPtr[0]*255,bgPtr[1]*255,bgPtr[2]*255, bgPtr[3]*255); } } //// MAREK HERE ////glutSwapBuffers(); nFramesSinceWindowResized++; //fps calculation moved to idle_cb as we were having fps speedups when heavy drawing was occuring //wasn't reflecting on the actual app fps which was in reality slower. //could be caused by some sort of deferred drawing? nFrameCount++; // increase the overall frame count //setFrameNum(nFrameCount); // get this info to ofUtils for people to access }
//------------------------------------------------------------ void ofAppGlutWindow::display(void){ //-------------------------------- // when I had "glutFullScreen()" // in the initOpenGl, I was gettings a "heap" allocation error // when debugging via visual studio. putting it here, changes that. // maybe it's voodoo, or I am getting rid of the problem // by removing something unrelated, but everything seems // to work if I put fullscreen on the first frame of display. if (windowMode != OF_GAME_MODE){ if ( bNewScreenMode ){ if( windowMode == OF_FULLSCREEN){ //---------------------------------------------------- // before we go fullscreen, take a snapshot of where we are: nonFullScreenX = glutGet(GLUT_WINDOW_X); nonFullScreenY = glutGet(GLUT_WINDOW_Y); //---------------------------------------------------- glutFullScreen(); #ifdef TARGET_OSX SetSystemUIMode(kUIModeAllHidden,NULL); #endif }else if( windowMode == OF_WINDOW ){ glutReshapeWindow(requestedWidth, requestedHeight); //---------------------------------------------------- // if we have recorded the screen posion, put it there // if not, better to let the system do it (and put it where it wants) if (nFrameCount > 0){ glutPositionWindow(nonFullScreenX,nonFullScreenY); } //---------------------------------------------------- #ifdef TARGET_OSX SetSystemUIMode(kUIModeNormal,NULL); #endif } bNewScreenMode = false; } } // set viewport, clear the screen ofViewport(0, 0, glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT)); // used to be glViewport( 0, 0, width, height ); float * bgPtr = ofBgColorPtr(); bool bClearAuto = ofbClearBg(); // to do non auto clear on PC for now - we do something like "single" buffering -- // it's not that pretty but it work for the most part #ifdef TARGET_WIN32 if (bClearAuto == false){ glDrawBuffer (GL_FRONT); } #endif if ( bClearAuto == true || nFrameCount < 3){ ofClear(bgPtr[0]*255,bgPtr[1]*255,bgPtr[2]*255, bgPtr[3]*255); } if( bEnableSetupScreen )ofSetupScreen(); ofNotifyDraw(); #ifdef TARGET_WIN32 if (bClearAuto == false){ // on a PC resizing a window with this method of accumulation (essentially single buffering) // is BAD, so we clear on resize events. if (nFramesSinceWindowResized < 3){ ofClear(bgPtr[0]*255,bgPtr[1]*255,bgPtr[2]*255, bgPtr[3]*255); } else { if (nFrameCount < 3 || nFramesSinceWindowResized < 3) glutSwapBuffers(); else glFlush(); } } else { glutSwapBuffers(); } #else if (bClearAuto == false){ // in accum mode resizing a window is BAD, so we clear on resize events. if (nFramesSinceWindowResized < 3){ ofClear(bgPtr[0]*255,bgPtr[1]*255,bgPtr[2]*255, bgPtr[3]*255); } } glutSwapBuffers(); #endif nFramesSinceWindowResized++; //fps calculation moved to idle_cb as we were having fps speedups when heavy drawing was occuring //wasn't reflecting on the actual app fps which was in reality slower. //could be caused by some sort of deferred drawing? nFrameCount++; // increase the overall frame count //setFrameNum(nFrameCount); // get this info to ofUtils for people to access }
/* Call to render the next GL frame */ void Java_cc_openframeworks_OFAndroid_render( JNIEnv* env, jclass thiz ) { if(paused || surfaceDestroyed) return; if(!threadedTouchEvents){ mutex.lock(); queue<ofTouchEventArgs> events = touchEventArgsQueue; while(!touchEventArgsQueue.empty()) touchEventArgsQueue.pop(); mutex.unlock(); while(!events.empty()){ switch(events.front().type){ case ofTouchEventArgs::down: ofNotifyMousePressed(events.front().x,events.front().y,0); ofNotifyEvent(ofEvents().touchDown,events.front()); break; case ofTouchEventArgs::up: ofNotifyMouseReleased(events.front().x,events.front().y,0); ofNotifyEvent(ofEvents().touchUp,events.front()); break; case ofTouchEventArgs::move: ofNotifyMouseMoved(events.front().x,events.front().y); ofNotifyMouseDragged(events.front().x,events.front().y,0); ofNotifyEvent(ofEvents().touchMoved,events.front()); break; case ofTouchEventArgs::doubleTap: ofNotifyEvent(ofEvents().touchDoubleTap,events.front()); break; case ofTouchEventArgs::cancel: ofNotifyEvent(ofEvents().touchCancelled,events.front()); break; } events.pop(); } } ofNotifyUpdate(); if(ofGetGLProgrammableRenderer()){ ofGetGLProgrammableRenderer()->startRender(); } int width, height; width = sWindowWidth; height = sWindowHeight; height = height > 0 ? height : 1; // set viewport, clear the screen //glViewport( 0, 0, width, height ); ofViewport(0, 0, width, height, false); // used to be glViewport( 0, 0, width, height ); float * bgPtr = ofBgColorPtr(); bool bClearAuto = ofbClearBg(); if ( bClearAuto == true || ofGetFrameNum() < 3){ ofClear(bgPtr[0]*255,bgPtr[1]*255,bgPtr[2]*255, bgPtr[3]*255); } if(bSetupScreen) ofSetupScreen(); ofNotifyDraw(); if(ofGetGLProgrammableRenderer()){ ofGetGLProgrammableRenderer()->finishRender(); } }
/* Call to render the next GL frame */ void Java_cc_openframeworks_OFAndroid_render( JNIEnv* env, jclass thiz ) { unsigned long beginFrameMicros = ofGetElapsedTimeMicros(); if(paused) return; lastFrameTime = double(beginFrameMicros - previousFrameMicros)/1000000.; previousFrameMicros = beginFrameMicros; if(!threadedTouchEvents){ mutex.lock(); while(!touchEventArgsQueue.empty()){ switch(touchEventArgsQueue.front().type){ case ofTouchEventArgs::down: ofNotifyEvent(ofEvents().touchDown,touchEventArgsQueue.front()); break; case ofTouchEventArgs::up: ofNotifyEvent(ofEvents().touchUp,touchEventArgsQueue.front()); break; case ofTouchEventArgs::move: ofNotifyEvent(ofEvents().touchMoved,touchEventArgsQueue.front()); break; case ofTouchEventArgs::doubleTap: ofNotifyEvent(ofEvents().touchDoubleTap,touchEventArgsQueue.front()); break; } touchEventArgsQueue.pop(); } mutex.unlock(); } ofNotifyUpdate(); int width, height; width = sWindowWidth; height = sWindowHeight; height = height > 0 ? height : 1; // set viewport, clear the screen //glViewport( 0, 0, width, height ); ofViewport(0, 0, width, height, false); // used to be glViewport( 0, 0, width, height ); float * bgPtr = ofBgColorPtr(); bool bClearAuto = ofbClearBg(); if ( bClearAuto == true || nFrameCount < 3){ ofClear(bgPtr[0]*255,bgPtr[1]*255,bgPtr[2]*255, bgPtr[3]*255); } if(bSetupScreen) ofSetupScreen(); ofNotifyDraw(); unsigned long currTime = ofGetElapsedTimeMicros(); unsigned long frameMicros = currTime - beginFrameMicros; nFrameCount++; // increase the overall frame count*/ frames++; if(currTime - onesec>=1000000){ frameRate = frames; frames = 0; onesec = currTime; } if(bFrameRateSet && frameMicros<oneFrameTime) usleep(oneFrameTime-frameMicros); }