Ejemplo n.º 1
0
bool C4MusicFileOgg::Play(bool loop)
{
	// Load Song
	size_t iFileSize;
	if (!C4Group_ReadFile(FileName, &Data, &iFileSize))
		return false;

	// init fsound
	int loop_flag = loop ? FSOUND_LOOP_NORMAL : 0;
	stream = FSOUND_Stream_Open(Data, FSOUND_LOADMEMORY | FSOUND_NORMAL | FSOUND_2D | loop_flag, 0, iFileSize);

	if (!stream) return false;

	// Play Song
	Channel = FSOUND_Stream_Play(FSOUND_FREE, stream);
	if (Channel == -1) return false;

	// Set highest priority
	if (!FSOUND_SetPriority(Channel, 255))
		return false;

	Playing = true;

	FSOUND_Stream_SetEndCallback(stream, &C4MusicFileOgg::OnEnd, this);

	return true;
}
Ejemplo n.º 2
0
void MusicStream::play(double volume) {
    if (! playing && (music != NULL)) {
        channel = FSOUND_Stream_Play(FSOUND_FREE, music);
        FSOUND_SetVolume(channel, min(volume, 1) * 255);
        playing = true;
    }
}
Ejemplo n.º 3
0
int CSound::Startmusic(char *song)
{

	songname = song;
	CurrentSong = FSOUND_Stream_OpenFile(song,FSOUND_LOOP_NORMAL,0);

	
	//if (!CurrentSong)
	//{
		//printf("Error Loading!\n");
		//printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
	//	return 1;
	//}
	FSOUND_Stream_Play(0,CurrentSong);
	SetMusicVolume(MUSIC_VOLUME); // be adam: stream play seems to reset the music volume
//	ret = FMUSIC_PlaySong(CurrentSong);
	
//	if (!ret)
	{
		//printf("Error Playing!\n");
		//printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
//		return 2;
		//printf("Press Any Key.\n");
	}
//	getchar();
	return 0;
}
Ejemplo n.º 4
0
	void LecteurAudio::joueurLectureMorceau()
	{
		// Si aucun fichier audio n'est actuellement ouvert, on quitte la fonction
		if (!fluxAudio)
		{
			qWarning("Demande de lecture alors qu'aucun fichier n'est ouvert (joueurLectureMorceau - LecteurAudio.cpp)");
			return;
		}

		// Si le lecteur etait a l'arret
		if (etatActuel == arret)
		{
			// L'etat passe a Lecture
			etatActuel = lecture;
			// On initialise le canal audio en commencant la lecture
			canalAudio = FSOUND_Stream_Play(FSOUND_FREE, fluxAudio);
			// On se positionne a l'endroit indique par le MJ
			FSOUND_Stream_SetTime(fluxAudio, joueurPositionTemps);
			// On regle le volume
			FSOUND_SetVolume(canalAudio, niveauVolume->value());
		}
		
		// Si le lecteur etait en pause
		else if (etatActuel == pause)
		{
			// L'etat passe a Lecture
			etatActuel = lecture;
			// On reprend la lecture du titre
			FSOUND_SetPaused(canalAudio, false);
		}
		
		// Dans tous les autres cas il s'agit d'une erreur
		else
			qWarning("Demande de lecture d'un titre alors que le lecteur n'est ni en pause, ni a l'arret (joueurLectureMorceau - LecteurAudio.cpp)");
	}
Ejemplo n.º 5
0
bool C4MusicFileMP3::Play(bool loop)
{
#ifndef USE_MP3
	return false;
#endif

	// Load Song
	size_t iFileSize;
	if (!C4Group_ReadFile(FileName, &Data, &iFileSize))
		return false;

	// init fsound
	int loop_flag = loop ? FSOUND_LOOP_NORMAL : 0;
	stream = FSOUND_Stream_Open(Data, FSOUND_LOADMEMORY | FSOUND_NORMAL | FSOUND_2D | loop_flag, 0, iFileSize);

	if (!stream) return false;

	// Play Song
	Channel = FSOUND_Stream_Play(FSOUND_FREE, stream);
	if (Channel == -1) return false;

	// Set highest priority
	if (!FSOUND_SetPriority(Channel, 255))
		return false;

	return true;
}
Ejemplo n.º 6
0
// Lecture des sons. Ils sont lu par streaming c'est à dire qu'ils sont chargés pendant la lecture.
void CSoundManager::Jouer
(
	std::string const & Filename, 
	ECanaux Canal, 
	bool bLoop
)
{
	if (!m_bCanauxJeu && Canal != CANAL_MUSIQUE)
		return;

	if (m_pSon[Canal])
		FSOUND_Stream_Close (m_pSon[Canal]);

	// Si bLoop == true alors le son boucle.
	if (bLoop)
	{
		FSOUND_SetLoopMode (0, FSOUND_LOOP_NORMAL);
		m_pSon[Canal] = FSOUND_Stream_Open((DIRECTORY + Filename).c_str(), FSOUND_LOOP_NORMAL, 0, 0);
		FSOUND_SetVolume (Canal, 64);
		FSOUND_SetVolumeAbsolute (Canal, 64);
	}
	// Sinon il est jouer une seule fois.
	else
	{
		m_pSon[Canal] = FSOUND_Stream_Open((DIRECTORY + Filename).c_str(), FSOUND_NORMAL, 0, 0);
		FSOUND_SetVolume (Canal, 255);
		FSOUND_SetVolumeAbsolute (Canal, 255);
	}

	FSOUND_Stream_Play (Canal, m_pSon[Canal]);
}
Ejemplo n.º 7
0
	void LecteurAudio::appuiLecture(bool etatBouton)
	{
		// Le bouton vient d'etre enfonce
		if (etatBouton)
		{
			// On (re)met en lecture les lecteurs des joueurs
			emettreCommande(lectureMorceau);
			// L'etat passe a Lecture
			etatActuel = lecture;
			// Si le bouton pause etait enfonce il s'agit d'une reprise de pause
			if (actionPause->isChecked())
			{
				// On relache le bouton pause
				actionPause->setChecked(false);
				// On reprend la lecture du titre
				FSOUND_SetPaused(canalAudio, false);
			}

			// Sinon il s'agit d'une premiere lecture
			else
			{
				// On rend inoperant le passage sur un tag : sans cela un tag peut deplacer le curseur de temps entre
				// le lancement de la lecture et le repositionnement dans le temps
				repriseDeLecture = true;
				// On initialise le canal audio en commencant la lecture
				canalAudio = FSOUND_Stream_Play(FSOUND_FREE, fluxAudio);
				// On se positionne a l'endroit choisi par l'utilisateur
				FSOUND_Stream_SetTime(fluxAudio, positionTemps->value());
				// On regle le volume
				FSOUND_SetVolume(canalAudio, niveauVolume->value());
				// Le passage sur un tag est a nouveau operationnel
				repriseDeLecture = false;
			}
		}

		// Le bouton vient d'etre relache
		else
		{
			// Le lecteur etait dans l'etat Lecture
			if (etatActuel == lecture)
			{
				// On met en pause les lecteurs des joueurs
				emettreCommande(pauseMorceau);
				// On met le lecteur en Pause
				etatActuel = pause;
				// On enfonce le bouton pause
				actionPause->setChecked(true);
				// On met la lecture en pause
				FSOUND_SetPaused(canalAudio, true);
			}
			
			// Dans les autres cas il y a un probleme
			else
			{
				qWarning("Le bouton lecture etait enfonce alors que le lecteur n'etait pas en en train de lire (appuiLecture - LecteurAudio.cpp)");
				return;
			}
		}
	}
