void ofxSpriteRenderer::Update() { float delta_time = 0.0f; if(ofGetFrameRate() > 1) delta_time = 1.0/ofGetFrameRate(); #ifdef _DEBUG unsigned long long time_start_update = ofGetSystemTime(); #endif float width = m_RenderRect.width; float height = m_RenderRect.height*2.0; m_WorldRect.x = m_Camera->getPosition().x - width*0.5; m_WorldRect.y = m_Camera->getPosition().z - height*0.5; m_WorldRect.width = width; m_WorldRect.height = height; m_ExpandedWorldRect = ofRectangle( m_WorldRect.x - FAR_SCREEN_DISTANCE_THRESHOLD, m_WorldRect.y - FAR_SCREEN_DISTANCE_THRESHOLD, m_WorldRect.width + FAR_SCREEN_DISTANCE_THRESHOLD*2, m_WorldRect.height + FAR_SCREEN_DISTANCE_THRESHOLD*2); ofxBaseSprites::iterator it = m_Sprites.begin(); for(;it != m_Sprites.end();it++) { ofxBaseSprite* item = *it; item->Update(delta_time); item->SubmitChanges(); } m_CameraMove = false; m_CameraForce = false; #ifdef _DEBUG unsigned long long time_finish_update = ofGetSystemTime(); m_UpdateTimeMilisecond = time_finish_update - time_start_update; #endif }
void recompileAndReload() { printf("File is modified, reloading\n"); long t = ofGetSystemTime(); system("make live"); reload(); printf("Reload took %ldms\n", ofGetSystemTime() - t); }
//-------------------------------------------------------------- void testApp::update(){ switch (demo) { case OSCILLATIONS:{ ildaFrame.getPolys().clear(); ildaFrame.addPoly(ofFloatColor( (int)ofGetElapsedTimef()%3, (int)ofGetElapsedTimef()%5, (int)ofGetElapsedTimef()%7, 1)); ofxIlda::Poly& p = ildaFrame.getLastPoly(); p.clear(); for (int i = 0 ; i < 35 ; i ++){ float t = (ofGetElapsedTimef() + i * 0.5); float scale = sqrt(abs(sin(ofGetElapsedTimef()))); ofPoint pnt = (ofPoint(0.5,0.5) + scale * ofPoint(0.5*cos(t*1.1), 0.5*sin(t))); p.lineTo(pnt); } break; } case MILKYWAY:{ ildaFrame.getPolys().clear(); ildaFrame.addPoly(ofFloatColor( (int)ofGetElapsedTimef()%11, (int)ofGetElapsedTimef()%5, (int)ofGetElapsedTimef()%7, 1)); ofxIlda::Poly& q = ildaFrame.getLastPoly(); q.clear(); for (int i = 0 ; i < 150 ; i ++){ float t = (ofGetElapsedTimef() + i*0.5); float scale = sqrt(i/150.0); ofPoint pnt = (ofPoint(0.5,0.5) + scale * ofPoint(0.5*cos(t*1.1), 0.5*sin(t))); q.lineTo(pnt); } break; } default: ildaFrame.clear(); break; } // drawSomething(EYE, ofPoint(0.5,0.5), 0.2, ofFloatColor(0,1,1,1)); drawSomething(TRIANGLE, ofPoint(0.5,0.5), 0.05*(sqrt(ofGetSystemTime()%53)), ofFloatColor(1,0,0,1)); drawSomething(TRIANGLE, ofPoint(0.5,0.5), 0.05*(sqrt(ofGetSystemTime()%73)), ofFloatColor(0,0,1,1)); drawSomething(TRIANGLE, ofPoint(0.5,0.5), 0.05*(sqrt(ofGetSystemTime()%101)), ofFloatColor(1,1,0,1)); }
//-------------------------------------------------------------- void ofApp::update() { grabber.update(); if(grabber.isFrameNew()) { frames_one_sec++; if( ofGetSystemTime() - one_second_time >= 1000) { camera_fps = frames_one_sec; frames_one_sec = 0; one_second_time = ofGetSystemTime(); } colorCv = grabber.getPixels(); colorCvSmall.scaleIntoMe(colorCv, CV_INTER_NN); grayCv = colorCvSmall; faceFinder.findHaarObjects(grayCv); faces = faceFinder.blobs; } }
void ofxGuiGrid::selectedColor() { mNowTime = ofGetSystemTime(); //printf( "old: %ld\n now: %ld\n", oldTime, now ); if ( mNowTime - mOldTime >= mInterval ) { mOldTime = mNowTime; if ( mRising ) { mColorR += mOffset; mColorG += mOffset; mColorB += mOffset; } else { mColorR -= mOffset; mColorG -= mOffset; mColorB -= mOffset; } if ( mColorR >= 1 ) { mRising = false; } else if ( mColorR <= 0 ) { mRising = true; } // printf( "\nR: %f\n", mColorR ); } }
void ofxMarsyasNetwork::threadedFunction() { while( isThreadRunning() ) { if (priority != targetPriority) { run(); priority = targetPriority; } // cout << "ofxMarsyasNetwork trying to lock" << endl; if (lock()) { // cout << "ofxMarsyasNetwork in lock" << endl; tick(); thisTick = ofGetSystemTime(); rate = ofLerp(rate, 1000.0/(thisTick-lastTick), 0.001); lastTick = thisTick; update(); unlock(); // cout << "ofxMarsyasNetwork after unlock()" << endl; } else { // cout << "ofxMarsyasNetwork sleeping" << endl; ofSleepMillis(20); } if (targetRate>0) ofSleepMillis(1000.0/targetRate); } }
//-------------------------------------------------------------- void testApp::update(){ unsigned long long cur_time = ofGetSystemTime(); // grid needs to be regenerated every draw due to random noise // TODO maybe we can use a separate buffer for noise and do displacement in shader generateGrid(); //rotate and zoom camera double tick_double = double(cur_time % 2000)/2000; double scale = abs(tick_double - 0.5) * 3; if (move_camera) { theCamera.position.x = cos(tick_double * 2 * PI) * scale; theCamera.position.y = 0.35f; theCamera.position.z = sin(tick_double * 2 * PI) * scale ; } else { theCamera.position.x = 0; theCamera.position.y = 0.35f; theCamera.position.z = -1.1f ; } theCamera.target.x = 0; theCamera.target.y = 0; theCamera.target.z = 0; theCamera.roll = 0.0; }
ofxGuiGrid::ofxGuiGrid() { mParamType = kofxGui_Object_Grid; mWidthScale = GRID_WIDTH_SCALE; mHeightScale = GRID_HEIGHT_SCALE; mSelectedId = -1; mIndexOffset = 0; mOldTime = ofGetSystemTime(); mInterval = 50; // 50 ms mOffset = 0.05f; // color changing offset mRising = true; mIsSelectable = false; mValidSelection = false; mDraggingRawIndex = -1; mIsActive = true; // default: active bDrawSelectedText = false; bShowResetBtn = false; bShowSettingBtn = false; bDblClickMode = false; bCanDblClickMode = false; mPrevClickTime = 0; dblClickImage = new ofxGuiImage(); }
//---------------------------------------- void ofxOpenNITracker::setUserState(unsigned int nID, ofxOpenNIUser::TrackingState userState) { // if (users.find(nID) != users.end()) { users[nID].state = userState; users[nID].stateChangedTimestamp = ofGetSystemTime(); } }
void testApp::update() { videoGrabber.update(); if (videoGrabber.isFrameNew()) { if (ofGetSystemTime() - previousCaptureTime > captureInterval) { capture(); } } }
void idle(void) { long t = ofGetSystemTime(); // check update time on the file if(t>lastTimeChecked+100) { // check every 300ms checkAndUpdate(); lastTimeChecked = t; } }
//-------------------------------------------------------------- void CloudsVHXAuth::update(ofEventArgs& args) { if (bNotifyComplete) { //Wait to ensure the thread has stopped //JG Added this... Elie please advise waitForThread(true); Mode completedMode = mode; mode = WAITING; if (completedMode == REQUEST_TOKEN) { ofNotifyEvent(requestTokenComplete, completeArgs); } else if (completedMode == REFRESH_TOKEN) { ofNotifyEvent(refreshTokenComplete, completeArgs); } else if (completedMode == REQUEST_CODE) { ofNotifyEvent(requestCodeComplete, completeArgs); } else if (completedMode == LINK_CODE) { ofNotifyEvent(linkCodeComplete, completeArgs); } else if (completedMode == VERIFY_PACKAGE) { ofNotifyEvent(verifyPackageComplete, completeArgs); } bNotifyComplete = false; } time_t nowTime = (ofGetSystemTime() / 1000.f); // Refresh token if it's expired. if (mode == WAITING && _tokenExpiry && nowTime > _tokenExpiry) { if (_refreshToken.empty()) { requestToken(); } else { refreshToken(); } } // Reset code if it's expired. if (_codeExpiry && nowTime > _codeExpiry) { _code = ""; _codeExpiry = 0; CloudsVHXEventArgs args; ofNotifyEvent(codeExpired, args); } // Update state if package expired. if (state == RENTAL && _packageExpiry && nowTime > _packageExpiry) { state = EXPIRED; CloudsVHXEventArgs args; ofNotifyEvent(packageExpired, args); } }
//------------------------------------------------------------------ void xmlParty::setFileNameSave(string iOSDocumentsDirectory, ofxXmlSettings& _XMLOne, ofxXmlSettings& _XMLTwo, button& _mathButton, vector <drawing>& _drawThese, vector<flagState>& _theFlagStates, string& theText) { // welcomeButton.thisString = "welcome "+_setUserName+"!"; //float stringSize = welcomeButton.thisString.size(); // welcomeButton.offSet.set(415, 35); //ASSIGN ALL THE BUTTON INFO HERE _mathButton.XMLFileOne = ofToString(ofGetSystemTime()) + "_" + _mathButton.myCreateProbRefresh; _mathButton.XMLFileTwo = ofToString(ofGetSystemTime()) + "_" + _mathButton.myReflectProbRefresh; xmlSetupThang(iOSDocumentsDirectory, _XMLOne, _XMLTwo, _mathButton); saveXML(iOSDocumentsDirectory, _XMLOne, _XMLTwo, _mathButton, _drawThese, _theFlagStates, theText); // mathTwoButton.XMLFileOne = ofToString(ofGetSystemTime()) + "_myCreateProbTwo.xml"; // mathTwoButton.XMLFileTwo = ofToString(ofGetSystemTime()) + "_myReflectProbTwo.xml"; // xmlSetupThang(iOSDocumentsDirectory, _XMLOne, _XMLTwo, mathTwoButton.XMLFileOne, mathTwoButton.XMLFileTwo); // saveXML(iOSDocumentsDirectory, _XMLOne, _XMLTwo, mathTwoButton.XMLFileOne, mathTwoButton.XMLFileTwo, mathTwoButton.problemText); // // mathThreeButton.XMLFileOne = ofToString(ofGetSystemTime()) + "_myCreateProbThree.xml"; // mathThreeButton.XMLFileTwo = ofToString(ofGetSystemTime()) + "_myReflectProbThree.xml"; // xmlSetupThang(iOSDocumentsDirectory, _XMLOne, _XMLTwo, mathThreeButton.XMLFileOne, mathThreeButton.XMLFileTwo); // saveXML(iOSDocumentsDirectory, _XMLOne, _XMLTwo, mathThreeButton.XMLFileOne, mathThreeButton.XMLFileTwo, mathThreeButton.problemText); // // mathFourButton.XMLFileOne = ofToString(ofGetSystemTime()) + "_myCreateProbFour.xml"; // mathFourButton.XMLFileTwo = ofToString(ofGetSystemTime()) + "_myReflectProbFour.xml"; // xmlSetupThang(iOSDocumentsDirectory, _XMLOne, _XMLTwo, mathFourButton.XMLFileOne, mathFourButton.XMLFileTwo); // saveXML(iOSDocumentsDirectory, _XMLOne, _XMLTwo, mathFourButton.XMLFileOne, mathFourButton.XMLFileTwo, mathFourButton.problemText); // // mathFiveButton.XMLFileOne = ofToString(ofGetSystemTime()) + "_myCreateProbFive.xml"; // mathFiveButton.XMLFileTwo = ofToString(ofGetSystemTime()) + "_myReflectProbFive.xml"; // xmlSetupThang(iOSDocumentsDirectory, _XMLOne, _XMLTwo, mathFiveButton.XMLFileOne, mathFiveButton.XMLFileTwo); // saveXML(iOSDocumentsDirectory, _XMLOne, _XMLTwo, mathFiveButton.XMLFileOne, mathFiveButton.XMLFileTwo, mathFiveButton.problemText); // // mathSixButton.XMLFileOne = ofToString(ofGetSystemTime()) + "_myCreateProbSix.xml"; // mathSixButton.XMLFileTwo = ofToString(ofGetSystemTime()) + "_myReflectProbSix.xml"; // xmlSetupThang(iOSDocumentsDirectory, _XMLOne, _XMLTwo, mathSixButton.XMLFileOne, mathSixButton.XMLFileTwo); // saveXML(iOSDocumentsDirectory, _XMLOne, _XMLTwo, mathSixButton.XMLFileOne, mathSixButton.XMLFileTwo, mathSixButton.problemText); // }
bool timer::isFinished() { // Check how much time has passed passedTime = ofGetSystemTime(); if (passedTime - savedTime > totalTime) { return true; } else { return false; } }
TBlob::TBlob (const ABlob * b) { TBlob::TBlob(); // id = ImageBlobs::idnumbers++; id = ImageBlobs::idnumbers; pixelcount = b->pixelcount; boxminx = b->boxminx; boxminy = b->boxminy; boxmaxx = b->boxmaxx; boxmaxy = b->boxmaxy; boxcenterx = b->boxcenterx; boxcentery = b->boxcentery; boxdimx = b->boxdimx; boxdimy = b->boxdimy; pboxcenterx = boxcenterx; pboxcentery = boxcentery; // ivelx = b->ivelx; // ively = b->ively; cx = b->cx; cy = b->cy; bx = b->bx; by = b->by; dimx = b->dimx; dimy = b->dimy; armleftx = b->armleftx; armlefty = b->armlefty; armrightx = b->armrightx; armrighty = b->armrighty; headx = b->headx; heady = b->heady; bottomx = b->bottomx; bottomy = b->bottomy; footleftx = b->footleftx; footlefty = b->footlefty; footrightx = b->footrightx; footrighty = b->footrighty; // TBlob specific newblob=true; birthtime=ofGetSystemTime();//System.currentTimeMillis(); lifetime = ofxFlob::TBlobLifeTime; presencetime = 1; linked=false; pcx = cx; pcy = cy; prevelx=prevely=velx=vely=0.0f; maxdist2 = ofxFlob::TBlobMaxDistSquared;//2555f;//1000;//~31px//100; calcrad(); }
Score testApp::recordMiss() { Score score; score.difficulty = difficulty; score.time = ofGetSystemTime() - startTime; misses.push_back(score); latestScore = score; return score; }
KinectMarkerTracker::KinectMarkerTracker() { _hasResult = false; contourFinder.setTargetColor(ofColor(64, 153, 33), ofxCv::TRACK_COLOR_RGB); contourFinder.setMinAreaRadius(1); contourFinder.setMaxAreaRadius(10); contourFinder.setThreshold(50); foundTime = ofGetSystemTime(); }
void smlWriter::saveFile(){ float stopTime = ofGetElapsedTimef(); if(scratchMLfile.getNumTags("sml")>0){ while(scratchMLfile.getPushLevel() > 0){ scratchMLfile.popTag(); } scratchMLfile.addValue("sml:performance:time:duration", stopTime-startTime); scratchMLfile.saveFile(fileName); scratchMLfile.clear(); fileName = "session-"+ofToString(ofGetSystemTime())+".xml"; newFile(fileName); } }
void testApp::updateParticles() { // cycle through hue every minute long systemTime = ofGetSystemTime(); ofColor particleColor = getParticleColor(); for(int i = 0; i < PARTICLE_COUNT; i++) { Particle::particle_state oldState = particles[i].state; particles[i].update(systemTime); particles[i].baseColor = particleColor; Particle::particle_state newState = particles[i].state; if(particles[i].state == Particle::INACTIVE && oldState == Particle::FALLING) inactiveParticles.push_back(i); } }
//-------------------------------------------------------------- bool CloudsVHXAuth::setup() { _keysPath = GetCloudsDataPath(true) + "vhx/client.bin"; _tokensPath = GetCloudsDataPath(true) + "vhx/tokens.bin"; // Load and decrypt the info from files on disk. //string path = GetCloudsDataPath() + "vhx/client.bin"; if (CloudsCryptoLoadKeys(_clientId, _clientSecret, _packageId, _keysPath)) { ofLogNotice("CloudsVHXAuth::setup") << "Loaded keys successfully:\n" << "\tClient ID: " << _clientId << "\n" << "\tClient Secret: " << _clientSecret << "\n" << "\tPackage ID: " << _packageId; } else { ofLogError("CloudsVHXAuth::setup") << "Cannot open file at " << _keysPath; } if (CloudsCryptoLoadTokens(_accessToken, _refreshToken, _tokenExpiry, _tokensPath)) { ofLogNotice("CloudsVHXAuth::setup") << "Loaded tokens successfully:\n" << "\tAccess Token: " << _accessToken << "\n" << "\tRefresh Token: " << _refreshToken << "\n" << "\tToken Expiry: " << _tokenExpiry; } else { ofLogError("CloudsVHXAuth::setup") << "Cannot open file at " << _tokensPath; _tokenExpiry = 0; } state = INACTIVE; mode = WAITING; bNotifyComplete = false; ofAddListener(ofEvents().update, this, &CloudsVHXAuth::update); if (_packageId.size() && _accessToken.size()) { time_t nowTime = (ofGetSystemTime() / 1000.f); if (_tokenExpiry > nowTime) { // Try to verify the package immediately. verifyPackage(); } else { // Refresh the token first, it's expired. refreshToken(); } return true; } return false; }
void testApp::makeParticleAt(const ofVec3f &pt, ofColor c) { if(inactiveParticles.size() == 0) { return; } int idx = inactiveParticles.front(); Particle *p = &particles[idx]; p->location.x = pt.x + ofRandom( -100, 100); p->location.y = pt.y + ofRandom( -100, 100); p->location.z = pt.z + ofRandom( -100, 100); p->velocity = ofVec3f(0); p->acceleration = ofVec3f(0); p->state = Particle::BORN; p->bornTime = ofGetSystemTime(); p->baseColor = c; inactiveParticles.pop_front(); }
void testApp::drawParticles() { ofMesh mesh; mesh.setMode(OF_PRIMITIVE_POINTS); auto systemTime = ofGetSystemTime(); for(int i = 0; i < PARTICLE_COUNT; i++) { particles[i].addToMesh(mesh, systemTime); } glPointSize(2); ofPushMatrix(); // TODO: clean these up. // the projected points are 'upside down' and 'backwards' ofTranslate(0, 0, 0); // center the points a bit ofEnableDepthTest(); mesh.drawVertices(); ofDisableDepthTest(); ofPopMatrix(); }
//-------------------------------------------------------------- void testApp::draw(){ unsigned long long cur_time = ofGetSystemTime(); update_p_matrix(proj_mat, screen_width, screen_height); update_mv_matrix(mv_mat, 0); glMatrixMode(GL_PROJECTION); glLoadMatrixf(proj_mat); glMatrixMode(GL_MODELVIEW); glLoadMatrixf(mv_mat); if (!use_easycam) look(); else easycam.begin(); glVertexPointer(3,GL_FLOAT,sizeof(GLfloat)*3,(void*)0); glEnableClientState(GL_VERTEX_ARRAY); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer); glDrawElements( GL_QUADS, e_buffer_size, /* count */ GL_UNSIGNED_INT, (void*)0 /* element array buffer offset */ ); glDisableClientState(GL_VERTEX_ARRAY); // print framerate to stdout every second static unsigned long long last_fps_tick = 0; if (cur_time > last_fps_tick + 1000) { last_fps_tick = cur_time; cout << ofToString(ofGetFrameRate(), 2) << " fps" << endl; } GLenum err = glGetError(); if (err) { //breakpoint? if (false) cout << "error" << endl; } last_time = cur_time; if (use_easycam) easycam.end(); }
//------------------------------------------------------------------ void pointRecorder::addPoint(ofPoint pt) { // on the first point, grab the start time if (pts.size() == 0){ //startTime = ofGetSystemTime(); } // combine the position and the time here: timePt myPoint; myPoint.pos = pt; myPoint.time = (ofGetSystemTime() - startTime)/1000.0; pts.push_back(myPoint); if (pts.size() > maxNumPts){ pts.erase(pts.begin()); } }
void testApp::setup() { deviceId = 0; captureId = 0; // Increment by 1000 until we find a good filename. ofFile file; file.open(captureFilename(captureId)); while (file.exists()) { captureId += 1000; file.open(captureFilename(captureId)); } videoGrabber.setVerbose(true); videoGrabber.setDeviceID(deviceId); videoGrabber.initGrabber(640, 480); captureInterval = 60 * 1000; previousCaptureTime = ofGetSystemTime(); }
//-------------------------------------------------------------- void currentColor::update() { transSpeed = (float) colorTime / colorDuration; currentTime = ofGetSystemTime() - startTime;//how long the sketch has been running in m for ( int i = 0; i < nBars; i ++ ) { currentColors[ i ] = fromColors[ i ].getLerped( toColors[ i ], transSpeed ); } if ( colorTime >= colorDuration ) { cycles ++; lastColors = nextColors; for ( int i = 0; i < nBars; i ++ ) { nextColors[ i ] ++; if ( nextColors[ i ] > imgWidth - 1 ) { nextColors[ i ] = 0; } fromColors[ i ] = colorPalettePixels.getColor( lastColors[ i ], 0 ); toColors[ i ] = colorPalettePixels.getColor( nextColors[ i ], 0 ); } colorPosition ++; if ( colorPosition > imgWidth ) { colorPosition = 0; } } if ( cycles > 1 ) { colorTime = currentTime - ((cycles - 1 ) * colorDuration ); } else { colorTime = currentTime; } }
void VideoGrabber::update() { if(!isMainThread()) { // Textures must be loaded in main thread. cerr << "update() may not be called from outside the main " << "thread. Returning."; return; } if (connected_) { bool wasNewFrame = false; unsigned long now = ofGetSystemTime(); // // BEGIN CRITICAL SECTION // mutex.lock(); elapsedTime_ = (initTime_ == 0) ? 0 : (now - initTime_); if (backBufferReady_) { ++framesRendered_; swap(pixelsFront_, pixelsBack_); backBufferReady_ = false; wasNewFrame = true; } mutex.unlock(); // // END CRITICAL SECTION // if (wasNewFrame) { texture_.loadData(pixelsFront_); if(elapsedTime_ > 0) { currentFrameRate_ = (float(framesRendered_) / (elapsedTime_ / (1000.0f))); currentBitRate_ = (float(bytesReceived_) * 8.0f / (elapsedTime_ / (1000.0f))); } else { currentFrameRate_ = 0.0; currentBitRate_ = 0.0; } } } }
// resets all values void basicEffect::reset(){ ofScopedLock lock(effectMutex); // todo: do this in _reset() which then calls reset(); aliveSince=0; startTime=ofGetSystemTime(); shapes.clear(); shapes.resize(0); bInitialised = true; bHasError = false; bEnabled = false; bIsLoading = false; bShowGuiWindow = false; effectName = effectType; bUsePingpong = false; overallBoundingBox = ofRectangle(0,0,0,0); }
//-------------------------------------------------------------- void ofApp::setup() { ofBackground(255,255,255); ofSetLogLevel(OF_LOG_NOTICE); ofSetOrientation(OF_ORIENTATION_90_LEFT); int grabberWidth = 320; int grabberHeight = 240; grabber.setup(grabberWidth,grabberHeight); colorCv.allocate(grabberWidth, grabberHeight); colorCvSmall.allocate(grabberWidth/4, grabberHeight/4); grayCv.allocate(grabberWidth/4, grabberHeight/4); faceFinder.setup("haarcascade_frontalface_default.xml"); faceFinder.setNeighbors(1); faceFinder.setScaleHaar(1.5); one_second_time = ofGetSystemTime(); camera_fps = 0; frames_one_sec = 0; }
void KinectMarkerTracker::update() { _hasResult = false; result = ofVec3f(); depthImage.setFromPixels(kinect->getPixelsRef()); contourFinder.findContours(depthImage); long now = ofGetSystemTime(); if (now > foundTime + 5000) { if (contourFinder.size() > 0 && contourFinder.getContourArea(0) > 0) { ofVec3f pScreen = ofxCv::toOf(contourFinder.getCentroid(0)); ofVec3f pWorld = kinect->getWorldCoordinateAt(pScreen.x, pScreen.y); if (pWorld.x != 0 && pWorld.y != 0 && pWorld.z != 0) { _hasResult = true; result = pWorld; foundTime = now; } } } }