Esempio n. 1
0
void testApp::objectRemoved(ofxTuioObject & tuioObject){
    //マーカー削除
    log = " object removed: " + ofToString(tuioObject.getFiducialId())+
    " X: "+ofToString(tuioObject.getX())+
    " Y: "+ofToString(tuioObject.getY())+
    " angle: "+ofToString(tuioObject.getAngleDegrees());
}
Esempio n. 2
0
void testApp::objectUpdated(ofxTuioObject & tuioObject){
    //マーカーの状態更新
    log = " object updated: " + ofToString(tuioObject.getFiducialId())+
    " X: "+ofToString(tuioObject.getX())+
    " Y: "+ofToString(tuioObject.getY())+
    " angle: "+ofToString(tuioObject.getAngleDegrees());
}
Esempio n. 3
0
void testApp::objectAdded(ofxTuioObject & tuioObject){
    //マーカー追加
    log = " new object: " + ofToString(tuioObject.getFiducialId())+
    " X: "+ofToString(tuioObject.getX())+
    " Y: "+ofToString(tuioObject.getY())+
    " angle: "+ofToString(tuioObject.getAngleDegrees());
}
Esempio n. 4
0
//call when TuioObject is moved
void testApp::objectUpdated(ofxTuioObject & tuioObject) {
    //TODO update objects corresponding to tuioObject's FiducialID
    int i=0,max,*array=getIndex(tuioObject.getFiducialId());
    if(array==NULL)return;
    while(0) {
        if(array[i]==tuioObject.getFiducialId())
            break;
        i++;
    }
    switch(types[tuioObject.getFiducialId()]) {
    case TYPE_IDEA:
        ideas[i].update(&tuioObject);
        break;
    case TYPE_VIDEO:
        videos[i].update(&tuioObject);
        break;
    case TYPE_BGM:
        bgms[i].update(&tuioObject);
        break;
    case TYPE_IMAGE:
        imageobjs[i].update(&tuioObject);
        ofLogWarning()<<"image update";
        break;
    }
    for(line_itr=lines.begin(); line_itr!=lines.end(); line_itr++) {
        (*line_itr).update(&tuioObject);
    }
#ifdef DEBUG
    log="Object Updated: "+ofToString(tuioObject.getFiducialId())+
        " X: "+ofToString(tuioObject.getX())+
        " Y: "+ofToString(tuioObject.getY());
    ofLog()<<log;
#endif
}
Esempio n. 5
0
void testApp::objectRemoved(ofxTuioObject & tuioObject) {
    int i;
    objects.erase(tuioObject.getFiducialId());
    isActive[tuioObject.getFiducialId()]=false;
    if(types[tuioObject.getFiducialId()]==TYPE_BGM) {
        for(i=0; i<BGM_NUM; i++) {
            if(soundIndex[i]==tuioObject.getFiducialId())
                if(sounds[i].getIsPlaying())
                    sounds[i].stop();
        }
    } else if(types[tuioObject.getFiducialId()]==TYPE_VIDEO) {
        for(i=0; i<VIDEO_NUM; i++) {
            if(videoIndex[i]==tuioObject.getFiducialId())
                if(vplayers[i].isPlaying())
                    vplayers[i].closeMovie();
        }
    }
    for(line_itr=lines.begin(); line_itr!=lines.end(); ++line_itr) {
        if((*line_itr).getFromID()==tuioObject.getFiducialId()||
                (*line_itr).getToID()==tuioObject.getFiducialId()) {
            lines.erase(line_itr);
            break;
        }
    }
#ifdef DEBUG
    log="Object Removed: "+ofToString(tuioObject.getFiducialId())+
        " X: "+ofToString(tuioObject.getX())+
        " Y: "+ofToString(tuioObject.getY());
    ofLog()<<log;
#endif
}
Esempio n. 6
0
void testApp::objectUpdated(ofxTuioObject& tuioObject)
{
    log  = " object updated: ";
	log += ofToString(tuioObject.getFiducialId());
	log += " X: " + ofToString(tuioObject.getX());
	log += " Y: " + ofToString(tuioObject.getY());
	log += " angle: " + ofToString(tuioObject.getAngleDegrees());
}
Esempio n. 7
0
void testApp::objectAdded(ofxTuioObject & tuioObject) {
    objects.insert(map<int,ofxTuioObject>::value_type(tuioObject.getFiducialId(),
                   &tuioObject));
    isActive[tuioObject.getFiducialId()]=true;
#ifdef DEBUG
    log="New Object: "+ofToString(tuioObject.getFiducialId())+
        " X: "+ofToString(tuioObject.getX())+
        " Y: "+ofToString(tuioObject.getY());
    ofLog()<<log;
#endif
}
Esempio n. 8
0
// OBJECT ADDED ////////////////////////////////////////////////////////
// ogni volta che una oggetto viene aggiunto sulla superficie di gioco
void testApp::objectAdded(ofxTuioObject & tuioObject)
{	
	int posX; // variabile di appoggio per identificare la posizione relativa del fiducial dentro alla matrice 
	int session_id	= tuioObject.getSessionId();
	int fiducial_id = tuioObject.getFiducialId();
	int piano;
	
	angolo = tuioObject.getAngle() * (-1);			// passo anche il (-1) perchè da reactivision, l'angolo è invertito
	rot_vel = tuioObject.getRotationSpeed() * (-1);	// passo anche il (-1) perchè da reactivision, l'angolo è invertito
	// calcolo la posizione del fiducial per disegnarla graficamente
	pos.x = wQuadro * tuioObject.getX();		// i valori tuioObject.getX() e tuioObject.getY() variano tra 0 e 1
	pos.y = hQuadro * tuioObject.getY();
	

	switch(fiducial_id)
	{
		 
		case KICK:
		{

			posX = tuioObject.getX() * 8; //in che croma siamo?
			piano=1;
			matrice.add_to_table(posX, piano, session_id);
			
			rotondo = new Fid_Round(fiducial_id, session_id);
			rnd_list.push_back(rotondo);
			rnd_list.back()->setup(&pos, &centro, angolo, color_kick);
			rnd_list.back()->added();
			
			break;
		}
		case SNARE:
		{
			
			posX = tuioObject.getX() * 8;
			piano=2;
			matrice.add_to_table(posX, piano, session_id);
			
			quadrato = new Fid_Sqr(fiducial_id, session_id);
			sqr_list.push_back(quadrato);
			sqr_list.back()->setup(&pos, &centro, angolo, color_snare);
			sqr_list.back()->added();
			
			break;
		}
		case HIHAT: 
		{
			posX = tuioObject.getX() * 8;
			piano=3;
			matrice.add_to_table(posX, piano, session_id);
			
			quadrato = new Fid_Sqr(fiducial_id, session_id);
			sqr_list.push_back(quadrato);
			sqr_list.back()->setup(&pos, &centro, angolo, color_hihat);
			sqr_list.back()->added();

			break;
		}
		case BPM: 
		{			
			
			rotativo = new Fid_Rot(fiducial_id, session_id);
			rot_list.push_back(rotativo);
			rot_list.back()->setup(&pos, &centro, angolo, memoria_bpm_angle, color_bpm, color_bpm_corona);
			rot_list.back()->added();
			rot_list.back()->update_interrupt(&pos, &centro, angolo, rot_vel); //commentarlo?
			// aggiorno la mamoria dell'angolo per poterlo riutilizzare la prossima creazione di uno stsso tipo d'oggetto
			memoria_bpm_angle = rot_list.back()->get_lim_angle(); 
			digit.set_bpm(bpm);
			break;

		}
		case BASS:
		{
			core.send_float("bass", 1.0);
			
			
			//posX = tuioObject.getX() * 8; //in che croma siamo?
			//piano=1;
			//matrice.add_to_table(posX, piano, session_id);
			
			basso = new Fid_Bass(fiducial_id, session_id);
			bass_list.push_back(basso);
			bass_list.back()->setup(&pos, &centro, angolo, color_bass);
			bass_list.back()->added();
			
			break;			
		}
		case PADS:
		{
			core.send_float("pads", 1.0);
			
			//posX = tuioObject.getX() * 8;
			//piano=3;
			//matrice.add_to_table(posX, piano, session_id);
			
			pads = new Fid_Synth(fiducial_id, session_id);
			sint_list.push_back(pads);
			sint_list.back()->setup(&pos, &centro, angolo, color_pads);
			sint_list.back()->added();
			
			break;
		}
		case CHORD_0:
		{
			chord_number=0;
			core.send_float("chords", chord_number);
			
			accordo = new Fid_Chords(fiducial_id, session_id);
			chords_list.push_back(accordo);
			chords_list.back()->setup(&pos, &centro, angolo, color_accordo_0);
			chords_list.back()->added();
			chords_list.back()->update_interrupt(&pos, &centro, angolo, rot_vel); //commentarlo?

			
			break;
		}
		case CHORD_1:
		{
			chord_number=1;
			core.send_float("chords", chord_number);
			
			accordo = new Fid_Chords(fiducial_id, session_id);
			chords_list.push_back(accordo);
			chords_list.back()->setup(&pos, &centro, angolo, color_accordo_1);
			chords_list.back()->added();
			chords_list.back()->update_interrupt(&pos, &centro, angolo, rot_vel);
			
			break;
		}
		case CHORD_2:
		{
			chord_number=2;
			core.send_float("chords", chord_number);
			
			accordo = new Fid_Chords(fiducial_id, session_id);
			chords_list.push_back(accordo);
			chords_list.back()->setup(&pos, &centro, angolo, color_accordo_2);
			chords_list.back()->added();
			chords_list.back()->update_interrupt(&pos, &centro, angolo, rot_vel);
			
			break;
		}
		case CHORD_3:
		{
			chord_number=3;
			core.send_float("chords", chord_number);
			
			accordo = new Fid_Chords(fiducial_id, session_id);
			chords_list.push_back(accordo);
			chords_list.back()->setup(&pos, &centro, angolo, color_accordo_3);
			chords_list.back()->added();
			chords_list.back()->update_interrupt(&pos, &centro, angolo, rot_vel);
			
			break;
		}
		case CHORD_4:
		{
			chord_number=4;
			core.send_float("chords", chord_number);
			
			accordo = new Fid_Chords(fiducial_id, session_id);
			chords_list.push_back(accordo);
			chords_list.back()->setup(&pos, &centro, angolo, color_accordo_4);
			chords_list.back()->added();
			chords_list.back()->update_interrupt(&pos, &centro, angolo, rot_vel);
			
			break;
		}
		case CHORD_5:
		{
			chord_number=5;
			core.send_float("chords", chord_number);
			
			accordo = new Fid_Chords(fiducial_id, session_id);
			chords_list.push_back(accordo);
			chords_list.back()->setup(&pos, &centro, angolo, color_accordo_5);
			chords_list.back()->added();
			chords_list.back()->update_interrupt(&pos, &centro, angolo, rot_vel);
			
			break;
		}
		default:
		{
			cout << "Fiducial ID non valido.\n";
			break;
		}
	}
		
}
Esempio n. 9
0
// OBJECT UPDATED //////////////////////////////////////////////////////
// ogni volta che una oggetto viene modificato sulla superficie di gioco
void testApp::objectUpdated(ofxTuioObject & tuioObject)
{	
	int posX;
	int session_id	= tuioObject.getSessionId();
	int fiducial_id	= tuioObject.getFiducialId();
	int piano;

	angolo = tuioObject.getAngle() * (-1);			// passo anche il (-1) perchè da reactivision, l'angolo è invertito
	rot_vel = tuioObject.getRotationSpeed() * (-1);	// passo anche il (-1) perchè da reactivision, l'angolo è invertito
	pos.x = wQuadro * tuioObject.getX();
	pos.y = hQuadro * tuioObject.getY();	
	
	switch(fiducial_id)
	{
		case KICK:
		{
			posX = tuioObject.getX() * 8;
			piano=1;
			matrice.update_table(posX, piano, session_id);
			
			for (list<Fid_Round*>::iterator it=rnd_list.begin(); it !=rnd_list.end(); ++it) 
			{
				if ( (*it)->get_s_id() == session_id) 
				{
					(*it)->update_interrupt(&pos, &centro, angolo, rot_vel);	
					break;
				}
				
			}	
			break;
		}
		case SNARE:
		{
			posX = tuioObject.getX() * 8;
			piano=2;
			matrice.update_table(posX, piano, session_id);
	
			for (list<Fid_Sqr*>::iterator it=sqr_list.begin(); it !=sqr_list.end(); ++it) 
			{
				if ( (*it)->get_s_id() == session_id) 
				{
					(*it)->update_interrupt(&pos, &centro, angolo, rot_vel);	
					break;
				}
				
			}
			break;
		}
		case HIHAT:
		{
			posX = tuioObject.getX() * 8;
			piano=3;
			matrice.update_table(posX, piano, session_id);

			for (list<Fid_Sqr*>::iterator it=sqr_list.begin(); it !=sqr_list.end(); ++it) 
			{
				if ( (*it)->get_s_id() == session_id) 
				{
					(*it)->update_interrupt(&pos, &centro, angolo, rot_vel);	
					break;
				}
			}
			break;
		}
		case BPM:
		{

			for (list<Fid_Rot*>::iterator it=rot_list.begin(); it !=rot_list.end(); ++it) 
			{
				if ( (*it)->get_s_id() == session_id) 
				{
					(*it)->update_interrupt(&pos, &centro, angolo, rot_vel);
					// aggiorno la mamoria dell'angolo per poterlo riutilizzare la porssima creazione di uno stsso tipo d'oggetto
					memoria_bpm_angle = rot_list.back()->get_lim_angle(); 
					
					break;
				}
				
			}
			
			bpm = ofMap(memoria_bpm_angle, -FIDUCIAL_MER, FIDUCIAL_MER, 30, 260, true);
			digit.set_bpm(bpm);
			break;

		}
		case BASS:
		{
			//posX = tuioObject.getX() * 8;
			//piano=1;
			//matrice.update_table(posX, piano, session_id);
			
			for (list<Fid_Bass*>::iterator it=bass_list.begin(); it !=bass_list.end(); ++it) 
			{
				if ( (*it)->get_s_id() == session_id) 
				{
					(*it)->update_interrupt(&pos, &centro, angolo, rot_vel);	
					break;
				}
				
			}	
			break;
		}
		case CHORD_0:
		case CHORD_1:
		case CHORD_2:
		case CHORD_3:
		case CHORD_4:
		case CHORD_5:
		{
			
			for (list<Fid_Chords*>::iterator it=chords_list.begin(); it !=chords_list.end(); ++it) 
			{
				if ( (*it)->get_s_id() == session_id) 
				{
					(*it)->update_interrupt(&pos, &centro, angolo, rot_vel);
					// aggiorno la mamoria dell'angolo per poterlo riutilizzare la porssima creazione di uno stsso tipo d'oggetto
					//memoria_bpm_angle = rot_list.back()->get_lim_angle(); 
					
					break;
				}
				
			}
			
			//bpm = ofMap(memoria_bpm_angle, -FIDUCIAL_MER, FIDUCIAL_MER, 30, 260, true);
			//digit.set_bpm(bpm);
			break;
			
		}
		case PADS:
		{
			//posX = tuioObject.getX() * 8;
			//piano=2;
			//matrice.update_table(posX, piano, session_id);
			
			for (list<Fid_Synth*>::iterator it=sint_list.begin(); it !=sint_list.end(); ++it) 
			{
				if ( (*it)->get_s_id() == session_id) 
				{
					(*it)->update_interrupt(&pos, &centro, angolo, rot_vel);	
					break;
				}
				
			}
			break;
		}
		default:
		{
			cout << "Fiducial ID non valido.\n";
			break;
			
		}
	}
}