//count = 0 is infinte
void CAudioManager::PlayStream(int id, int count){
  if(m_bValidAudio == false)
    return;

  for(int i = 0; i < m_Stream.size(); i++){
    if(m_Stream[i].AudioID == id){
      FSOUND_Stream_SetLoopCount(m_Stream[i].handle, count);
      FSOUND_Stream_Play(m_Stream[i].AudioID, m_Stream[i].handle);
    }
  }
}
Ejemplo n.º 9
0
void SoundSystem::playMusic(const FileName &fileName)
{
	stopMusic();

	if(!mute && fileName!=FileName("none") && fileName!=FileName(""))
	{
		musicStream = FSOUND_Stream_Open(fileName.c_str(),
		                                 FSOUND_LOOP_NORMAL,
										 0, 0);
		musicChannel = FSOUND_Stream_Play(FSOUND_FREE, musicStream);
		TRACE("Playing music: " + fileName.str());
	}
}
Ejemplo n.º 10
0
//===========================================================================
// DM_FModExtStartPlaying
//===========================================================================
void DM_FModExtStartPlaying(void)
{
	if(module)
	{
		FMUSIC_SetMasterVolume(module, ext_volume);
		FMUSIC_PlaySong(module);
	}
	if(stream)
	{
		stream_channel = FSOUND_Stream_Play(FSOUND_FREE, stream);
	}
	//  ext_playing = true;
	//  ext_start_time = Sys_GetTime();
}
    /*
     *
     *  void Play(float fadeout, float fadein, Music &oldmusic){
     *   if (!m) return;
     *   FSOUND_Stream_SetEndCallback(m,endcallback,0);
     *   FSOUND_Stream_SetSynchCallback(m, endcallback, 0);
     *   channel = FSOUND_Stream_PlayEx(FSOUND_FREE, m, NULL, 1);
     *   FSOUND_SetPaused(channel, 0);
     *   SetVolume(0);
     *   if (fadeout*100>1) {
     *       for (unsigned int i=0;i<fadeout*100;i++) {
     *           SetVolume(i/(float)fadeout);
     *           oldmusic.SetVolume(((float)fadeout-i)/fadeout);
     *           micro_sleep (10000);
     *       }
     *   }
     *   SetVolume(1);
     *   oldmusic.Stop();
     *  }
     *  void SetVolume(float vol) {
     *   if (m) {
     *       F_API FSOUND_SetVolume(this->channel,(int)(vol*GetMaxVolume()));
     *   }
     *  }
     */
    void Play( float fadeout, float fadein, Music &oldmusic )
    {
        if (!m) return;
        FSOUND_Stream_SetEndCallback( m, endcallback, 0 );
        FSOUND_Stream_SetSynchCallback( m, endcallback, 0 );
        channel = FSOUND_Stream_Play( FSOUND_FREE, m );
        SetVolume( 0 );
        if (fadeout*10 > 1)
            for (unsigned int i = 0; i < fadeout*10; i++) {
                float ratio = ( (float) i )/(fadeout*10.);
                SetVolume( ratio );
                oldmusic.SetVolume( 1-ratio );
                micro_sleep( 10000 );
            }
        oldmusic.Stop();
        oldmusic.Free();

        SetVolume( 1 );
    }
