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; } }
bool SensorFile::init( const string &fileName ) { if( mInited ) return false; fs::path fullPath( getAssetPath( string( "capture/" ) + fileName )); if( ! fs::exists( fullPath )) { console() << "Unable to load captured file: " << fileName << endl; return false; } mDoc = XmlTree( loadFile( fullPath )); if( mDoc.hasChild( "PulseSensor" )) { XmlTree &xmlPulseSensor = mDoc.getChild( "PulseSensor" ); mName = xmlPulseSensor.getAttributeValue<string>( "Name" , "" ); if( xmlPulseSensor.hasChild( "Data" )) { mListXmlData = &xmlPulseSensor.getChildren(); mXmlDataActIt = mListXmlData->end(); mInited = true; mTime = getElapsedSeconds(); return true; } } console() << "Invalid captured file: " << fileName << endl; return false; }
void Connection::update() { mClient->poll(); if ( mShouldAutoReconnect ) { if ( ! mIsConnected && getElapsedSeconds() - mLastTimeTriedConnect > mReconnectInterval ) { // Disconnect update signal: mUpdateConnection.disconnect(); // Re-initialize ws client: initialize(); // Re-establish connection: mClient->connect( mHost ); // Reset connection attempt time: mLastTimeTriedConnect = getElapsedSeconds(); } } }
// All logic updates here // Called every frame void HelloWorldApp::update() { // This is a work hacky work around, to force our application to be above other windows when launched static bool hasBecomeFirstResponder = false; if( !hasBecomeFirstResponder && getElapsedSeconds() > 2 ) { // After 2 seconds, resume normal behavior hasBecomeFirstResponder = true; setAlwaysOnTop( false ); } }
void StateInit::update() { if (_app._hands[LEFT]->state == Hand::NORMAL || _app._hands[RIGHT]->state == Hand::NORMAL)//entering gesture { resetTimer(); } if (getElapsedSeconds() > n_countdown) _app.changeToState(_app._state_countdown); }
// Runs update logic void DynamicsWorld::update() { // Get time since last frame, update double elapsedSeconds = getElapsedSeconds(); double step = elapsedSeconds - mElapsedSeconds; mElapsedSeconds = elapsedSeconds; // Update Bullet world mDynamicsWorld->stepSimulation(1.0f, 10, 1.0f / math<float>::max(1.0f, getFrameRate())); // Get object counts uint32_t numObjects = mObjects.size(); // Update bodies for (uint32_t i = 0; i < mObjects.size(); i++) { mObjects[i]->update(step); if (mObjects[i]->getLifespan() > 0.0 && mObjects[i]->getLifetime() > mObjects[i]->getLifespan()) mObjects.erase(mObjects.begin() + i); } // Object count has changed if (numObjects != mObjects.size()) { // Iterate through objects numObjects = mDynamicsWorld->getNumCollisionObjects(); for (int32_t i = (int32_t)numObjects - 1; i >= 0 ; i--) { // Check range if (i >= 0) { // Activate object if it is a rigid or soft body btCollisionObject * collisionObject = mDynamicsWorld->getCollisionObjectArray()[i]; btRigidBody * rigidBody = btRigidBody::upcast(collisionObject); if (rigidBody) { rigidBody->activate(true); } else { btSoftBody * softBody = btSoftBody::upcast(collisionObject); if (softBody) softBody->activate(true); } } } } }
//-------------------------------------------------------------- // Reads and parses a message from the server. //-------------------------------------------------------------- void mpeClientTCP::read(string _serverInput) { out("Receiving: " + _serverInput); char c = _serverInput.at(0); if (c == 'G' || c == 'B' || c == 'I') { if (!allConnected) { if (DEBUG) out("all connected!"); allConnected = true; } // split into frame message and data message vector<string> info = ofSplitString(_serverInput, ":"); vector<string> frameMessage = ofSplitString(info[0], ","); int fc = ofToInt(frameMessage[1]); if (info.size() > 1) { // there is a message here with the frame event info.erase(info.begin()); dataMessage.clear(); dataMessage = info; bMessageAvailable = true; } else { bMessageAvailable = false; } // assume no arrays are available bIntsAvailable = false; bBytesAvailable = false; if (fc == frameCount) { rendering = true; frameCount++; // calculate new framerate float ms = getElapsedSeconds()*1000.0 - lastMs; fps = 1000.f / ms; lastMs = getElapsedSeconds()*1000.0; if (!autoMode) { parent->frameEvent(); } } } }
void PlayerBullet::update() { //location -= Vec2f((sin(getElapsedSeconds()*40)*7),SPEED*(getElapsedSeconds() - t)*60); location -= Vec2f(0,SPEED); t = getElapsedSeconds(); if(location.y < 0) { isAlive = false; } }
Cube::Cube(Vec3f loc, Vec3f colour, string type){ cubeMaterial.setSpecular( ColorA (colour.x, colour.y, colour.z, .3) ); cubeMaterial.setDiffuse( ColorA (colour.x, colour.y, colour.z, .3)); cubeMaterial.setAmbient(ColorA (colour.x, colour.y, .05f, .01f)) ; cubeMaterial.setShininess( 600.0f ); cubeMaterial.setEmission(ColorA(1, 1, 1, 1 )); gl::lineWidth(15); tempCube = cinder::gl::DisplayList (GL_COMPILE); tempCube.newList(); if (type == "stroked") gl::drawStrokedCube(Vec3f(0,0,0), Vec3f (80, 80, 80)); if (type == "solid") gl::drawCube(Vec3f(0,0,0), Vec3f (80, 80, 80)); tempCube.endList(); tempCube.setMaterial( cubeMaterial ); location = loc; rotator = Vec3f(sin(getElapsedSeconds()), cos (getElapsedSeconds()), tan(getElapsedFrames())); }
void Device::setTilt( int32_t degrees ) { double elapsedSeconds = getElapsedSeconds(); if ( mCapture && mSensor != 0 && elapsedSeconds - mTiltRequestTime > kTiltRequestInterval ) { long hr = mSensor->NuiCameraElevationSetAngle( (long)math<int32_t>::clamp( degrees, -MAXIMUM_TILT_ANGLE, MAXIMUM_TILT_ANGLE ) ); if ( FAILED( hr ) ) { console() << "Unable to change device angle: " << endl; error( hr ); } mTiltRequestTime = elapsedSeconds; } }
int PitchBendSequenceDialog::numVibratoCycles(void) { const int vibratoFrequency = m_vibratoFrequency->value(); const float totalCyclesExact = float(vibratoFrequency) * getElapsedSeconds(); // We round so that the interval gets an exact number of cycles. const int totalCycles = int(totalCyclesExact + 0.5); // Since the user wanted vibrato, provide at least one cycle. if (totalCycles > 1) { return totalCycles; } else { return 1; } }
void SystemCinderApp::update() { /*update head pos and interaction goes here*/ //elapsed time double timePassed = getElapsedSeconds() - mCurrentSeconds; mCurrentSeconds += timePassed; // rotate the teapot object mObjectRotation *= rotate(0.04f, normalize(vec3(0.1f, 1, 0.1f))); renderSceneToFbo(); }
void Kinect::setTilt( int32_t degrees ) { // Tilt requests should be spaced apart to prevent wear on the motor double elapsedSeconds = getElapsedSeconds(); if ( mCapture && mSensor != 0 && elapsedSeconds - mTiltRequestTime > kTiltRequestInterval ) { long hr = mSensor->NuiCameraElevationSetAngle( (long)math<int32_t>::clamp( degrees, -MAXIMUM_TILT_ANGLE, MAXIMUM_TILT_ANGLE ) ); if ( FAILED( hr ) ) { trace( "Unable to change device angle: " ); error( hr ); } mTiltRequestTime = elapsedSeconds; } }
MidiApp::MidiApp() : _detail(new Detail()) { #define TEST 0 switch (TEST) { case 0: _detail->testMidi = new TestSoftSynth("resources/rachmaninov3.mid"); break; case 1: _detail->testMidi = new TestSoftSynth("resources/209-Tchaikovsky - Russian Dance (Nutcracker)"); break; case 2: _detail->testMidi = new TestSoftSynth(MMLtune, true); break; case 3: _detail->testMidi = new TestInOut(); break; case 4: _detail->testMidi = new TestFrequencyCalc(); break; case 5: _detail->testMidi = new TestSoftSynth("resources/106-Grieg - In the Hall of the Mountain King (Peer Gynt)"); break; } _detail->startTime = getElapsedSeconds(); _detail->listPorts(); }
void PulseSensor::processMessage( const char messageId, const std::string message ) { MessageType messageType = convertCharToMessageType( messageId ); int messageValue = atoi( message.c_str()); switch( messageType ) { case MT_BeatPerMinute : mBeatPerMinute = messageValue; break; case MT_SensorData : mSensorData = messageValue; break; case MT_BeatPauseTime : mBeatPauseTime = messageValue; break; default : console() << "unknown message: " << message << endl; return; } mListener.callCallback( (int)messageType, messageValue ); if( mRecorder.isRecording()) mRecorder.dataRecording( getElapsedSeconds(), messageId, message ); }
void SplatTestApp::update() { if (spaceNav) { spaceNav->update(); } { const auto &ori = cameraBody.orientation; cameraBody.impulse = glm::rotate(ori, cameraTranslation * vec3(1, 1, -1)) * 0.000005f; cameraBody.angularImpulse = quat(cameraRotation * vec3(1, 1, -1) * 0.00000333f); } cameraBody.step(); cameraBody.applyTransform(camera); particleSys->update(getElapsedSeconds(), getElapsedFrames(), cameraBody.position, cameraBody.position - cameraBody.positionPrev, camera.getViewDirection()); updateGui(); }
void Kinect::run() { while ( mCapture ) { if ( mSensor != 0 ) { // Get elapsed time to calculate frame rate double time = getElapsedSeconds(); ////////////////////////////////////////////////////////////////////////////////////////////// if ( mDeviceOptions.isDepthEnabled() && mDepthStreamHandle != 0 && !mNewDepthSurface ) { _NUI_IMAGE_FRAME imageFrame; long hr = mSensor->NuiImageStreamGetNextFrame( mDepthStreamHandle, WAIT_TIME, &imageFrame ); if ( FAILED( hr ) ) { error( hr ); } else { INuiFrameTexture * texture = imageFrame.pFrameTexture; _NUI_LOCKED_RECT lockedRect; hr = texture->LockRect( 0, &lockedRect, 0, 0 ); if ( FAILED( hr ) ) { error( hr ); } if ( lockedRect.Pitch == 0 ) { trace( "Invalid buffer length received" ); } else { pixelToDepthSurface( (uint16_t*)lockedRect.pBits ); } hr = mSensor->NuiImageStreamReleaseFrame( mDepthStreamHandle, &imageFrame ); if ( FAILED( hr ) ) { error( hr ); } mFrameRateDepth = (float)( 1.0 / ( time - mReadTimeDepth ) ); mReadTimeDepth = time; mUserCount = 0; for ( uint32_t i = 0; i < NUI_SKELETON_COUNT; i++ ) { if ( mActiveUsers[ i ] ) { mUserCount++; } } mNewDepthSurface = true; } } ////////////////////////////////////////////////////////////////////////////////////////////// if ( mDeviceOptions.isSkeletonTrackingEnabled() && mIsSkeletonDevice && !mNewSkeletons ) { _NUI_SKELETON_FRAME skeletonFrame; long hr = mSensor->NuiSkeletonGetNextFrame( WAIT_TIME, &skeletonFrame ); if ( FAILED( hr ) ) { error( hr ); } else { bool foundSkeleton = false; for ( int32_t i = 0; i < NUI_SKELETON_COUNT; i++ ) { mSkeletons.at( i ).clear(); NUI_SKELETON_TRACKING_STATE trackingState = skeletonFrame.SkeletonData[ i ].eTrackingState; if ( trackingState == NUI_SKELETON_TRACKED || trackingState == NUI_SKELETON_POSITION_ONLY ) { if ( !foundSkeleton ) { _NUI_TRANSFORM_SMOOTH_PARAMETERS transform = kTransformParams[ mTransform ]; hr = mSensor->NuiTransformSmooth( &skeletonFrame, &transform ); if ( FAILED( hr ) ) { error( hr ); } foundSkeleton = true; } // Flip X when flipping the image. if ( mFlipped ) { ( skeletonFrame.SkeletonData + i )->Position.x *= -1.0f; for ( int32_t j = 0; j < (int32_t)NUI_SKELETON_POSITION_COUNT; j++ ) { ( skeletonFrame.SkeletonData + i )->SkeletonPositions[ j ].x *= -1.0f; } } _NUI_SKELETON_BONE_ORIENTATION bones[ NUI_SKELETON_POSITION_COUNT ]; hr = NuiSkeletonCalculateBoneOrientations( skeletonFrame.SkeletonData + i, bones ); if ( FAILED( hr ) ) { error( hr ); } for ( int32_t j = 0; j < (int32_t)NUI_SKELETON_POSITION_COUNT; j++ ) { Bone bone( *( ( skeletonFrame.SkeletonData + i )->SkeletonPositions + j ), *( bones + j ) ); ( mSkeletons.begin() + i )->insert( std::make_pair<JointName, Bone>( (JointName)j, bone ) ); } } } mFrameRateSkeletons = (float)( 1.0 / ( time - mReadTimeSkeletons ) ); mReadTimeSkeletons = time; mNewSkeletons = true; } } ////////////////////////////////////////////////////////////////////////////////////////////// if ( mDeviceOptions.isVideoEnabled() && mVideoStreamHandle != 0 && !mNewVideoSurface ) { _NUI_IMAGE_FRAME imageFrame; long hr = mSensor->NuiImageStreamGetNextFrame( mVideoStreamHandle, WAIT_TIME, &imageFrame ); if ( FAILED( hr ) ) { error( hr ); } else { INuiFrameTexture * texture = imageFrame.pFrameTexture; _NUI_LOCKED_RECT lockedRect; hr = texture->LockRect( 0, &lockedRect, 0, 0 ); if ( FAILED( hr ) ) { error( hr ); } if ( lockedRect.Pitch != 0 ) { pixelToVideoSurface( (uint8_t *)lockedRect.pBits ); } else { trace( "Invalid buffer length received." ); } hr = mSensor->NuiImageStreamReleaseFrame( mVideoStreamHandle, &imageFrame ); if ( FAILED( hr ) ) { error( hr ); } mFrameRateVideo = (float)( 1.0 / ( time - mReadTimeVideo ) ); mReadTimeVideo = time; mNewVideoSurface = true; } } } Sleep( 8 ); } // Return to join thread return; }
RecipeView::RecipeView(UserAreaModel _area, RecipeModel _recipe){ lastTouched = getElapsedSeconds(); recipeModel = _recipe; areaModel = _area; timeOut = areaModel.timeout; // menu_img.load(_model.getMenuImage()); debugState = 2; curStep = 0; stepState = 0; prevStepState = -1; prevStep = -1; pos = Vec2f(_area.x,_area.y); rotation = _area.r; align=TOP_LEFT; if(_area.name.compare("bottom-left")==0) align=BOTTOM_LEFT; if(_area.name.compare("bottom-right")==0) align=BOTTOM_RIGHT; if(_area.name.compare("top-left")==0){ align=BOTTOM_RIGHT; console() << "aligning top left"; } if(_area.name.compare("top-right")==0){ align=BOTTOM_LEFT; console() << "aligning top right"; } console() << "this recipemodel has this many steps: " << recipeModel.getNumSteps() << "." << endl; for(int i=0;i<recipeModel.getNumSteps();i++){ console() << "wtf: " << recipeModel.getCookStep(i).img.at(0) << endl; gallerytools::Image anImage; anImage.load(recipeModel.getCookStep(i).img.at(recipeModel.curLanguage)); anImage.hide(); images.push_back(anImage); gallerytools::Video aVideo; console() << "loading video::: " << aVideo.load(recipeModel.getCookStep(i).video.at(recipeModel.curLanguage)) << endl; aVideo.hide(); videos.push_back(aVideo); } back_btn.load(areaModel.back_btn.path); back_btn.moveTo(areaModel.back_btn.x,areaModel.back_btn.y,false); fwd_btn.load(areaModel.fwd_btn.path); fwd_btn.moveTo(areaModel.fwd_btn.x,areaModel.fwd_btn.y,false); select_btn.load(areaModel.select_btn.path); select_btn.moveTo(areaModel.select_btn.x,areaModel.select_btn.y,false); string normalFont( "Arial" ); TextLayout layout; layout.clear( ColorA( 0.5f, 0.5f, 0.5f, 0.5f ) ); layout.setFont( Font( normalFont, 24 ) ); layout.setColor( Color( 1, 1, 1 ) ); layout.addLine( "testing here"); Surface8u rendered = layout.render( true, false ); text_texture = gl::Texture( rendered ); select_btn.setHalfHidden(); back_btn.setHalfHidden(); fwd_btn.setHalfHidden(); }
void RecipeView::update(){ //console() << ":::TIMED OUT:::" << endl; if((curStep==0 && stepState==0) || stepState==1){ // it's already at the start, or if it's on a video... delayTimeOut(); } else { double curTime = getElapsedSeconds(); if((curTime-lastTouched)>timeOut){ console() << "going to start: " << recipeModel.name << endl; goStart(); } } for(int i=0;i<videos.size();i++){ if(i!=curStep){ // videos.at(i).stop(); } } if(stepState==1){ if(videos.size()>curStep){ videos.at(curStep).update(); if(videos.at(curStep).isDone()) forwardRelease(); } } char buffer [40]; sprintf (buffer, "curStep: %i \n stepState: %i", curStep, stepState); TextLayout layout; layout.clear( ColorA( 0.5f, 0.5f, 0.5f, 0.5f ) ); layout.setFont( Font( "Arial", 18 ) ); layout.setColor( Color( 1, 1, 1 ) ); layout.addLine(recipeModel.name.c_str()); layout.addLine( buffer); Surface8u rendered = layout.render( true, false ); text_texture = gl::Texture( rendered ); // this needs work here.... // this is specifically to handle a goStart() situation... if(prevStepState==0 && stepState == 0 && prevStep!=curStep){ console() << "THIS SHOULD BE FIRING on TIMEOUT >>> " << recipeModel.name << endl; if(images.size()>prevStep) images.at(prevStep).hide(); if(images.size()>curStep) images.at(curStep).show(); prevStep = curStep; } else { if(prevStep!=curStep){ // moved from video to new start image // load both the image and the video for the new step if(prevStep>-1) videos.at(prevStep).stop(); prevStep = curStep; } if(prevStepState!=stepState){ // moved from start image to video if(stepState==1){ if(videos.size()>curStep) videos.at(curStep).show(); if(images.size()>curStep) images.at(curStep).hide(); if(videos.size()>curStep) videos.at(curStep).play(); } else { if(images.size()>curStep) images.at(curStep).show(); if(videos.size()>curStep) videos.at(curStep).hide(); if(videos.size()>curStep) videos.at(curStep).stop(); } prevStepState = stepState; } } }
void RecipeView::delayTimeOut(){ lastTouched = getElapsedSeconds(); }
bool MidiApp::running() { return _detail->testMidi->running(getElapsedSeconds() - _detail->startTime); }
void Kinect::run() { while ( mCapture ) { if ( mSensor != 0 ) { // Get elapsed time to calculate frame rate double time = getElapsedSeconds(); ////////////////////////////////////////////////////////////////////////////////////////////// if ( mEnabledDepth && mDepthStreamHandle != 0 && !mNewDepthFrame ) { // Acquire depth image _NUI_IMAGE_FRAME imageFrame; HRESULT hr = mSensor->NuiImageStreamGetNextFrame( mDepthStreamHandle, WAIT_TIME, &imageFrame ); if ( FAILED( hr ) ) { error( hr ); } else { // Read texture to surface INuiFrameTexture * texture = imageFrame.pFrameTexture; _NUI_LOCKED_RECT lockedRect; hr = texture->LockRect( 0, &lockedRect, 0, 0 ); if ( FAILED( hr ) ) { error( hr ); } if ( lockedRect.Pitch == 0 ) { trace( "Invalid buffer length received" ); } else { pixelToDepthSurface( mDepthSurface, (uint16_t*)lockedRect.pBits ); } // Clean up hr = mSensor->NuiImageStreamReleaseFrame( mDepthStreamHandle, &imageFrame ); if ( FAILED( hr ) ) { error( hr ); } // Update frame rate mFrameRateDepth = (float)( 1.0 / ( time - mReadTimeDepth ) ); mReadTimeDepth = time; // Set flag mNewDepthFrame = true; // Update user count mUserCount = 0; for ( uint32_t i = 0; i < NUI_SKELETON_COUNT; i++ ) { if ( mActiveUsers[ i ] ) { mUserCount++; } } } } ////////////////////////////////////////////////////////////////////////////////////////////// if ( mEnabledSkeletons && mIsSkeletonDevice && !mNewSkeletons ) { // Acquire skeleton _NUI_SKELETON_FRAME skeletonFrame; HRESULT hr = mSensor->NuiSkeletonGetNextFrame( WAIT_TIME, &skeletonFrame ); if ( FAILED( hr ) ) { error( hr ); } else { // Iterate through skeletons bool foundSkeleton = false; for ( int32_t i = 0; i < NUI_SKELETON_COUNT; i++ ) { // Clear skeleton data mSkeletons[ i ].clear(); // Mark skeleton found if ( ( skeletonFrame.SkeletonData + i )->eTrackingState == NUI_SKELETON_TRACKED ) { // Smooth out the skeleton data when found if ( !foundSkeleton ) { hr = mSensor->NuiTransformSmooth( &skeletonFrame, 0 ); if ( FAILED( hr ) ) { error( hr ); } foundSkeleton = true; } // Get skeleton data _NUI_SKELETON_DATA skeletonData = *( skeletonFrame.SkeletonData + i ); // Set joint data for ( int32_t j = 0; j < (int32_t)NUI_SKELETON_POSITION_COUNT; j++ ) { Vector4 point = *( skeletonData.SkeletonPositions + j ); ( mSkeletons.begin() + i )->insert( std::make_pair<JointName, Vec3f>( (JointName)j, Vec3f( point.x, point.y, point.z ) ) ); } } } // Update frame rate mFrameRateSkeletons = (float)( 1.0 / ( time - mReadTimeSkeletons ) ); mReadTimeSkeletons = time; // Set flag mNewSkeletons = true; } } ////////////////////////////////////////////////////////////////////////////////////////////// if ( mEnabledVideo && mVideoStreamHandle != 0 && !mNewVideoFrame ) { // Acquire video image _NUI_IMAGE_FRAME imageFrame; HRESULT hr = mSensor->NuiImageStreamGetNextFrame( mVideoStreamHandle, WAIT_TIME, &imageFrame ); if ( FAILED( hr ) ) { error( hr ); } else { // Read texture INuiFrameTexture * texture = imageFrame.pFrameTexture; _NUI_LOCKED_RECT lockedRect; hr = texture->LockRect( 0, &lockedRect, 0, 0 ); if ( FAILED( hr ) ) { error( hr ); } if ( lockedRect.Pitch != 0 ) { pixelToVideoSurface( mVideoSurface, (uint8_t *)lockedRect.pBits ); } else { trace( "Invalid buffer length received." ); } // Clean up hr = mSensor->NuiImageStreamReleaseFrame( mVideoStreamHandle, &imageFrame ); if ( FAILED( hr ) ) { error( hr ); } // Update frame rate mFrameRateVideo = (float)( 1.0 / ( time - mReadTimeVideo ) ); mReadTimeVideo = time; // Set flag mNewVideoFrame = true; } } } // Pause thread Sleep( 17 ); } // Return to join thread return; }
double ClockInterface::getElapsedSeconds(const PreciseClock& start) { return getElapsedSeconds(start, getMonotonicClock()); }
void AppBase::privateSetup__() { mTimeline->stepTo( static_cast<float>( getElapsedSeconds() ) ); setup(); }
void StateLose::update() { if (getElapsedSeconds() > n_countdown) _app.changeToState(_app._state_idle); }
void ProjectManagerApp::draw() { gl::clear(bgColor); gui->draw(getElapsedSeconds()); }
void DataManager::updateDataCrawler( DataCrawler* dataCrawler ){ if(dataCrawler->length == 0) return; double time = getElapsedSeconds(); double diff = time - dataCrawler->lastUpdate; float pos = dataCrawler->roiDataSet.startPosition + (diff * (float)dataCrawler->speed*mMainSpeed); // console() << "DataManager::updateDataCrawler! pos " h<< pos << " diff:" << diff << std::endl; dataCrawler->pos = pos; if( dataCrawler->roiDataSet.endPosition <= pos ){ dataCrawler->roiDataSet = getNextRoi(dataCrawler); dataCrawler->roiDataSetID = dataCrawler->roiDataSet.roiId; dataCrawler->lastUpdate = getElapsedSeconds(); dataCrawler->pos = dataCrawler->roiDataSet.startPosition; dataCrawler->speed = 2;//pow(Rand::randInt(1,4),2); sOnRoiChange(); console() << "DataManager::updateDataCrawler::resetCrawler " << std::endl; } // int len = dataCrawler->length; int len = dataCrawler->roiDataSet.basePairsCount; char* datas = (char*)mDataBuffer.getData(); int size = mDataBuffer.getDataSize(); char d; string dataString = ""; for(int i=dataCrawler->roiDataSet.startPosition;i<dataCrawler->roiDataSet.startPosition+len;i++){ d = *(datas+min(i,size-1)); dataString += d; } // for(int i=start;i<end;i++){ // // d = *(datas+min(i,size-1)); // // dataString += d; //// dataCharPos = (int)(cnt / 4); //// dataBitPos = ((cnt%4)) * 2; // // // seems to be the fastest way to do it like this according to: // // http://stackoverflow.com/questions/6860525/c-what-is-faster-lookup-in-hashmap-or-switch-statement // // // switch(d){ // case 'A': //// rawData[dataCharPos] |= 0 << dataBitPos; //// dataString += "A"; // break; // case 'C': //// rawData[dataCharPos] |= 1 << dataBitPos; //// dataString += "C"; // break; // case 'G': //// rawData[dataCharPos] |= 2 << dataBitPos; //// dataString += "G"; // break; // case 'T': //// dataString += "T"; //// rawData[dataCharPos] |= 3 << dataBitPos; // break; // // } // cnt++; // } dataCrawler->dataSet.dataBitsString = dataString; dataCrawler->dataSet.startPosition = pos; dataCrawler->dataSet.basePairsCount = len; dataCrawler->dataSet.chromosomeData = mCurrentDataSet; dataCrawler->dataSet.roi = dataCrawler->roiDataSet; dataCrawler->dataSet.percent = (dataCrawler->pos-dataCrawler->roiDataSet.startPosition) / (float)dataCrawler->roiDataSet.basePairsCount; }
void MidiApp::update() { _detail->testMidi->update(getElapsedSeconds() - _detail->startTime); }
void AppImplMswBasic::run() { mFrameRate = mApp->getSettings().getFrameRate(); mFrameRateEnabled = mApp->getSettings().isFrameRateEnabled(); auto formats = mApp->getSettings().getWindowFormats(); if( formats.empty() ) formats.push_back( mApp->getSettings().getDefaultWindowFormat() ); for( auto format = formats.begin(); format != formats.end(); ++format ) { if( ! format->isTitleSpecified() ) format->setTitle( mApp->getSettings().getTitle() ); createWindow( *format ); } mApp->privateSetup__(); mSetupHasBeenCalled = true; for( auto windowIt = mWindows.begin(); windowIt != mWindows.end(); ++windowIt ) (*windowIt)->resize(); // initialize our next frame time mNextFrameTime = getElapsedSeconds(); // inner loop while( ! mShouldQuit ) { // update and draw mApp->privateUpdate__(); for( auto windowIt = mWindows.begin(); windowIt != mWindows.end(); ++windowIt ) (*windowIt)->redraw(); // get current time in seconds double currentSeconds = mApp->getElapsedSeconds(); // calculate time per frame in seconds double secondsPerFrame = 1.0 / mFrameRate; // determine if application was frozen for a while and adjust next frame time double elapsedSeconds = currentSeconds - mNextFrameTime; if( elapsedSeconds > 1.0 ) { int numSkipFrames = (int)(elapsedSeconds / secondsPerFrame); mNextFrameTime += (numSkipFrames * secondsPerFrame); } // determine when next frame should be drawn mNextFrameTime += secondsPerFrame; // sleep and process messages until next frame if( ( mFrameRateEnabled ) && ( mNextFrameTime > currentSeconds ) ) sleep(mNextFrameTime - currentSeconds); else { MSG msg; while( ::PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) ) { ::TranslateMessage( &msg ); ::DispatchMessage( &msg ); } } } // killWindow( mFullScreen ); mApp->emitShutdown(); delete mApp; }
void Device::run() { HANDLE events[ 4 ]; events[ 0 ] = mColorEvent; events[ 1 ] = mDepthEvent; events[ 2 ] = mSkeletonEvent; while ( mCapture ) { if ( mSensor != 0 ) { double time = getElapsedSeconds(); WaitForMultipleObjects( sizeof( events ) / sizeof( events[ 0 ]), events, 0, WAIT_TIME ); const NUI_IMAGE_FRAME* frameColor = 0; const NUI_IMAGE_FRAME* frameDepth = 0; NUI_SKELETON_FRAME frameSkeleton = { 0 }; bool readColor = !mNewColorSurface; bool readDepth = !mNewDepthSurface; bool readSkeleton = !mNewSkeletons; /*if ( mDeviceOptions.isFrameSyncEnabled() && mDeviceOptions.isColorEnabled() && mDeviceOptions.isDepthEnabled() ) { if ( readColor != readDepth ) { readColor = false; readDepth = false; } readSkeleton = readDepth; }*/ readColor = readColor && mDeviceOptions.isColorEnabled(); readDepth = readDepth && mDeviceOptions.isDepthEnabled(); readSkeleton = readSkeleton && mDeviceOptions.isSkeletonTrackingEnabled(); ////////////////////////////////////////////////////////////////////////////////////////////// if ( readDepth && WAIT_OBJECT_0 == WaitForSingleObject( mDepthEvent, 0 ) ) { if ( SUCCEEDED( NuiImageStreamGetNextFrame( mDepthStreamHandle, 0, &frameDepth ) ) && frameDepth != 0 && frameDepth->pFrameTexture != 0 ) { mDepthTimeStamp = frameDepth->liTimeStamp.QuadPart; INuiFrameTexture* texture = frameDepth->pFrameTexture; _NUI_LOCKED_RECT lockedRect; long hr = texture->LockRect( 0, &lockedRect, 0, 0 ); if ( FAILED( hr ) ) { error( hr ); } if ( lockedRect.Pitch == 0 ) { console() << "Invalid buffer length received" << endl; } else { pixelToDepthSurface( (uint16_t*)lockedRect.pBits ); } hr = NuiImageStreamReleaseFrame( mDepthStreamHandle, frameDepth ); if ( FAILED( hr ) ) { error( hr ); } mUserCount = 0; for ( uint32_t i = 0; i < NUI_SKELETON_COUNT; ++i ) { if ( mActiveUsers[ i ] ) { ++mUserCount; } } mNewDepthSurface = true; } } ////////////////////////////////////////////////////////////////////////////////////////////// if ( readColor && WAIT_OBJECT_0 == WaitForSingleObject( mColorEvent, 0 ) ) { if ( SUCCEEDED( NuiImageStreamGetNextFrame( mColorStreamHandle, 0, &frameColor ) ) && frameColor != 0 && frameColor->pFrameTexture != 0 ) { INuiFrameTexture* texture = frameColor->pFrameTexture; _NUI_LOCKED_RECT lockedRect; long hr = texture->LockRect( 0, &lockedRect, 0, 0 ); if ( FAILED( hr ) ) { error( hr ); } if ( lockedRect.Pitch != 0 ) { pixelToColorSurface( (uint8_t*)lockedRect.pBits ); /*if ( mDeviceOptions.isFrameSyncEnabled() ) { mColorFrames.push_back( ColorFrame( mColorSurface, frameColor->liTimeStamp.QuadPart ) ); if ( mColorFrames.size() > 10 ) { mColorFrames.erase( mColorFrames.begin() ); } }*/ } else { console() << "Invalid buffer length received." << endl; } hr = NuiImageStreamReleaseFrame( mColorStreamHandle, frameColor ); if ( FAILED( hr ) ) { error( hr ); } mNewColorSurface = true; } } ////////////////////////////////////////////////////////////////////////////////////////////// if ( readSkeleton && WAIT_OBJECT_0 == WaitForSingleObject( mSkeletonEvent, 0 ) ) { long hr = NuiSkeletonGetNextFrame( 0, &frameSkeleton ); if ( SUCCEEDED( hr ) ) { bool foundSkeleton = false; for ( int32_t i = 0; i < NUI_SKELETON_COUNT; ++i ) { mSkeletons.at( i ).clear(); NUI_SKELETON_TRACKING_STATE trackingState = frameSkeleton.SkeletonData[ i ].eTrackingState; if ( trackingState == NUI_SKELETON_TRACKED || trackingState == NUI_SKELETON_POSITION_ONLY ) { if ( !foundSkeleton ) { _NUI_TRANSFORM_SMOOTH_PARAMETERS transform = kTransformParams[ mTransform ]; hr = mSensor->NuiTransformSmooth( &frameSkeleton, &transform ); if ( FAILED( hr ) ) { error( hr ); } foundSkeleton = true; } if ( mFlipped ) { ( frameSkeleton.SkeletonData + i )->Position.x *= -1.0f; for ( int32_t j = 0; j < (int32_t)NUI_SKELETON_POSITION_COUNT; ++j ) { ( frameSkeleton.SkeletonData + i )->SkeletonPositions[ j ].x *= -1.0f; } } _NUI_SKELETON_BONE_ORIENTATION bones[ NUI_SKELETON_POSITION_COUNT ]; hr = NuiSkeletonCalculateBoneOrientations( frameSkeleton.SkeletonData + i, bones ); if ( FAILED( hr ) ) { error( hr ); } for ( int32_t j = 0; j < (int32_t)NUI_SKELETON_POSITION_COUNT; ++j ) { Bone bone( *( ( frameSkeleton.SkeletonData + i )->SkeletonPositions + j ), *( bones + j ) ); ( mSkeletons.begin() + i )->insert( std::pair<JointName, Bone>( (JointName)j, bone ) ); } } } mNewSkeletons = true; } mFrameRate = (float)( 1.0 / ( time - mReadTime ) ); mReadTime = time; } } } return; }