void GLWidget::paintGL()
{
makeCurrent();
static ofEventArgs voidEventArgs;
//Update framerate
frameRate = frames /(time.elapsed() / 1000.0);
frameRateChanged(frameRate);
if (!(frames % 100)) {
time.start();
frames = 0;
}
frames ++;
//Draw
glPushMatrix();
if(ofbClearBg()){
glClearColor(ofBgColorPtr()[0],ofBgColorPtr()[1],ofBgColorPtr()[2], ofBgColorPtr()[3]);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
ofApp->draw(viewCombo->currentIndex());
//(ofApp->*drawMethod)();
#ifdef OF_USING_POCO
ofNotifyEvent( ofEvents.draw, voidEventArgs );
#endif
glPopMatrix();
}
/* 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 ofBackground(int r, int g, int b){
bgColor[0] = (float)r / (float)255.0f;
bgColor[1] = (float)g / (float)255.0f;
bgColor[2] = (float)b / (float)255.0f;
bgColor[3] = 1.0f;
// if we are in not-auto mode, then clear with a bg call...
if (ofbClearBg() == false){
glClearColor(bgColor[0],bgColor[1],bgColor[2], bgColor[3]);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
}
//------------------------------------------------------------
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
}
void ofAppGLFWWindow::display(void){
static ofEventArgs voidEventArgs;
int width, height;
width = getWindowSize().x;
height = getWindowSize().y;
height = height > 0 ? height : 1;
// set viewport, clear the screen
glViewport( 0, 0, width, height );
float * bgPtr = ofBgColorPtr();
bool bClearAuto = ofbClearBg();
// I don't know why, I need more than one frame at the start in fullscreen mode
// also, in non-fullscreen mode, windows/intel graphics, this bClearAuto just fails.
// I seem to have 2 buffers, alot of flickering
// and don't accumulate the way I expect.
// with this line: if ((bClearAuto == true) || nFrameCount < 3){
// we do nFrameCount < 3, so that the buffers are cleared at the start of the app
// or else we have video memory garbage to draw on to...
//glDrawBuffer( GL_BACK );
printf("nFrameCount %i \n", nFrameCount);
glDrawBuffer( GL_FRONT_AND_BACK );
// glDrawBuffer( GL_FRONT );
#ifdef TARGET_WIN32
//windows doesn't get accumulation in window mode
if ((bClearAuto == true || windowMode == OF_WINDOW) || nFrameCount < 3){
#else
//mac and linux does :)
if ( bClearAuto == true || nFrameCount < 3){
#endif
glClearColor(bgPtr[0],bgPtr[1],bgPtr[2], bgPtr[3]);
// printf("clearing the screen \n");
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
if( bEnableSetupScreen )ofSetupScreen();
if(ofAppPtr)
ofAppPtr->draw();
#ifdef OF_USING_POCO
ofNotifyEvent( ofEvents().draw, voidEventArgs );
#endif
// Swap front and back buffers (we use a double buffered display)
glfwSwapBuffers();
}
//------------------------------------------------------------
void ofAppGLFWWindow::exitApp(){
// -- This is already happening in ofAppRunner
// static ofEventArgs voidEventArgs;
// if(ofAppPtr)ofAppPtr->exit();
//
// #ifdef OF_USING_POCO
// ofNotifyEvent( ofEvents().exit, voidEventArgs );
// #endif
ofLog(OF_LOG_VERBOSE,"GLFW app is being terminated!");
// Terminate GLFW
glfwTerminate();
OF_EXIT_APP(0);
}
//------------------------------------------------------------
void ofAppGlutWindow::display(void){
static ofEventArgs voidEventArgs;
//--------------------------------
// 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;
}
}
int width, height;
width = ofGetWidth();
height = ofGetHeight();
height = height > 0 ? height : 1;
// set viewport, clear the screen
glViewport( 0, 0, width, height );
float * bgPtr = ofBgColorPtr();
bool bClearAuto = ofbClearBg();
// I don't know why, I need more than one frame at the start in fullscreen mode
// also, in non-fullscreen mode, windows/intel graphics, this bClearAuto just fails.
// I seem to have 2 buffers, alot of flickering
// and don't accumulate the way I expect.
// with this line: if ((bClearAuto == true) || nFrameCount < 3){
// we do nFrameCount < 3, so that the buffers are cleared at the start of the app
// or else we have video memory garbage to draw on to...
#ifdef TARGET_WIN32
//windows doesn't get accumulation in window mode
if ((bClearAuto == true || windowMode == OF_WINDOW) || nFrameCount < 3){
#else
//mac and linux does :)
if ( bClearAuto == true || nFrameCount < 3){
#endif
glClearColor(bgPtr[0],bgPtr[1],bgPtr[2], bgPtr[3]);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
if( bEnableSetupScreen )ofSetupScreen();
if(ofAppPtr)
ofAppPtr->draw();
#ifdef OF_USING_POCO
ofNotifyEvent( ofEvents.draw, voidEventArgs );
#endif
glutSwapBuffers();
// -------------- fps calculation:
timeNow = ofGetElapsedTimef();
if( (timeNow-timeThen) > 0.05f || nFramesForFPS == 0 ) {
fps = (double)nFramesForFPS / (timeNow-timeThen);
timeThen = timeNow;
nFramesForFPS = 0;
//hack for windows - was getting NAN - maybe unitialized vars???
if( nFrameCount < 5) frameRate = fps;
else frameRate = 0.9f * frameRate + 0.1f * fps;
}
nFramesForFPS++;
// --------------
nFrameCount++; // increase the overall frame count
//setFrameNum(nFrameCount); // get this info to ofUtils for people to access
}
//------------------------------------------------------------
void ofAppGlutWindow::mouse_cb(int button, int state, int x, int y) {
static ofMouseEventArgs mouseEventArgs;
if (nFrameCount > 0){
if(ofAppPtr){
ofAppPtr->mouseX = x;
ofAppPtr->mouseY = y;
}
if (state == GLUT_DOWN) {
if(ofAppPtr)
ofAppPtr->mousePressed(x,y,button);
#ifdef OF_USING_POCO
mouseEventArgs.x = x;
mouseEventArgs.y = y;
mouseEventArgs.button = button;
ofNotifyEvent( ofEvents.mousePressed, mouseEventArgs );
#endif
} else if (state == GLUT_UP) {
if(ofAppPtr){
ofAppPtr->mouseReleased(x,y,button);
ofAppPtr->mouseReleased();
}
#ifdef OF_USING_POCO
mouseEventArgs.x = x;
mouseEventArgs.y = y;
mouseEventArgs.button = button;
ofNotifyEvent( ofEvents.mouseReleased, mouseEventArgs );
#endif
}
buttonInUse = button;
}
}
//------------------------------------------------------------
void ofAppGlutWindow::motion_cb(int x, int y) {
static ofMouseEventArgs mouseEventArgs;
if (nFrameCount > 0){
if(ofAppPtr){
ofAppPtr->mouseX = x;
ofAppPtr->mouseY = y;
ofAppPtr->mouseDragged(x,y,buttonInUse);
}
#ifdef OF_USING_POCO
mouseEventArgs.x = x;
mouseEventArgs.y = y;
mouseEventArgs.button = buttonInUse;
ofNotifyEvent( ofEvents.mouseDragged, mouseEventArgs );
#endif
}
}
//------------------------------------------------------------
void ofAppGlutWindow::passive_motion_cb(int x, int y) {
static ofMouseEventArgs mouseEventArgs;
if (nFrameCount > 0){
if(ofAppPtr){
ofAppPtr->mouseX = x;
ofAppPtr->mouseY = y;
ofAppPtr->mouseMoved(x,y);
}
#ifdef OF_USING_POCO
mouseEventArgs.x = x;
mouseEventArgs.y = y;
ofNotifyEvent( ofEvents.mouseMoved, mouseEventArgs );
#endif
}
}
//------------------------------------------------------------
void ofAppGlutWindow::idle_cb(void) {
static ofEventArgs voidEventArgs;
// thanks to jorge for the fix:
// http://www.openframeworks.cc/forum/viewtopic.php?t=515&highlight=frame+rate
if (nFrameCount != 0 && bFrameRateSet == true){
diffMillis = ofGetElapsedTimeMillis() - prevMillis;
if (diffMillis > millisForFrame){
; // we do nothing, we are already slower than target frame
} else {
int waitMillis = millisForFrame - diffMillis;
#ifdef TARGET_WIN32
Sleep(waitMillis); //windows sleep in milliseconds
#else
usleep(waitMillis * 1000); //mac sleep in microseconds - cooler :)
#endif
}
}
prevMillis = ofGetElapsedTimeMillis(); // you have to measure here
if(ofAppPtr)
ofAppPtr->update();
#ifdef OF_USING_POCO
ofNotifyEvent( ofEvents.update, voidEventArgs);
#endif
glutPostRedisplay();
}
//------------------------------------------------------------
void ofAppGlutWindow::keyboard_cb(unsigned char key, int x, int y) {
static ofKeyEventArgs keyEventArgs;
if(ofAppPtr)
ofAppPtr->keyPressed(key);
#ifdef OF_USING_POCO
keyEventArgs.key = key;
ofNotifyEvent( ofEvents.keyPressed, keyEventArgs );
#endif
if (key == OF_KEY_ESC){ // "escape"
exitApp();
}
}
//------------------------------------------------------------
void ofAppGlutWindow::keyboard_up_cb(unsigned char key, int x, int y) {
static ofKeyEventArgs keyEventArgs;
if(ofAppPtr)
ofAppPtr->keyReleased(key);
#ifdef OF_USING_POCO
keyEventArgs.key = key;
ofNotifyEvent( ofEvents.keyReleased, keyEventArgs );
#endif
}
//------------------------------------------------------
void ofAppGlutWindow::special_key_cb(int key, int x, int y) {
static ofKeyEventArgs keyEventArgs;
if(ofAppPtr)
ofAppPtr->keyPressed(key | OF_KEY_MODIFIER);
#ifdef OF_USING_POCO
keyEventArgs.key = (key | OF_KEY_MODIFIER);
ofNotifyEvent( ofEvents.keyPressed, keyEventArgs );
#endif
}
//------------------------------------------------------------
void ofAppGlutWindow::special_key_up_cb(int key, int x, int y) {
static ofKeyEventArgs keyEventArgs;
if(ofAppPtr)
ofAppPtr->keyReleased(key | OF_KEY_MODIFIER);
#ifdef OF_USING_POCO
keyEventArgs.key = (key | OF_KEY_MODIFIER);
ofNotifyEvent( ofEvents.keyReleased, keyEventArgs );
#endif
}
//------------------------------------------------------------
void ofAppGlutWindow::resize_cb(int w, int h) {
static ofResizeEventArgs resizeEventArgs;
if(ofAppPtr)
ofAppPtr->windowResized(w,h);
#ifdef OF_USING_POCO
resizeEventArgs.width = w;
resizeEventArgs.height = h;
ofNotifyEvent( ofEvents.windowResized, resizeEventArgs );
#endif
}
/* 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();
}
}
//------------------------------------------------------------
void ofxSDLAppWindow::runAppViaInfiniteLoop(ofBaseApp* appPtr) {
static ofEventArgs voidEventArgs;
// ------------------------------------------------------------
// enable keyboarding
SDL_EnableUNICODE(1);
// ------------------------------------------------------------
// connect controllers
SDL_InitSubSystem(SDL_INIT_JOYSTICK);
numJoys = SDL_NumJoysticks();
for (int j = 0; j < numJoys; j++) {
joys[j] = SDL_JoystickOpen(j);
}
// ------------------------------------------------------------
// setup application
ofAppPtr = (ofxSDLApp*) appPtr;
if (ofAppPtr) {
ofAppPtr->setup();
ofAppPtr->update();
}
#ifdef OF_USING_POCO
ofNotifyEvent(ofEvents.setup, voidEventArgs);
ofNotifyEvent(ofEvents.update, voidEventArgs);
#endif
// ------------------------------------------------------------
// loop forever and ever and ever and ever (and ever)
while (true) {
// ------------------------------------------------------------
// check for events
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_JOYAXISMOTION:
this->joyMovedHandler(&event);
break;
case SDL_JOYBUTTONDOWN:
this->joyDownHandler(&event);
break;
case SDL_JOYBUTTONUP:
this->joyUpHandler(&event);
break;
case SDL_MOUSEMOTION:
// TODO
break;
case SDL_MOUSEBUTTONDOWN:
this->mouseDownHandler(&event);
break;
case SDL_MOUSEBUTTONUP:
this->mouseUpHandler(&event);
break;
case SDL_KEYDOWN:
this->keyDownHandler(&event);
break;
case SDL_KEYUP:
this->keyUpHandler(&event);
break;
case SDL_QUIT:
this->exitApp();
break;
default:
break;
}
}
// ------------------------------------------------------------
// set viewport, clear the screen
int width, height;
width = ofGetWidth();
height = ofGetHeight();
height = height > 0 ? height : 1;
glViewport(0, 0, width, height);
float* bgPtr = ofBgColorPtr();
bool bClearAuto = ofbClearBg();
#ifdef TARGET_WIN32
// TODO: unsure if this is required for SDL, copied from GLUT.
// 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 == false) {
glDrawBuffer(GL_FRONT);
}
#endif
if (bClearAuto == true || nFrameCount < 3) {
glClearColor(bgPtr[0], bgPtr[1], bgPtr[2], bgPtr[3]);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
// ------------------------------------------------------------
// do frame drawing
if (bEnableSetupScreen) {
ofSetupScreen();
}
if (ofAppPtr) {
ofAppPtr->draw();
}
#ifdef OF_USING_POCO
ofNotifyEvent(ofEvents.draw, voidEventArgs);
#endif
// ------------------------------------------------------------
// finish viewport
#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) {
glClearColor(bgPtr[0], bgPtr[1], bgPtr[2], bgPtr[3]);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
} else {
if (nFrameCount < 3 || nFramesSinceWindowResized < 3) {
SDL_GL_SwapBuffers();
} else {
glFlush();
}
}
} else {
SDL_GL_SwapBuffers();
}
#else
if (bClearAuto == false) {
// in accum mode resizing a window is BAD, so we clear on resize events.
if (nFramesSinceWindowResized < 3) {
glClearColor(bgPtr[0], bgPtr[1], bgPtr[2], bgPtr[3]);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
}
SDL_GL_SwapBuffers();
#endif
// ------------------------------------------------------------
// wait a moment plz! keep our framerate sane
timeNow = ofGetElapsedTimef();
lastFrameTime = timeNow - timeThen;
if (lastFrameTime > 0.00001) {
fps = 1.0 / lastFrameTime;
frameRate *= 0.9f;
frameRate += 0.1f * fps;
}
timeThen = timeNow;
// --------------
if (nFrameCount != 0 && bFrameRateSet == true) {
diffMillis = SDL_GetTicks() - prevMillis;
if (diffMillis > millisForFrame) {
; // we do nothing, we are already slower than target frame
} else {
waitMillis = millisForFrame - diffMillis;
SDL_Delay(waitMillis);
}
}
prevMillis = SDL_GetTicks(); // you have to measure here
// ------------------------------------------------------------
// increment the world
nFrameCount++;
nFramesSinceWindowResized++; // TODO: do we actually use this?
// ------------------------------------------------------------
// update the application
if (ofAppPtr) {
ofAppPtr->update();
}
#ifdef OF_USING_POCO
ofNotifyEvent(ofEvents.update, voidEventArgs);
#endif
}
}
/* 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);
}
//------------------------------------------------------------
void ofAppGlutWindow::display(void){
static ofEventArgs voidEventArgs;
//--------------------------------
// 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;
}
}
int width, height;
width = ofGetWidth();
height = ofGetHeight();
height = height > 0 ? height : 1;
// set viewport, clear the screen
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){
glClearColor(bgPtr[0],bgPtr[1],bgPtr[2], bgPtr[3]);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
if( bEnableSetupScreen )ofSetupScreen();
if(ofAppPtr)
ofAppPtr->draw();
#ifdef OF_USING_POCO
ofNotifyEvent( ofEvents.draw, voidEventArgs );
#endif
#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){
glClearColor(bgPtr[0],bgPtr[1],bgPtr[2], bgPtr[3]);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
} 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){
glClearColor(bgPtr[0],bgPtr[1],bgPtr[2], bgPtr[3]);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
}
glutSwapBuffers();
#endif
nFramesSinceWindowResized++;
nFrameCount++; // increase the overall frame count
//setFrameNum(nFrameCount); // get this info to ofUtils for people to access
}