Ejemplo n.º 12
0
void
Ambient::enterState()
{
  if(baseBuffer != NULL && baseSize > 0) {
    base = FSOUND_Stream_Open(static_cast<const char*>(baseBuffer), FSOUND_LOADMEMORY | FSOUND_LOOP_NORMAL, 0, baseSize);
    if(base == NULL) {
      reportFMODError("FSOUND_Stream_Open");
    }
    else {
      baseChannel = FSOUND_Stream_Play(FSOUND_FREE, base);
      if(baseChannel == -1) {
        reportFMODError("FSOUND_Stream_Play");
      }
      else {      
        isActive = true;
        play();
      }
    }
  }  
}
Ejemplo n.º 13
0
void StateLevel::handleEvents()
{
	if ( SDL_PollEvent(&event) )
	{
		if ( event.type == SDL_QUIT ) setNextGameState(0);

		if ( event.type == SDL_KEYUP )
		{
            if ( event.key.keysym.sym == SDLK_ESCAPE ) setNextGameState (2);
            if ( event.key.keysym.sym == SDLK_SPACE && ( (o_player.b_die == true) || (o_player.b_win == true )) ) b_go = true;
            if ( event.key.keysym.sym == SDLK_r ) b_restart = true;
		}
            if ( o_player.b_die == false && o_player.b_win == false ) o_player.handleEvents();

        if ( event.type == SDL_KEYUP && event.key.keysym.sym == SDLK_m )
		{
		    if ( b_music == true )
		    {
		        FSOUND_Stream_Stop(song2);

		        b_music = false;
		    }

		    else if ( b_music == false )
		    {
		        FSOUND_Stream_Play( 1, song2 );
                FSOUND_Stream_SetLoopCount(song2,-1);

                b_music = true;

		    }

		}




	}

}
Ejemplo n.º 14
0
Status Target::Response()
{    
    glEnable(GL_TEXTURE_2D);
	glBindTexture(GL_TEXTURE_2D, _targetTex);
    
    //camera spot light
    GLfloat white_light[] = {1.0, 1.0, 1.0, 1.0};
    GLfloat uplightpoz[] = {0, 20, 0, 1};
    GLfloat uplightdir[]={0, -1, 0};
    
    glLightfv(GL_LIGHT2, GL_DIFFUSE, white_light);
    glLightfv(GL_LIGHT2, GL_SPOT_DIRECTION, uplightdir);
    glLightf(GL_LIGHT2, GL_SPOT_CUTOFF, 60);
    glLightf(GL_LIGHT2, GL_SPOT_EXPONENT, 50);
    
    glLightfv(GL_LIGHT3, GL_DIFFUSE, white_light);
    glLightfv(GL_LIGHT3, GL_SPOT_DIRECTION, uplightdir);
    glLightf(GL_LIGHT3, GL_SPOT_CUTOFF, 60);
    glLightf(GL_LIGHT3, GL_SPOT_EXPONENT, 50);
    
    glLightfv(GL_LIGHT4, GL_DIFFUSE, white_light);
    glLightfv(GL_LIGHT4, GL_SPOT_DIRECTION, uplightdir);
    glLightf(GL_LIGHT4, GL_SPOT_CUTOFF, 60);
    glLightf(GL_LIGHT4, GL_SPOT_EXPONENT, 50);
    
    glLightfv(GL_LIGHT5, GL_DIFFUSE, white_light);
    glLightfv(GL_LIGHT5, GL_SPOT_DIRECTION, uplightdir);
    glLightf(GL_LIGHT5, GL_SPOT_CUTOFF, 60);
    glLightf(GL_LIGHT5, GL_SPOT_EXPONENT, 50);
    
    glLightfv(GL_LIGHT6, GL_DIFFUSE, white_light);
    glLightfv(GL_LIGHT6, GL_SPOT_DIRECTION, uplightdir);
    glLightf(GL_LIGHT6, GL_SPOT_CUTOFF, 60);
    glLightf(GL_LIGHT6, GL_SPOT_EXPONENT, 50);
    
    glLightfv(GL_LIGHT7, GL_DIFFUSE, white_light);
    glLightfv(GL_LIGHT7, GL_SPOT_DIRECTION, uplightdir);
    glLightf(GL_LIGHT7, GL_SPOT_CUTOFF, 60);
    glLightf(GL_LIGHT7, GL_SPOT_EXPONENT, 50);
    

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    
    glPushMatrix();
    glTranslatef(targetPoz1.x, 0, targetPoz1.z);
    glLightfv(GL_LIGHT2, GL_POSITION,uplightpoz);
    if (flag1 == 1)
    {
        glDisable(GL_LIGHT2);
        glTranslatef(0, -1.6, 0);
        glRotatef(90, 1, 0, 0);
    }
	else if (collision(BulletPoz)==1) 
    {
        glTranslatef(0, -1.6, 0);
        glRotatef(90, 1, 0, 0);
		//if hit the target, play clap sound
		hitTarget = FSOUND_Stream_Open( "Resources\\Sound\\hitTarget.wav" , FSOUND_2D , 0 , 0 );
		FSOUND_Stream_Play(0,hitTarget);
        flag1 = 1;
    }
    glCallList(targetList);
    glPopMatrix();
    
    glPushMatrix();
    glTranslatef(targetPoz2.x, 0, targetPoz2.z);
    glLightfv(GL_LIGHT3, GL_POSITION,uplightpoz);
    if (flag2 == 1)
    {
        glDisable(GL_LIGHT3);
        glTranslatef(0, -1.6, 0);
        glRotatef(90, 1, 0, 0);
    }
    else if (collision(BulletPoz)==2) 
    {
        glTranslatef(0, -1.6, 0);
        glRotatef(90, 1, 0, 0);
		//if hit the target, play clap sound
		hitTarget = FSOUND_Stream_Open( "Resources\\Sound\\hitTarget.wav" , FSOUND_2D , 0 , 0 );
		FSOUND_Stream_Play(0,hitTarget);
        flag2 = 1;
    }
    glCallList(targetList);    
    glPopMatrix();
    
    glPushMatrix();
    glTranslatef(targetPoz3.x, 0, targetPoz3.z);
    glLightfv(GL_LIGHT4, GL_POSITION,uplightpoz);
    if (flag3 == 1)
    {
        glDisable(GL_LIGHT4);
        glTranslatef(0, -1.6, 0);
        glRotatef(90, 1, 0, 0);
    }
    else if (collision(BulletPoz)==3) 
    {
        glTranslatef(0, -1.6, 0);
        glRotatef(90, 1, 0, 0);
		//if hit the target, play clap sound
		hitTarget = FSOUND_Stream_Open( "Resources\\Sound\\hitTarget.wav" , FSOUND_2D , 0 , 0 );
		FSOUND_Stream_Play(0,hitTarget);
        flag3 = 1;
    }
    glCallList(targetList);    
    glPopMatrix();
    
    glPushMatrix();
    glTranslatef(targetPoz4.x, 0, targetPoz4.z);
    glLightfv(GL_LIGHT5, GL_POSITION,uplightpoz);
    if (flag4 == 1)
    {
        glDisable(GL_LIGHT5);
        glTranslatef(0, -1.6, 0);
        glRotatef(90, 1, 0, 0);
    }
    else if (collision(BulletPoz)==4) 
    {
        glTranslatef(0, -1.6, 0);
        glRotatef(90, 1, 0, 0);
		//if hit the target, play clap sound
		hitTarget = FSOUND_Stream_Open( "Resources\\Sound\\hitTarget.wav" , FSOUND_2D , 0 , 0 );
		FSOUND_Stream_Play(0,hitTarget);
        flag4 = 1;
    }
    glCallList(targetList);    
    glPopMatrix();
    
    glPushMatrix();
    glTranslatef(targetPoz5.x, 0, targetPoz5.z);
    glLightfv(GL_LIGHT6, GL_POSITION,uplightpoz);
    if (flag5 == 1)
    {
        glDisable(GL_LIGHT6);
        glTranslatef(0, -1.6, 0);
        glRotatef(90, 1, 0, 0);
    }
    else if (collision(BulletPoz)==5) 
    {
        glTranslatef(0, -1.6, 0);
        glRotatef(90, 1, 0, 0);
		//if hit the target, play clap sound
		hitTarget = FSOUND_Stream_Open( "Resources\\Sound\\hitTarget.wav" , FSOUND_2D , 0 , 0 );
		FSOUND_Stream_Play(0,hitTarget);
        flag5 = 1;
    }
    glCallList(targetList);    
    glPopMatrix();
    
    glPushMatrix();
    glTranslatef(targetPoz6.x, 0, targetPoz6.z);
    glLightfv(GL_LIGHT7, GL_POSITION,uplightpoz);
    if (flag6 == 1)
    {
        glDisable(GL_LIGHT7);
        glTranslatef(0, -1.6, 0);
        glRotatef(90, 1, 0, 0);
    }
    else if (collision(BulletPoz)==6) 
    {
        glTranslatef(0, -1.6, 0);
        glRotatef(90, 1, 0, 0);
		//if hit the target, play clap sound
		hitTarget = FSOUND_Stream_Open( "Resources\\Sound\\hitTarget.wav" , FSOUND_2D , 0 , 0 );
		FSOUND_Stream_Play(0,hitTarget);
        flag6 = 1;
    }
    glCallList(targetList);    
    glPopMatrix();
    
    glDisable(GL_TEXTURE_2D);

	if (flag1==1&&flag2==1&&flag3==1&&flag4==1&&flag5==1&&flag6==1)
	{
		return WIN;
	}
    
}
Ejemplo n.º 15
0
static void DrawCube(void)
{
	if (guss == 99){

	}
	else if (gCharacter[0].patt_found){
	

		glPushMatrix();
		//Applying // coordinate transformation matrix
		arglCameraViewRH(gCharacter[0].trans, m, gViewScaleFactor);
		glLoadMatrixd(m);

		glPushMatrix();
		glScalef(7.8, 4.8, 4.8);

		//glTranslated(3, 0, -30);
		//glRotated(90, 1, 0, 0);
		//sky();
		//glTranslated(-3, 0, 20);
		//glScalef(xx, yy, z);
		//drawElephant2();
		if (wire){
			OnDraw();
		}
else
		OnDraw1();
		glPopMatrix();

		glPopMatrix();
		if (skyflag){
			
			
		}
		

	//FSOUND_Stream_Play(0, g_mp3_stream1);
		//PlaySound(data1, NULL, SND_ASYNC | SND_NOSTOP );*/
	}
	else if (gCharacter[4].patt_found){


		glPushMatrix();
		//Applying // coordinate transformation matrix
		arglCameraViewRH(gCharacter[4].trans, m, gViewScaleFactor);
		glLoadMatrixd(m);

		glPushMatrix();
		
		//sky();
		glTranslated(-3, 0, 20);
	    glScalef(xx, yy, z);
		//drawElephant2();
	

		FSOUND_Stream_Play(0, g_mp3_stream1);
		//PlaySound(data1, NULL, SND_ASYNC | SND_NOSTOP );*/
	}
	
	else if(gCharacter[1].patt_found){

		glPushMatrix();
		
		arglCameraViewRH(gCharacter[1].trans, m, gViewScaleFactor);
		glLoadMatrixd(m);

		glPushMatrix();
		glLightModelfv(GL_LIGHT_MODEL_AMBIENT, LIGHT_MODEL_AMBIENT);
		glEnable(GL_LIGHTING);
		//gluPerspective(60.0, ASPECT_RATIO, 0.2, 100.0);
		gluLookAt(LOOK_AT_POSITION[0] + ViewerDistance * sin(viewerZenith) * sin(viewerAzimuth),
			LOOK_AT_POSITION[1] + ViewerDistance * cos(viewerZenith),
			LOOK_AT_POSITION[2] + ViewerDistance * sin(viewerZenith) * cos(viewerAzimuth),
			LOOK_AT_POSITION[0], LOOK_AT_POSITION[1], LOOK_AT_POSITION[2],
			0.0, 1.0, 0.20);
		glScalef(xx, yy, z);
		glShadeModel(GL_SMOOTH);
		glEnable(GL_DEPTH_TEST);
		glDepthFunc(GL_LEQUAL);
		glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);	
		glEnable(GL_NORMALIZE);
		glCullFace(GL_BACK);
		glEnable(GL_CULL_FACE);

		glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

		FSOUND_Stream_Play(0, g_mp3_stream2);
		
	
		glRotated(90, 1, 0, 0);
		glScaled(2, 2, 2);
		UpdateLight();
		drawEarthAndMoon();
	
		
		
		drawAllPlanets();
		drawSaturnRing();
		drawSun();
		


		if (blendFlag){ 
			glEnable(GL_BLEND);
		glDepthMask(GL_FALSE);
			glBlendFunc(GL_SRC_COLOR, GL_ONE);
		}

		if (particleFlag)
		drawAllParticles();
		
		



		glDepthMask(GL_TRUE);
		glDisable(GL_BLEND);
		glDisable(GL_LIGHTING);
		
		//drawElephant();
	
		
	
	
		//glTranslated(0, 0, -2);


		glPopMatrix();
		
		glPopMatrix();
		//OnDraw2();
	
	}
	else if (gCharacter[3].patt_found)
	{
		glPushMatrix();
	
		arglCameraViewRH(gCharacter[3].trans, m, gViewScaleFactor);
		glLoadMatrixd(m);

		glPushMatrix();

		glLightModelfv(GL_LIGHT_MODEL_AMBIENT, LIGHT_MODEL_AMBIENT);
		glEnable(GL_LIGHTING);
		//gluPerspective(60.0, ASPECT_RATIO, 0.2, 100.0);
		gluLookAt(LOOK_AT_POSITION[0] + ViewerDistance * sin(viewerZenith) * sin(viewerAzimuth),
			LOOK_AT_POSITION[1] + ViewerDistance * cos(viewerZenith),
			LOOK_AT_POSITION[2] + ViewerDistance * sin(viewerZenith) * cos(viewerAzimuth),
			LOOK_AT_POSITION[0], LOOK_AT_POSITION[1], LOOK_AT_POSITION[2],
			0.0, 1.0, 0.020);
		glShadeModel(GL_SMOOTH);
		glEnable(GL_DEPTH_TEST);
		glDepthFunc(GL_LEQUAL);
		glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
		glEnable(GL_NORMALIZE);
		glCullFace(GL_BACK);
	glEnable(GL_CULL_FACE);

		glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

		glTranslated(0, 0, 0);
		glScalef(xx, yy, z);
		UpdateLight();
		glRotated(90, 1, 0, 0);
		drawOne();







		glDepthMask(GL_TRUE);
		glDisable(GL_BLEND);
		glDisable(GL_LIGHTING);
		guss1 = 1;
		glPopMatrix();
		glPopMatrix();
	}
	/* if (gCharacter[4].patt_found){

		glPushMatrix();
	
		arglCameraViewRH(gCharacter[4].trans, m, gViewScaleFactor);
		glLoadMatrixd(m);

		glPushMatrix();


		glScaled(xx, yy, z);
		glColor3d(1, 1, 1);
		glBegin(GL_QUADS);

		glVertex2f(-3, 3);


		glVertex2f(-3, -3);


		glVertex2f(3, -3);


		glVertex2f(3, 3);
		glEnd();
		glPopMatrix();
		glPushMatrix();
		glTranslated(0, 0, 2);
		glScaled(25, 25, 25);
		glBegin(GL_TRIANGLES);

		glColor3f(0.0f, 0.0f, 0.0f);
		glVertex3f(0.0f, 1.0f, 0.0f);

		glVertex3f(-1.0f, -1.0f, 0.0f);

		glVertex3f(1.0f, -1.0f, 0.0f);
		glEnd();
		glPopMatrix();
		glPopMatrix();
		//printf("found");
	}
	 if (gCharacter[5].patt_found){

		glPushMatrix();
	
		arglCameraViewRH(gCharacter[5].trans, m, gViewScaleFactor);
		glLoadMatrixd(m);

		glPushMatrix();


		glScaled(xx, yy, z);
		glColor3d(1, 1, 1);
		glBegin(GL_QUADS);

		glVertex2f(-3, 3);


		glVertex2f(-3, -3);


		glVertex2f(3, -3);


		glVertex2f(3, 3);
		glEnd();
		glPopMatrix();
		glPushMatrix();
		glTranslated(0, 0, 2);
		glScaled(25, 25, 25);
		glBegin(GL_TRIANGLES);

		glColor3f(0.0f, 0.0f, 0.0f);
		glVertex3f(0.0f, 1.0f, 0.0f);

		glVertex3f(-1.0f, -1.0f, 0.0f);

		glVertex3f(1.0f, -1.0f, 0.0f);
		glEnd();
		glPopMatrix();
		glPopMatrix();
		//printf("found");
	
	}*/else
	 if (gCharacter[5].patt_found){
		 glPushMatrix();

		 arglCameraViewRH(gCharacter[6].trans, m, gViewScaleFactor);
		 glLoadMatrixd(m);

		 glPushMatrix();
		 glScalef(13, 13, 13);
		 glColor3f(1, 1, 1);
		 glTranslated(-10, 0, 0);
		 cube();
		 FSOUND_Stream_Play(0, g_mp3_stream16);
		 glPopMatrix();

		 glPopMatrix();
	 }
		/* if (gCharacter[7].patt_found){
			 glPushMatrix();

			 arglCameraViewRH(gCharacter[7].trans, m, gViewScaleFactor);
			 glLoadMatrixd(m);

			 glPushMatrix();


			 glScaled(xx, yy, z);
			 glColor3d(1, 1, 1);
			 glBegin(GL_QUADS);

			 glVertex2f(-3, 3);


			 glVertex2f(-3, -3);


			 glVertex2f(3, -3);


			 glVertex2f(3, 3);
			 glEnd();
			 glPopMatrix();
			 if (pause){
				 glPushMatrix();
				 glTranslated(0, 0, 2);
				 glScaled(25, 25, 25);
				 glBegin(GL_TRIANGLES);

				 glColor3f(0.0f, 0.0f, 0.0f);
				 glVertex3f(0.0f, 1.0f, 0.0f);

				 glVertex3f(-1.0f, -1.0f, 0.0f);

				 glVertex3f(1.0f, -1.0f, 0.0f);
				 glEnd();
				 glPopMatrix();
			 }
			 else
			 if (!pause){
				 glPushMatrix();
				 glScaled(8, 8, 8);
				 glTranslated(0, -1
					 , 3);
				 glRotated(90, 0, 0, 1);
				 glColor3d(0, 1, 1);
				 glBegin(GL_QUADS);

				 glVertex2f(-0.6, 3);


				 glVertex2f(-0.6, -3);


				 glVertex2f(0.6, -3);


				 glVertex2f(0.6, 3);
				 glEnd();
				 glPopMatrix();
				 glPushMatrix();
				 glScaled(8, 8, 8);
				 glTranslated(0, 1
					 , 3);
				 glRotated(90, 0, 0, 1);
				 glColor3d(0, 1, 1);
				 glBegin(GL_QUADS);

				 glVertex2f(-0.6, 3);


				 glVertex2f(-0.6, -3);


				 glVertex2f(0.6, -3);


				 glVertex2f(0.6, 3);
				 glEnd();
				 glPopMatrix();

			 }

			 glPopMatrix();
		 }*/
	 





}
Ejemplo n.º 16
0
void StateMenu::handleEvents()
{
	if ( SDL_PollEvent(&event) )
	{

		if ( event.type == SDL_QUIT )
		{
			setNextGameState(0);
		}

		if ( event.type == SDL_KEYUP && event.key.keysym.sym == SDLK_m )
		{
		    if ( b_music == true )
		    {
		        FSOUND_Stream_Stop(song2);

		        b_music = false;
		    }

		    else if ( b_music == false )
		    {
		        FSOUND_Stream_Play( 1, song2 );
                FSOUND_Stream_SetLoopCount(song2,-1);

                b_music = true;

		    }

		}

		if ( event.type == SDL_MOUSEBUTTONUP )
		{
			if ( event.button.button == SDL_BUTTON_LEFT )
			{
				int x,y;
				SDL_GetMouseState(&x,&y);

				Box mouse;
				mouse.x = (float)x;
				mouse.y = (float)y;
				mouse.w = 1;
				mouse.h = 1;

				if ( checkCollisionQuads( mouse, play ) )
				{
					setNextGameState(8);
				}

				else if ( checkCollisionQuads( mouse, select ) )
				{
					setNextGameState(5);
				}

				else if ( checkCollisionQuads( mouse, editor ) )
				{
					setNextGameState(4);
				}

				else if ( checkCollisionQuads( mouse, exit ) )
				{
					setNextGameState(0);
				}
			}
		}

	}

}
Ejemplo n.º 17
0
	void LecteurAudio::finDeTitreSlot()
	{
		// Si la lecture en boucle est activee
		if (enBoucle)
		{
			// On arrete les lecteurs des joueurs
			emettreCommande(arretMorceau);
			// On remet en lecture les lecteurs des joueurs
			emettreCommande(lectureMorceau);
			// On initialise le canal audio en commencant la lecture
			canalAudio = FSOUND_Stream_Play(FSOUND_FREE, fluxAudio);
			// On regle le volume
			FSOUND_SetVolume(canalAudio, niveauVolume->value());
			// On remet la barre de temps au depart
			positionTemps->setValue(0);
			positionTemps->update();
			// On met l'afficheur de temps a 0
			afficheurTemps->display("0:00");
		}

		// Si la lecture unique est activee
		else if (lectureUnique)
		{
			// On arrete les lecteurs des joueurs
			emettreCommande(arretMorceau);
			// On arrete le lecteur local
			arreter();
		}

		// Sinon on passe au titre suivant
		else
		{
			// Il existe un titre suivant
			if (titreCourant < listeChemins.size()-1)
			{
				// On passe au titre suivant
				titreCourant++;
				// On envoie le nouveau titre aux lecteurs des joueurs
				emettreCommande(nouveauMorceau, listeTitres->item(titreCourant)->text());
				// On demande aux lecteurs des joueurs de commencer a le lire
				emettreCommande(lectureMorceau);
				// Changement de titre en cours
				nouveauTitre(listeTitres->item(titreCourant)->text(), listeChemins[titreCourant]);
				// On met le lecteur en lecture
				etatActuel = lecture;
				// On initialise le canal audio en commencant la lecture
				canalAudio = FSOUND_Stream_Play(FSOUND_FREE, fluxAudio);
				// On regle le volume
				FSOUND_SetVolume(canalAudio, niveauVolume->value());
				// On enfonce le bouton Lecture
				actionLecture->setChecked(true);
			}
			
			// Il n'existe pas de titre suivant : on arrete le lecteur
			else
			{
				// On emet une demande d'arret aux autres utilisateurs
				emettreCommande(arretMorceau);
				// On arrete le lecteur
				arreter();
			}
		}
	}
