//--------------------------------------------------------------
void ofApp::update(){
    ofSoundUpdate();
    updateStars();
    movie.update();
    
    satellite.setRotation(1, 270 + (ofGetElapsedTimef()*10), 1, 0, 1);
    
    time += ofGetElapsedTimef() - time;
    
    bool audioPlaying = false;
    for (int i = 0; i < 3; i++) {
        if (audioTracks[i].getIsPlaying()) { audioPlaying = true; }
    }
    
    // when all the audio has been played, print stats to the console
    if (isReady && !audioPlaying && !printedStats) {
        printStats();
        printedStats = true;
    }
    
    // checks to see if the prelude is over, if so start the main animation
    if (isPrelude && ((time-timer) > 15.0f)) {
        isPrelude = false;
        isReady = true;
        audioA.play();
        audioB.play();
        audioC.play();
    }
}
Exemple #2
0
//--------------------------------------------------------------
void ofApp::update(){
    ofSoundUpdate();
    beat.setVolume(volume);
    beat.setSpeed(speed);
    
    visual01.update();
}
Exemple #3
0
//--------------------------------------------------------------
void testApp::update(){
    
	//flock
	flocker.applyForces(80, 0.4, 0.75);
    flocker.update();
	//end flock
	
	ofSoundUpdate();
	
    if( bDragging ){
        return;
    }
    
    for( int i=0; i<springList.size(); i++ ){
        springList[i].update();
		
		
    }

    
    for( int i=0; i<jointList.size(); i++ ){
        //jointList[i].update();
		//xenos
				if (i==0) {
					jointList[i].xenoToPoint(mouseX,mouseY);
				}else {
					jointList[i].xenoToPoint(jointList[i-1].pos.x, jointList[i-1].pos.y);
				}
		
    }
}
Exemple #4
0
//--------------------------------------------------------------
void testApp::update()
{
	// Nécessaire pour le moteur de sons d'Openframeworks
	ofSoundUpdate();

	// Nécessaire pour la mise à jour du GPIO
	updateInputOutput();

	//
	if (!listSounds[0].getIsPlaying()){
		playSound(0);
	}

	// Exemple de lecture depuis une entrée
	// Puis écriture sur la sortir "/output0"
	int value = readInput(5);
	if (value>0)
	{
		soundVolumeTarget = 0.0f;
		soundVolume += (soundVolumeTarget-soundVolume)*0.2;
	}
	else
	{
		ofLogNotice() << "touch detected";
		soundVolumeTarget = 1.0f;
		soundVolume += (soundVolumeTarget-soundVolume)*0.7;
	}

	listSounds[0].setVolume(soundVolume);
}
Exemple #5
0
//--------------------------------------------------------------
void testApp::update()
{
	ofBackground(100, 100, 100);
	kinect.update();

	grayImage.setFromPixels(kinect.getDepthPixels(), kinect.width, kinect.height);
			
	if( bThreshWithOpenCV ){
		
		grayThreshFar = grayImage;
		grayThresh = grayImage;
		grayThreshFar.threshold(farThreshold, true);
		grayThresh.threshold(nearThreshold);
		cvAnd(grayThresh.getCvImage(), grayThreshFar.getCvImage(), grayImage.getCvImage(), NULL);
		 
	}

	// if one blob found, find nearest point in blob area		
	//update the cv image
	grayImage.flagImageChanged();
    // find contours which are between the size of 20 pixels and 1/3 the w*h pixels.
    // also, find holes is set to true so we will get interior contours as well....
    contourFinder.findContours(grayImage, 10, (kinect.width*kinect.height)/2, 200, false);
	ofSoundUpdate();
	
	
}
//--------------------------------------------------------------
void SoundManager::update(double dt)
{
    ofSoundUpdate();
    
    if(!m_currentSample)
    {
        return;
    }
    
    
    if(!m_currentSample->isPlaying())
    {
        if (m_playExpert) {
            this->resetSamples();
            AppManager::getInstance().getEventManager().setTimedEvent("END_ALL_SAMPLES", m_stateManager->m_t5);
        }
        
        else{
            AppManager::getInstance().getVisualEffectsManager().removeAllVisualEffects(*m_sampleName);
            AppManager::getInstance().getViewManager().fadeVisual(*m_sampleName, 0, m_stateManager->m_t5);
            AppManager::getInstance().getEventManager().setTimedEvent("END_SAMPLE", m_stateManager->m_t5);
            m_currentSample = NULL;
        }
    }  
}
void SuperColliderLooper::update(){
    float t = beat + (float) (ofGetElapsedTimef() - timeLast) / timeInterval;
    for (auto e : elements) {
        e->update(t);
    }
    ofSoundUpdate();
}
Exemple #8
0
//--------------------------------------------------------------
void testApp::update(){	
	
	ofBackground(255,255,255);
	
	// update the sound playing system:
	ofSoundUpdate();
	
}
Exemple #9
0
//--------------------------------------------------------------
void ofApp::update(){
	
	ofBackground(80,80,20);

	// update the sound playing system:
	ofSoundUpdate();	
	
	// (1) we increase px and py by adding vx and vy
	px += vx;
	py += vy;
	
	// (2) check for collision, and trigger sounds:
	// horizontal collisions:
	if (px < 0){
		px = 0;
		vx *= -1;
		dog.play();
	} else if (px > ofGetWidth()){
		px = ofGetWidth();
		vx *= -1;
		ow.play();
	}
	// vertical collisions:
	if (py < 0 ){
		py = 0;
		vy *= -1;
		rooster.play();
	} else if (py > ofGetHeight()){
		py = ofGetHeight();
		vy *= -1;
		beat.play();
	}
	// (3) slow down velocity:
	vx 	*= 0.996f;
	vy 	*= 0.996f;

	// (4) we use velocity for volume of the samples:
	float vel = sqrt(vx*vx + vy*vy);
	ow.setVolume(MIN(vel/5.0f, 1));
	beat.setVolume(MIN(vel/5.0f, 1));
	dog.setVolume(MIN(vel/5.0f, 1));
	rooster.setVolume(MIN(vel/5.0f, 1));

	// (5) grab the fft, and put in into a "smoothed" array,
	//		by taking maximums, as peaks and then smoothing downward
	float * val = ofSoundGetSpectrum(nBandsToGet);		// request 128 values for fft
	for (int i = 0;i < nBandsToGet; i++){
		
		// let the smoothed value sink to zero:
		fftSmoothed[i] *= 0.96f;
		
		// take the max, either the smoothed or the incoming:
		if (fftSmoothed[i] < val[i]) fftSmoothed[i] = val[i];
		
	}


}
//--------------------------------------------------------------
void ofApp::update(){
    float time = ofGetElapsedTimef();
    float x = time*0.1 + 30;
    for (int i=0;i<VOICES; i++) {
        float y = i * 0.02;
        float volume = ofNoise(x,y);
        voicePlayer[i].setVolume(volume);
    }
    ofSoundUpdate();
}
Exemple #11
0
void CEQView::soundUpdate()
{
    ofSoundUpdate();

    float * val = ofSoundGetSpectrum(m_nBandsToGet);
    for (int i = 0; i<m_nBandsToGet; i++) {
        //let the smoothed value sink to zero
        m_fftSmoothed[i] *= 0.96f; //Creates an animated drop back to zero
        if (m_fftSmoothed[i] < val[i]) m_fftSmoothed[i] = val[i];
    }
}
Exemple #12
0
void ofApp::updateSound(){
    ofSoundUpdate();
    
    float * val = ofSoundGetSpectrum(nBandsToGet);
    
    for (int i = 0;i < nBandsToGet; i++){
        
        fftSmoothed[i] *= 0.96f;
        if (fftSmoothed[i] < val[i]) fftSmoothed[i] = val[i];
        
    }
}
//--------------------------------------------------------------
void testApp::update() {
    // Mise à jour des sons
    ofSoundUpdate();
    int nRead  = 0;
    // Mise à jour des vidéos
    for (int idx=0; idx<NBVIDS; idx++) {
        vids[idx].update();
    }

    // Lecture Série !
    memset(bytesReadString, 0, 12);
    int byte1;
    if (bSerialInited) {
        if (serial.available()>0) {
            byte1 = serial.readByte();
            // printf("byte1 : %d\n", byte1);
            nRead = serial.readBytes(bytesReturned, 4);
            memcpy(bytesReadString, bytesReturned, nRead);
            // printf("suite : %s (int[0] = %d)\n", bytesReadString, bytesReadString[0]);
            if (byte1==88 && bytesReadString[0]!=0) { // accX
                accXLu = atoi(bytesReadString);
                accX *= 0.985;
                accX += 0.015 * float(accXLu);
            }
            if (byte1==89 && bytesReadString[0]!=0) { // accX
                accYLu = atoi(bytesReadString);
                accY *= 0.985;
                accY += 0.015 * float(accYLu);
            }
        }
    };

    // Mise à jour accéléromètre
    if (accX >= 400.0 && accX <= 510.0) {
        if (!sounds[4].getIsPlaying()) {
            sounds[4].play();
        }
        float speed = (accX - 400.0) / 110.0;
        float pan = (accX - 425.0) / 200.0;
        if (speed<-0.5) speed = -0.5;
        if (speed>0.5) speed = 0.5;
        if (pan<-1) pan = -1;
        if (pan>1) pan = 1;
        sounds[4].setSpeed( 0.5f + speed);
        sounds[4].setPan( 0.5f + pan);
        //printf("Play Cerf - speed : %.2f\n");
    } else {
        //printf("Stop Cerf !!!\n");
        if (sounds[4].getIsPlaying()) {
            sounds[4].stop();
        }
    }
}
//--------------------------------------------------------------
void testApp::update(){
    ofSoundUpdate();
   if(!chune.getIsPlaying())
   {
    chune.play();
   }
   
    // (5) grab the fft, and put in into a "smoothed" array,
	//		by taking maximums, as peaks and then smoothing downward
	float * val = ofSoundGetSpectrum(nBandsToGet);		// request 128 values for fft
	for (int i = 0;i < nBandsToGet; i++){
        
		// let the smoothed calue sink to zero:
		fftSmoothed[i] *= 0.96f;
		
		// take the max, either the smoothed or the incoming:
		if (fftSmoothed[i] < val[i]) fftSmoothed[i] = val[i];
		
	}
  
    for(int i = 0; i<3; i++) avgSound[i] = 0;
    
    // smooth fft and calc average volume
	for (int i = 0;i < nBandsToGet; i++){
		fftSmoothed[i] *= 0.96f;
		if (fftSmoothed[i] < val[i]) fftSmoothed[i] = val[i];
    
        if(i < (nBandsToGet/3)) avgSound[0] += fftSmoothed[i];
        if(i < (nBandsToGet/3)*2 && i > (nBandsToGet/2)) avgSound[1] += fftSmoothed[i];
        if(i > (nBandsToGet/3)*2) avgSound[2] += fftSmoothed[i];
	}
    
    // calculate average loudness of the music for "volume"
    avgSound[0] /= nBandsToGet;
    
    vidGrabber.update();
    
    if (vidGrabber.isFrameNew()) {
        tex1=vidGrabber.getTextureReference();
    }
    
    float centroidTop = 0;
    float centroidBottom = 0;
    for (int i = 0; i < nBandsToGet/2; i++)
    {
        centroidBottom += fftSmoothed[i];
        centroidTop += (fftSmoothed[i]*i);
    }
    centroid = centroidTop/centroidBottom;
    centroid = centroid/(nBandsToGet/2);
   // cout << centroid;
   // cout << " --- ";
}
Exemple #15
0
//--------------------------------------------------------------
void ofApp::update(){
    ofSoundUpdate();

    if(arraySounds[currentSoundIndex].getPosition() >= 0.95){
        arraySounds[currentSoundIndex].stop();
        arraySounds[currentSoundIndex].setPosition(0.0f);
        currentSoundIndex++;
        if(currentSoundIndex >= numberOfSounds){
            currentSoundIndex = 0;
        }
        arraySounds[currentSoundIndex].play();
    }
}
//--------------------------------------------------------------
void testApp::update(){
	ofSoundUpdate();
    
    float * val = ofSoundGetSpectrum(nBandsToGet);		// request 128 values for fft
	for (int i = 0;i < nBandsToGet; i++){
		
		// let the smoothed calue sink to zero:
		fftSmoothed[i] *= 0.96f;
		
		// take the max, either the smoothed or the incoming:
		if (fftSmoothed[i] < val[i]) fftSmoothed[i] = val[i];
		
	}

    
    movie.update();
    
    
    
    
    
    if(movie.isFrameNew()){
        
        if(drawRuttEtra){
        
        vidPixels = movie.getPixelsRef();
        
        
        }
  
    }
    
	float p = movie.getPosition();
    
    
	//printf("%f\n",p);
	
	// Broadcast current position information of movie
	if ((!started || count % howOften == 0)) {
		ofxOscMessage m;
		m.setAddress( "/movie/position" );
		m.addFloatArg(p);
        m.addFloatArg(yStep);
        m.addFloatArg(xStep);
        m.addIntArg(drawRuttEtra);
		sender1.sendMessage(m);
		sender2.sendMessage(m);
		started = true;
	}
	count++;
}
//--------------------------------------------------------------
void audioPlayer::update(int newRectX, int newRectY, string newLargeAudioDir){
    largeAudioDir = newLargeAudioDir;
    
    if (largeAudioDir != largeAudioDirTest) {
        large.unloadSound();
        large.loadSound(largeAudioDir);
        largeAudioDirTest = largeAudioDir;
    }
    
    //ofxSimpleSlider-----------------_
    float pctPos = 0;//sliderPosition.getValue();
    float pctSpeed = 1;//sliderSpeed.getValue();
    float pctVolume = 0.75;//sliderVolume.getValue();
    largeAudioPosition = pctPos;
    largeAudioSpeed = pctSpeed;
    largeAudioVolume = pctVolume;
    //----------ofxSimpleSlider-------_

    
    
    getLargePositionMS = large.getPositionMS();
    getLargePosition = large.getPosition();// just to have a 0-1 Position
    getLargeSpeed = large.getSpeed();
    getLargeVolume = large.getVolume();
    
	if (isPlay == true) {
        large.play();
        //large.setPositionMS(largeAudioPosition);
        large.setPosition(largeAudioPosition);
		large.setSpeed(largeAudioSpeed);
        large.setVolume(largeAudioVolume);
        isPlay = false;
    }
    if (large.getIsPlaying()) {
        playColor.set(255, 0, 255, 255);
    }else {
        playColor.set(100, 100, 255, 255);
    }
    if (isPaused == true) {
        large.setPaused(true);
        pausedColor.set(255, 0, 255, 255);
        isPlay = false;
    }else {
        pausedColor.set(100, 100, 255, 255);
        large.setPaused(false);
    }
   	// update the sound playing system:
    ofSoundUpdate();

}
//--------------------------------------------------------------
void ofApp::update(){
	//Update sound engine
	ofSoundUpdate();

	//Get current spectrum with N bands
	float *val = ofSoundGetSpectrum( N );
	//We should not release memory of val,
	//because it is managed by sound engine

	//Update our smoothed spectrum,
	//by slowly decreasing its values and getting maximum with val
	//So we will have slowly falling peaks in spectrum
	for ( int i=0; i<N; i++ ) {
		spectrum[i] *= 0.97;	//Slow decreasing
		spectrum[i] = max( spectrum[i], val[i] );
	}

	//Update particles using spectrum values

	//Computing dt as a time between the last
	//and the current calling of update()
	float time = ofGetElapsedTimef();
	float dt = time - time0;
	dt = ofClamp( dt, 0.0, 0.1 );
	time0 = time; //Store the current time

	//Update Rad and Vel from spectrum
	//Note, the parameters in ofMap's were tuned for best result
	//just for current music track
	Rad = ofMap( spectrum[ bandRad ], 1, 3, 400, 800, true );
	Vel = ofMap( spectrum[ bandVel ], 0, 0.1, 0.05, 0.5 );

	//Update particles positions
	for (int j=0; j<n; j++) {
		tx[j] += Vel * dt;	//move offset
		ty[j] += Vel * dt;	//move offset
		//Calculate Perlin's noise in [-1, 1] and
		//multiply on Rad
		p[j].x = ofSignedNoise( tx[j] ) * Rad;
		p[j].y = ofSignedNoise( ty[j] ) * Rad;
	}

    if (bg_transparent > 0){
        bg_transparent = 255 - time * 3.5;
    }
    else{
        bg_transparent = 0;
    }

}
//--------------------------------------------------------------
void testApp::update(){
    
    howareyou.update();
    
    menuNOSTALGIC.update();
    menuINTROSPECTIVE.update();
    menuLOST.update();
    menuDETERMINED.update();
    
    fadeOutVid.update();
    updateVideos();
    
    playSong(songMood);
    
    ofSoundUpdate();
    
    if (fadeOutVid.getIsMovieDone()) {
        fadeOutVid.closeMovie();
        
        switch (moodSelected) {
                
            case 1 :
                nostalgic[randomNostalgic].play();
                nostalgic[randomNostalgic].setLoopState(OF_LOOP_NONE);
                break;
                
            case 2 :
                introspective[randomIntrospective].play();
                introspective[randomIntrospective].setLoopState(OF_LOOP_NONE);
                break;
                
            case 3 :
                lost[randomLost].play();
                lost[randomLost].setLoopState(OF_LOOP_NONE);
                break;
                
            case 4 :
                determined[randomDetermined].play();
                determined[randomDetermined].setLoopState(OF_LOOP_NONE);
                break;
        }

        

    }
    
}
//--------------------------------------------------------------
void ofApp::update(){	
	//Update sound engine
	ofSoundUpdate();	

	//Get current spectrum with N bands
	float *val = ofSoundGetSpectrum( N );
	//We should not release memory of val,
	//because it is managed by sound engine

	//Update our smoothed spectrum,
	//by slowly decreasing its values and getting maximum with val
	//So we will have slowly falling peaks in spectrum
	for ( int i=0; i<N; i++ ) {
		spectrum[i] *= 0.97;	//Slow decreasing
		spectrum[i] = max( spectrum[i], val[i] );
	}
}
void testApp::update() {
	context.update();
	user.update();
	ofSoundUpdate();
	
	// find the hands via openni
	for (int i = 0; i < user.getTrackedUsers().size(); i++) {
		ofxTrackedUser* tracked = user.getTrackedUser(i);
        
        if (tracked != NULL && tracked->left_lower_arm.found && tracked->right_lower_arm.found) {

            // star the music
            if(!valkyries.getIsPlaying()) {
                valkyries.play();
            }            
            
            
            //cout << "Tracked hands of user: "******"flapPower");
        flappers[i].gravity = panel.getValueF("gravity");
        flappers[i].update();
    }
}
Exemple #22
0
//--------------------------------------------------------------
void ofApp::update(){
    
    kinect.update();
    
    ofSoundUpdate();
    
    if (kinect.isFrameNewDepth()){
        
        // auto-set crop/warp of kinect image to projection size if not done yet
        if (!bWarped && ofGetElapsedTimef() > 10){
            autoSetKinectWarp();
        }
        
        // quad-warp new kinect frame to match projection
        warpKinect();
    }
    
    
     // update each layer with depth image for thresholding
    
    for (int l=0; l<layers.size(); l++){
        layers[l].update(kinectWarp);
    }
    
    playSoundbites(); // plays mixed audio tracks according to time and rate of layer visibility
    
    
    // calibrate depth mode - sets thresholds based on GUI
    
    if (mode == CALIBRATEDEPTH){
        layers[0].setThresholds(topSlider, thresh0Slider);
        layers[1].setThresholds(thresh0Slider, thresh1Slider);
        layers[2].setThresholds(thresh1Slider, thresh2Slider);
        layers[3].setThresholds(thresh2Slider, bottomSlider);
    } 
    
    // kinect image registration/warping mode
    
    if (mode == AUTOKINECT){
        autoSetKinectWarp();
    }
}
//--------------------------------------------------------------
void testApp::update()
{
	step += 0.0001;
	if (step > 1) {
        
		step -= 1;
	}
    
    ofSoundUpdate();
    float * val = ofSoundGetSpectrum(nBandsToGet);		// request 128 values for fft
	for (int i = 0;i < nBandsToGet; i++){
		
		// let the smoothed value sink to zero:
		fftSmoothed[i] *= 0.96f;
		
		// take the max, either the smoothed or the incoming:
		if (fftSmoothed[i] < val[i]) fftSmoothed[i] = val[i];
	}

}
//--------------------------------------------------------------
void testApp::update(){
    
	ofSoundUpdate();
    
    string str = "";
    str += ofToString(sp.getPositionMS()) + ", " + ofToString(ofGetFrameNum()) + ", ";
    float* val = ofSoundGetSpectrum(nBandsToGet);
	for (int i = 0;i < nBandsToGet; i++){
		fftSmoothed[i] *= 0.96f;
		if (fftSmoothed[i] < val[i]) fftSmoothed[i] = val[i];
        str += ofToString(val[i]) + ((i == nBandsToGet - 1) ? "\n" : ", ");
	}
    
    
    file.open(ofToDataPath("soundData.text"), ofFile::Append);
    ofBuffer buff;
    buff = str;
    file.writeFromBuffer(buff);
    file.close();
}
Exemple #25
0
void Ball::update(){
    //Sound -------
    ofSoundUpdate();
    
    float * value = ofSoundGetSpectrum(bands);
    for (int i = 0; i < bands; i++){
        fftSmooth[i] *= 0.9f; //controls how fast dies down
        if (fftSmooth[i] < value[i]) {
            fftSmooth[i] = value[i];
        }
    }
    
    //Movement------
    
    sine = sin(ofGetElapsedTimef() * speed+5) * sinPar;
    cosine = cos(ofGetElapsedTimef() * speed+5) * cosPar;
    sine2 = sin(ofGetElapsedTimef() * speed) * sinPar2;
    cosine2 = cos(ofGetElapsedTimef() * speed) * cosPar2;
    
    
}
//--------------------------------------------------------------
void testApp::update(){

	updateArduino();
    ofSoundUpdate();
    
    int currentTime = ofGetElapsedTimef();
    
    if (currentTime > (timeElasped+cycleTime)) {
        // slow down the random number generator to prevent audio glitching
        randomGurgle = ofRandom(0,NUM_GURGLE);
        randomSound = ofRandom(0,NUM_BREATHE);
        timeElasped = currentTime;
        cout << "Random Sound# " << randomSound << " Random Gurgle #" << randomGurgle << endl;
    }
    // slow down the update of the random gurgle
    
    inhaleExhaleSound[randomSound].setSpeed(breathespeed);
    inhaleExhaleSound[randomSound].setMultiPlay(false);
    inhaleExhaleSound[randomSound].play();
    
}
Exemple #27
0
//--------------------------------------------------------------
void ofApp::update(){
    
    // update the sound playing system:
    ofSoundUpdate();
    
    // (5) grab the fft, and put in into a "smoothed" array,
    //		by taking maximums, as peaks and then smoothing downward
    float * val = ofSoundGetSpectrum(nBandsToGet);		// request 128 values for fft
    for (int i = 0;i < nBandsToGet; i++){
        
        // let the smoothed calue sink to zero
        fftSmoothed[i] *= 0.96f;
        
        // take the max, either the smoothed or the incoming:
        if (fftSmoothed[i] < val[i]) fftSmoothed[i] = val[i];
        
    }
    
   // ws.play();
    
    serialTest = serial.available();
    
    
    if (serialTest) {
        cout << "blahh" << endl;
    }
    
    //@add 2015/10/20 ########################################
    serialString = "";
    serialString = ofxGetSerialString(serial,'\n'); //read until end of line
    if (serialString.length() > 0) {
        readTime = ofGetElapsedTimef();
        ofLogVerbose() << "serialString = " << serialString << "\n";
    }

}
Exemple #28
0
//--------------------------------------------------------------
void AudioPlayer::update(){
	// update the sound playing system:
	ofSoundUpdate();
	// (5) grab the fft, and put in into a "smoothed" array,
	//		by taking maximums, as peaks and then smoothing downward
	float * val = ofSoundGetSpectrum(nBandsToGet);		// request 128 values for fft
	for (int i = 0;i < nBandsToGet; i++){
		
		// let the smoothed calue sink to zero:
		fftSmoothed[i] *= 0.96f;
		
		// take the max, either the smoothed or the incoming:
		if (fftSmoothed[i] < val[i]) fftSmoothed[i] = val[i];
		
	}
  
	updateColor(BG_R_, BG_G_, BG_B_);
	float BG_R = BG_R_;
	float BG_G = BG_G_;
	float BG_B = BG_B_;
	amplifyColor(BG_R, BG_G, BG_B);
  
	ofBackground(BG_R,BG_G,BG_B);
}
//--------------------------------------------------------------
void ofApp::update(){
    
    if (0<time && time <=50) {
        soundFreq =220;
    }
    if (50<time && time <=100) {
        soundFreq =440;
    }
    if (100<time && time <=150) {
        soundFreq =880;
    }
    if (150<time && time <=200) {
        soundFreq =440;
    }
    if (200<time && time <=250) {
        soundFreq =220;
    }
    if (250<time && time <=300) {
        soundFreq =220;
    }
    if (300<time && time <=350) {
        soundFreq =440;
    }
    if (350<time && time <=400) {
        soundFreq =880;
    }
    if (400<time && time <=450) {
        soundFreq =440;
    }
    if (450<time && time <=500) {
        soundFreq =220;
    }
    
    ofSoundUpdate();
    time++;
}
Exemple #30
0
//--------------------------------------------------------------
void testApp::update(){

    ofSoundUpdate();
}