Ejemplo n.º 18
0
int main ( int argc, char* args[] )
{
	init();

	srand(time(NULL));

	int FPS = 0;

	///////GLOBAL LOADING
	tex_spikes = loadTexture("data/gfx/Spikes.png");
	tex_block1 = loadTexture("data/gfx/block1.png");
	tex_menu = loadTexture("data/gfx/menu.png");
	tex_playgame = loadTexture("data/gfx/playgame.png");
	tex_selectlevel = loadTexture("data/gfx/selectlevel.png");
	tex_editor = loadTexture("data/gfx/editor.png");
	tex_exit = loadTexture("data/gfx/exitmenu.png");
	tex_player1 = loadTexture("data/gfx/player.png");
	tex_door = loadTexture("data/gfx/door.png");
	tex_font = loadTexture("data/gfx/font.png");
	tex_done = loadTexture("data/gfx/ok.png");
	tex_gold = loadTexture("data/gfx/gold.png");
	tex_silver = loadTexture("data/gfx/silver.png");
	tex_bronze = loadTexture("data/gfx/bronze.png");
	tex_eyes = loadTexture("data/gfx/playgame.png");
	tex_arrow = loadTexture("data/gfx/arrow.png");
	tex_info = loadTexture("data/gfx/info.png");


	///////soundsss
	sample_playerJump = FSOUND_Sample_Load(FSOUND_UNMANAGED,"data/sfx/jump.wav",0,0,0);
	FSOUND_Sample_SetDefaults(sample_playerJump, -1,100,-1,-1);
	sample_playerHit = FSOUND_Sample_Load(FSOUND_UNMANAGED,"data/sfx/hit.wav",0,0,0);
	FSOUND_Sample_SetDefaults(sample_playerHit, -1,100,-1,-1);
	sample_playerForce = FSOUND_Sample_Load(FSOUND_UNMANAGED,"data/sfx/force.wav",0,0,0);
	FSOUND_Sample_SetDefaults(sample_playerForce, -1,100,-1,-1);

	song2 = FSOUND_Stream_Open( "data/music/Random-SitgesSavepoint.mp3",FSOUND_LOOP_NORMAL,0,0);

	FSOUND_Stream_Play( 1, song2 );
	FSOUND_Stream_SetLoopCount(song2,-1);

	//FSOUND_SetVolume(1,80);

	std::ifstream file ("data/levels/score.lvl");

	while ( !file.eof() )
	{
		o_scores.push_back(new Score());

		file >> o_scores.back()->i_number;
		file >> o_scores.back()->b_unlocked;
		file >> o_scores.back()->i_highScore;
		file >> o_scores.back()->i_B;
		file >> o_scores.back()->i_S;
		file >> o_scores.back()->i_G;

	}

	file.close();

	//o_scores.pop_back();


	gameState = new StateMenu();
	currentGameState = STATE_MENU;



/*
	for ( int n = 0; n < 100; n++ )
	{
		o_scores.push_back( new Score () );
		o_scores.back()->b_unlocked = true;
		o_scores.back()->i_highScore = 0;
		o_scores.back()->i_B = 0;
		o_scores.back()->i_G = 0;
		o_scores.back()->i_S = 0;
	}*/

	//saving

	FPSA = SDL_GetTicks();

	while ( nextGameState != STATE_EXIT )
	{

		FPS = SDL_GetTicks();

		gameState->handleEvents();

		gameState->logic();

		FPSA = SDL_GetTicks();

		gameState->render();

		changeGameState();



		////////////////////////////
		if ( (SDL_GetTicks() - FPS) < 1000/60 )
		{
			//SDL_Delay( ( 1000/60) - (SDL_GetTicks() - FPS) );
		}
		SDL_Delay(2);

	}

    FSOUND_Stream_Close(song2);
	FSOUND_Close();

	return 0;
}
Ejemplo n.º 19
0
bool CMenu::load(TiXmlNode* t_nodePtr)
{
   TiXmlNode*     a_nodePtr      = 0;
   TiXmlNode*     a_subNodePtr   = 0;
   TiXmlElement*  a_elemPtr      = 0;
   CMenuItem*     a_menuItemPtr  = 0;

   std::string    a_key          = "";
   std::string    a_str          = "";

   bool           r_ret          = true;
   
   FSOUND_STREAM* a_sound        = 0;


   //////////////////////////////////////////////////////////////////////////
   // clear old menu
   clear();

   //////////////////////////////////////////////////////////////////////////
   // Start to play level music

   a_elemPtr = t_nodePtr->ToElement();
   getAttributeStr(a_elemPtr, "music", a_str);
   a_str = SOUND_BASE + a_str;
   a_sound = FSOUND_Stream_Open(a_str.c_str(), FSOUND_LOOP_NORMAL, 0, 0);
   
   if (a_sound  && !g_mute)
   {
      FSOUND_Stream_Play(0, a_sound);
   }

   //////////////////////////////////////////////////////////////////////////
   // load textures for menu
   a_nodePtr = t_nodePtr->FirstChild("texturelist");

   for(a_subNodePtr = a_nodePtr->FirstChild("texture"); a_subNodePtr; a_subNodePtr = a_nodePtr->IterateChildren("texture", a_subNodePtr))
   {
      a_elemPtr = a_subNodePtr->ToElement();

      if(!getAttributeStr(a_elemPtr, "key", a_key))
      {
         r_ret = false;
      }
 
      if(r_ret)
      {
         if(m_textureMap[a_key] == 0)
         {
            m_textureMap[a_key] = new CTexture(a_elemPtr, GFX_BASE);
         }
      }
   }

   //////////////////////////////////////////////////////////////////////////
   // load menu items
   for(a_nodePtr = t_nodePtr->FirstChild("menuitem"); a_nodePtr; a_nodePtr = t_nodePtr->IterateChildren("menuitem", a_nodePtr))
   {
      a_menuItemPtr = new CMenuItem(this);
      r_ret &= a_menuItemPtr->load(a_nodePtr);
      m_menuItems.push_back(a_menuItemPtr);
   }

   return r_ret;
}
Ejemplo n.º 20
0
void Title::HandleEvents(GameEngine* game)
{
     /*la majorité du code de l'écran titre se trouve ici (mise à jour des images inclue)
     étant donné le fonctionnement de l'écran titre

     la méthode de gestion des évènements de l'exploration peut également s'appliquer, mais il faut
     penser à inclure des variables static de fonction et "simuler" la répétition des touches
     après un certain temps appuyé sur une des deux touches (haut/bas)

     Ce type de code devra être simulé lors des combats si la jauge ATB reste active
     pendant la gestion des commandes*/

     SDL_EnableKeyRepeat(400, 100);
     int tempsPrecedent = 0, tempsActuel = 0;
     FSOUND_Stream_Play(FSOUND_FREE, musique1);
     SDL_BlitSurface(image1,NULL,SDL_GetVideoSurface(),NULL);
     SDL_BlitSurface(image2,NULL,SDL_GetVideoSurface(),&image02);
     SDL_UpdateRect(game->screen, 0, 0, 0, 0);

     //SDL_EventState(SDL_KEYDOWN, SDL_IGNORE); //Désactive et annule les anciens évènements
     SDL_EventState(SDL_KEYDOWN, SDL_ENABLE); // Réactive les évènements

     while ( quit==false  && positionCurseur != 0 )

     {

           //Tant qu'il y a un événement
           while( SDL_WaitEvent( &game->event ) ) //////ON ATTEND QU'UN EVENEMENT SE DECLBNCHE POUR EXECUTER LES ACTIONS EN DESSOUS
           {
                  switch (game->event.type)
                  {
                         //A retirer lorsque phase de test terminée
                         case SDL_QUIT: //Si l'utilisateur a cliqué sur le X de la fenêtre

                                            //On quitte the programme
                                             quit = true;



                                            break;
                         case SDL_KEYDOWN:
                              switch (game->event.key.keysym.sym)
                              {
                                     case SDLK_DOWN:
                                           FSOUND_PlaySound(FSOUND_FREE, sonCurseurDeplacement);
                                           positionCurseur++;
                                           if ( positionCurseur > 2 )
                                           {
                                                positionCurseur = 1;
                                           }
                                           SDL_Delay(10);
                                           break;

                                     case SDLK_UP:
                                           FSOUND_PlaySound(FSOUND_FREE, sonCurseurDeplacement);
                                           positionCurseur--;
                                           if ( positionCurseur < 1 )
                                           {
                                                positionCurseur = 2;
                                           }
                                           break;
                                     case SDLK_RETURN:
                                          FSOUND_PlaySound(FSOUND_FREE, sonCurseurValider);
                                          FSOUND_Stream_Stop(musique1);
                                          positionCurseur = 0;
                                          break;
                                    default:;

                              }


                  }

                  if (positionCurseur == 0 && quit==false )
                  {
                                 for (int i = 0 ; i <= 255 ; i+=24) // transition noir
                                 {
                                 alpha = i;
                                 SDL_SetAlpha(fondu, SDL_SRCALPHA, alpha);
                                 SDL_BlitSurface(image1,NULL,SDL_GetVideoSurface(),NULL);
                                 SDL_BlitSurface(image2,NULL,SDL_GetVideoSurface(),&image02);
                                 SDL_BlitSurface(fondu, NULL, SDL_GetVideoSurface(), NULL);

                                 SDL_UpdateRect(game->screen, 0, 0, 0, 0);

                                 tempsPrecedent = tempsActuel;

                                 while( tempsActuel - tempsPrecedent < 1000 / FRAMES_PER_SECOND )
                                 {
                                  tempsActuel = SDL_GetTicks();
                                 }

                                  }

                                 alpha = 255;
                                 SDL_SetAlpha(fondu, SDL_SRCALPHA, alpha);
                                 SDL_BlitSurface(fondu, NULL, SDL_GetVideoSurface(), NULL);
                                 SDL_UpdateRect(game->screen, 0, 0, 0, 0);
                                 break;

                  }

                  if ( positionCurseur == 1 && quit==false )
                  {
                  image02.x = 300;
                  image02.y = 515;
                  }
                  if ( positionCurseur == 2 && quit==false)
                  {
                  image02.x = 300;
                  image02.y = 539;
                  }
                  if ( positionCurseur != 0 && quit==false)
                  {
                  SDL_BlitSurface(image1,NULL,SDL_GetVideoSurface(),NULL);
                  SDL_BlitSurface(image2,NULL,SDL_GetVideoSurface(),&image02);
                  SDL_UpdateRect(game->screen, 0, 0, 0, 0);
                  }
                  break;
           }


     }
     game->Quit();



}
Ejemplo n.º 21
0
/**	Plays the stream
 *
 *	@returns	The channel id that the stream is playing on
 */
int FMODStreamBuffer::Play(void)
{
	//	Play the buffer, return the channel playing on
	m_channel = FSOUND_Stream_Play(FSOUND_FREE,m_stream);
	return m_channel;
}
Ejemplo n.º 22
0
	bool setupAudio()
	{
		int ret;


		//read audio stream info; specifically, we need the encoded chunksize
		AVISTREAMINFO audioStreamInfo;
		AVIStreamInfo(audioStream,&audioStreamInfo,sizeof(AVISTREAMINFO));
		audioChunkSize = audioStreamInfo.dwSuggestedBufferSize;
		audioSampleCount = audioStreamInfo.dwLength;

		audioEncoded = new char[audioChunkSize];

		//read the audio streamformat info
		LONG formatSize;
		AVIStreamReadFormat(audioStream,AVIStreamStart(audioStream),0,&formatSize);
		char *format = (char *)malloc(formatSize);
		AVIStreamReadFormat(audioStream,AVIStreamStart(audioStream),format,&formatSize);
		WAVEFORMATEX *wfxEncoded = (WAVEFORMATEX *)format;

		//construct a descriptor for the format we desire to get out of the decoder
		//note that we have to use the same samplerate as the encoded format indicates
		//since acm can't change the samplerate in one fell swoop
		wfxDecoded.cbSize = sizeof(WAVEFORMATEX);
		wfxDecoded.nChannels = wfxEncoded->nChannels;
		wfxDecoded.wFormatTag = WAVE_FORMAT_PCM;
		wfxDecoded.nSamplesPerSec = wfxEncoded->nSamplesPerSec;
		wfxDecoded.wBitsPerSample = 16;
		wfxDecoded.nBlockAlign = wfxDecoded.wBitsPerSample/8 * wfxEncoded->nChannels;
		wfxDecoded.nAvgBytesPerSec = wfxDecoded.nBlockAlign * wfxDecoded.nSamplesPerSec;

		sampleSize = wfxDecoded.nBlockAlign;

		//try to get a converter from the encoded data to the decoded data
		ret = acmStreamOpen(&acmStream,0,wfxEncoded,&wfxDecoded,0,0,0,0);

		//now we're done with wfxEncoded
		free(format);

		if(ret)
		{
			delete[] audioEncoded;
			AVIStreamClose(audioStream);
			return false;
		}


		//decide on a playback buffer size
		//make each buffer 1/2sec
		playBufferSamples = wfxDecoded.nSamplesPerSec / 2;
		playBufferSize = playBufferSamples * sampleSize;


		//hurry and try to create the output stream.
		//if we can't do that, then everything that follows is pointless.
		int mode = 0;
		if(wfxDecoded.wBitsPerSample == 8)
			mode |= FSOUND_8BITS;
		else if(wfxDecoded.wBitsPerSample == 16)
			mode |= FSOUND_16BITS;
		if(wfxDecoded.nChannels == 1)
			mode |= FSOUND_MONO;
		else
			mode |= FSOUND_STEREO;

		#ifdef SND_USE_FMOD
		fmod_stream = FSOUND_Stream_Create(win_movie_fmod_streamCallback,playBufferSize,mode,wfxDecoded.nSamplesPerSec,(int)this);
		if(!fmod_stream)
		{
			acmStreamClose(acmStream,0);
			delete[] audioEncoded;
			AVIStreamClose(audioStream);
			err("Error creating fmod stream for movieplayback.  Please report this case so we can improve the robustness of the movie player!");
			return false;
		}
		#endif


		//find out how large a decode buffer we need for the encode buffer chunksize
		acmStreamSize(acmStream,audioChunkSize,&decodeBufferSize,ACM_STREAMSIZEF_SOURCE);
		decodeBufferSamples = decodeBufferSize / sampleSize;


		//allocate the decode buffer
		audioDecoded = new char[decodeBufferSize];

		//prep the decode operation
		audioStreamHeader.cbStruct = sizeof(ACMSTREAMHEADER);
		audioStreamHeader.fdwStatus = 0;
		audioStreamHeader.pbSrc = (LPBYTE)audioEncoded;
		audioStreamHeader.cbSrcLength = audioChunkSize;
		audioStreamHeader.pbDst = (LPBYTE)audioDecoded;
		audioStreamHeader.cbDstLength = decodeBufferSize;
		ret = acmStreamPrepareHeader(acmStream,&audioStreamHeader,0);
		if(ret)
		{
			delete[] audioDecoded;
			acmStreamClose(acmStream,0);
			delete[] audioEncoded;
			AVIStreamClose(audioStream);
			return false;
		}

		#ifdef SND_USE_FMOD
		//finally we're ready to start the audio stream
		FSOUND_Stream_Play(FSOUND_FREE,fmod_stream);
		#endif

		return true;
	}
Ejemplo n.º 23
0
/*
[
    [DESCRIPTION]

    [PARAMETERS]
 
    [RETURN_VALUE]

    [REMARKS]

    [SEE_ALSO]
]
*/
int main()
{
    FSOUND_STREAM  *stream;
    FSOUND_DSPUNIT *dsp1,*dsp2;
    char key;

    if (FSOUND_GetVersion() < FMOD_VERSION)
    {
        printf("Error : You are using the wrong DLL version!  You should be using FMOD %.02f\n", FMOD_VERSION);
        return 1;
    }

    printf("-------------------------------------------------------------\n");
    printf("FSOUND Streamer example.\n");
    printf("Copyright (c) Firelight Technologies Pty, Ltd, 2001-2004.\n");
    printf("-------------------------------------------------------------\n");


    printf("---------------------------------------------------------\n");    
    printf("Output Type\n");    
    printf("---------------------------------------------------------\n");    
#if defined(WIN32) || defined(_WIN64) || defined(__CYGWIN32__) || defined(__WATCOMC__)
    printf("1 - Direct Sound\n");
    printf("2 - Windows Multimedia Waveout\n");
    printf("3 - ASIO\n");
#elif defined(__linux__)
    printf("1 - OSS - Open Sound System\n");
    printf("2 - ESD - Elightment Sound Daemon\n");
    printf("3 - ALSA 0.9 - Advanced Linux Sound Architecture\n");   
#endif   
    printf("4 - NoSound\n");
    printf("---------------------------------------------------------\n");    // print driver names
    printf("Press a corresponding number or ESC to quit\n");

    do
    {
        key = getch();
    } while (key != 27 && key < '1' && key > '4');
    
    switch (key)
    {
#if defined(WIN32) || defined(_WIN64) || defined(__CYGWIN32__) || defined(__WATCOMC__)
        case '1' :  FSOUND_SetOutput(FSOUND_OUTPUT_DSOUND);
                    break;
        case '2' :  FSOUND_SetOutput(FSOUND_OUTPUT_WINMM);
                    break;
        case '3' :  FSOUND_SetOutput(FSOUND_OUTPUT_ASIO);
                    break;
#elif defined(__linux__)
        case '1' :  FSOUND_SetOutput(FSOUND_OUTPUT_OSS);
                    break;
        case '2' :  FSOUND_SetOutput(FSOUND_OUTPUT_ESD);
                    break;
        case '3' :  FSOUND_SetOutput(FSOUND_OUTPUT_ALSA);
                    break; 
#endif       
        case '4' :  FSOUND_SetOutput(FSOUND_OUTPUT_NOSOUND);
                    break;
        default :   exit(0);
    }

    // ==========================================================================================
    // SELECT DRIVER
    // ==========================================================================================
    {
        int i,driver=0;
        char key;

        // The following list are the drivers for the output method selected above.
        printf("---------------------------------------------------------\n");    
        switch (FSOUND_GetOutput())
        {
            case FSOUND_OUTPUT_NOSOUND:   printf("NoSound"); break;
            case FSOUND_OUTPUT_WINMM:     printf("Windows Multimedia Waveout"); break;
            case FSOUND_OUTPUT_DSOUND:    printf("Direct Sound"); break;
            case FSOUND_OUTPUT_ASIO:      printf("ASIO"); break;
            case FSOUND_OUTPUT_OSS:       printf("Open Sound System"); break;
            case FSOUND_OUTPUT_ESD:       printf("Enlightment Sound Daemon"); break;
            case FSOUND_OUTPUT_ALSA:      printf("Alsa"); break;
           
        };
        printf(" Driver list\n");    
        printf("---------------------------------------------------------\n");    

        for (i=0; i < FSOUND_GetNumDrivers(); i++) 
        {
            printf("%d - %s\n", i+1, FSOUND_GetDriverName(i));    // print driver names
        }
        printf("---------------------------------------------------------\n");    // print driver names
        printf("Press a corresponding number or ESC to quit\n");

        do
        {
            key = getch();
            if (key == 27) exit(0);
            driver = key - '1';
        } while (driver < 0 || driver >= FSOUND_GetNumDrivers());

        FSOUND_SetDriver(driver);                    // Select sound card (0 = default)
    }

    // ==========================================================================================
    // INITIALIZE
    // ==========================================================================================
    if (!FSOUND_Init(44100, 16, 0))
    {
        printf("Error!\n");
        printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
        return 1;
    }

    // ==========================================================================================
    // CREATE USER STREAM
    // ==========================================================================================
    stream = FSOUND_Stream_Create(streamcallback, 6*2048, FSOUND_NORMAL | FSOUND_16BITS | FSOUND_STEREO, 44100, (void *)12345);
    if (!stream)
    {
        printf("Error!\n");
        printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
        return 1;
    }

    FSOUND_Stream_SetEndCallback(stream, endcallback, 0);

    dsp1 = FSOUND_Stream_CreateDSP(stream, dspcallback, 0, 0);    // priority 0 = it comes first in dsp chain.
    dsp2 = FSOUND_Stream_CreateDSP(stream, dspcallback, 1, 0);    // priority 1 = it comes last

    printf("Press any key to quit\n");
    printf("=========================================================================\n");
    printf("Playing stream...\n");

    // ==========================================================================================
    // PLAY STREAM
    // ==========================================================================================
    if (FSOUND_Stream_Play(FSOUND_FREE, stream) == -1)
    {
        printf("Error!\n");
        printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
        return 1;

    }

    printf("******* Hit a key to active stream DSP unit #1 to halve the stream volume.\n");
    getch();

    FSOUND_DSP_SetActive(dsp1, 1);
    printf("******* Now hit a key to active stream DSP unit #2 to quarter the stream volume.\n");
    getch();
    FSOUND_DSP_SetActive(dsp2, 1);
    printf("******* How hit a key to finish.\n");

    getch();

    printf("\n");

    FSOUND_DSP_Free(dsp1);
    FSOUND_DSP_Free(dsp2);

    FSOUND_Stream_Close(stream);

    FSOUND_Close();
   
    return 0;
}
Ejemplo n.º 24
0
int main(int argc, char ** argv)
{
    int finp = 0,first = 1;
    SDL_Surface * menu = NULL;
    SDL_Surface * ecran = NULL;
    SDL_Rect position_menu;
    SDL_Event event;
    FSOUND_STREAM * musique = NULL;
    
    SDL_Init(SDL_INIT_VIDEO);
    TTF_Init();
    FSOUND_Init(44100,32,0);
    
    ecran = SDL_SetVideoMode(800,800,32,SDL_HWSURFACE | SDL_DOUBLEBUF);
    
    if(ecran == NULL)
       exit(EXIT_FAILURE);
    SDL_WM_SetCaption("Prozet zz1",NULL);
    
    menu = IMG_Load("./dessin/menu.jpg");
    if(menu == NULL)
       exit(EXIT_FAILURE);
    
    position_menu.x = 0;
    position_menu.y = 0;
        
    musique = FSOUND_Stream_Open("./son/jourdefoot.mp3",0,0,0);
    if(musique == NULL)
       exit(EXIT_FAILURE);
    while(finp == 0)
    {
       if(first == 1)
       {
          SDL_BlitSurface(menu,NULL,ecran,&position_menu);
          SDL_Flip(ecran);
          FSOUND_Stream_Play(FSOUND_FREE,musique);
	  first = 0;
       }
       SDL_WaitEvent(&event);
       switch(event.type)
       {
          case SDL_QUIT:
	               finp = 1;
	               break;
	  case SDL_MOUSEBUTTONDOWN:
	               if(event.button.button == SDL_BUTTON_LEFT)
		       {
		          if(event.button.x >= 250 && event.button.x <= 550)
			  {
			     if(event.button.y >= 300 && event.button.y <= 400)
			     {
			        FSOUND_Stream_Stop(musique);
				mode_solo(ecran);
				first = 1;
			     }
			     else
			     {
			        if(event.button.y >= 450 && event.button.y <= 550)
				{
			           FSOUND_Stream_Stop(musique);
				   mode_local_serveur(ecran);
				   first = 1;
				}
				else
				{
				   if(event.button.y >= 600 && event.button.y <= 700)
				   {
			              FSOUND_Stream_Stop(musique);
				      mode_local_client(ecran);
				      first = 1;
				   }
				}
			     }
			  }
		       }
		       break;
       }
       
    }
    
    FSOUND_Stream_Stop(musique);
    FSOUND_Stream_Close(musique);
    FSOUND_Close();
    SDL_FreeSurface(menu);
    SDL_FreeSurface(ecran);
    TTF_Quit();
    SDL_Quit();
    return(EXIT_SUCCESS);
      
}