Jeux Libres
       
           

» Les Forums » Aide à propos de la création de jeux vidéo » [C++] Gérer le son en 3D en C++


Aller à la page : 1, 2.

[C++] Gérer le son en 3D en C++
David



Grade : Maître
Inscrit le: 11 Mai 2005, 20:30
Ecrit le: 08 Juillet 2011, 00:58             Message non corrigé

Ce sujet est dédié à la création d'une bibliothèque C++ de gestion du son en 3D.


La bibliothèque



Le projet consiste à créer une bibliothèque permettant de modéliser des sources sonores en 3D. Il s'agit d'une surcouche à l'API OpenAL.

Créateurs de la bibliothèque



Le développement de cette bibliothèque sera principalement maintenue par fabrizio.

________
Apprenez à créer votre propre FPS en C++ avec OpenGL. C'est pas dur ! :-)
  Profil
fabrizio



Grade : Connaisseur
Inscrit le: 30 Mai 2011, 15:09
Ecrit le: 08 Juillet 2011, 23:33             Message non corrigé

Je viens de commencez je vous tiendrez au courant ici:

Commencement (installation,premier code et assimilation de la blibliothèque) 25%



________
Je recrute pour un projet indé utilisant UDK ! http://halfactory.forumactif.org/
  Profil
David



Grade : Maître
Inscrit le: 11 Mai 2005, 20:30
Ecrit le: 09 Juillet 2011, 15:34             Message non corrigé

Je te conseille d'utiliser libsndfile pour charger les sons.

J'avais fais ceci pour m'initier à OpenAL :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
#include <AL/al.h>
#include <AL/alc.h>
#include <stdio.h>
#include <string>
#include <vector>
 
#include <sndfile.h>
#include <iostream>
 
ALuint LoadSound(const std::string& Filename)
{
   // Ouverture du fichier audio avec libsndfile
   SF_INFO FileInfos;
   SNDFILE* File = sf_open(Filename.c_str(), SFM_READ, &FileInfos);
   if (!File)
       return 0;
 
   // Lecture du nombre d'chantillons et du taux d'chantillonnage (nombre d'chantillons lire par seconde)
   ALsizei NbSamples  = static_cast<ALsizei>(FileInfos.channels * FileInfos.frames);
   ALsizei SampleRate = static_cast<ALsizei>(FileInfos.samplerate);
 
   // Lecture des chantillons audio au format entier 16 bits sign (le plus commun)
   std::vector<ALshort> Samples(NbSamples);
   if (sf_read_short(File, &Samples[0], NbSamples) < NbSamples)
       return 0;
 
   // Fermeture du fichier
   sf_close(File);
 
   // Dtermination du format en fonction du nombre de canaux
   ALenum Format;
   switch (FileInfos.channels)
   {
       case 1 :  Format = AL_FORMAT_MONO16;   break;
       case 2 :  Format = AL_FORMAT_STEREO16; break;
       default : return 0;
   }
 
   // Cration du tampon OpenAL
   ALuint Buffer;
   alGenBuffers(1, &Buffer);
 
   // Remplissage avec les chantillons lus
   alBufferData(Buffer, Format, &Samples[0], NbSamples * sizeof(ALushort), SampleRate);
 
   // Vrification des erreurs
   if (alGetError() != AL_NO_ERROR)
       return 0;
 
   return Buffer;
}
 
 
bool InitOpenAL()
{
   // Ouverture du device
   ALCdevice* Device = alcOpenDevice(NULL);
   if (!Device)
       return false;
 
   // Cration du contexte
   ALCcontext* Context = alcCreateContext(Device, NULL);
   if (!Context)
       return false;
 
   // Activation du contexte
   if (!alcMakeContextCurrent(Context))
       return false;
 
   return true;
}
 
 
 
void ShutdownOpenAL()
{
   // Rcupration du contexte et du device
   ALCcontext* Context = alcGetCurrentContext();
   ALCdevice*  Device  = alcGetContextsDevice(Context);
 
   // Dsactivation du contexte
   alcMakeContextCurrent(NULL);
 
   // Destruction du contexte
   alcDestroyContext(Context);
 
   // Fermeture du device
   alcCloseDevice(Device);
}
 
 
 
int main()
{
   if (false == InitOpenAL())
   {
       printf("Erreur d'initialisation d'OpenAL.\n");
   }
 
   // Cration d'une source
   ALuint Source;
   alGenSources(1, &Source);
 
   ALuint Buffer = LoadSound("embalm.wav");
 
   // On attache le tampon contenant les chantillons audio la source
   alSourcei(Source, AL_BUFFER, Buffer);
 
   // Lecture du son
   alSourcePlay(Source);
 
   alSource3f(Source, AL_POSITION, 0, 5, 0);
   alSource3f(Source, AL_VELOCITY, 0, 20, 0);
   //alSource3f(Source, AL_DIRECTION, 0, 0, 1);
 
   // Dfinition de la position de l'couteur (ici l'origine)
   alListener3f(AL_POSITION, 0.f, 0.f, 0.f);
 
   // Dfinition de la vitesse de l'couteur (ici nulle)
   alListener3f(AL_VELOCITY, 0.f, 0.f, 0.f);
 
   // Dfinition de l'orientation de l'couteur (ici il regarde vers l'axe des)
   ALfloat Orientation[] = {-1.f, 0.f, 0.f, 0.f, 0.f, 1.f};
   alListenerfv(AL_ORIENTATION, Orientation);
 
   ALint Status;
   do
   {
       // Rcupration et affichage de la position courante de lecture en secondes
       ALfloat Seconds = 0.f;
       alGetSourcef(Source, AL_SEC_OFFSET, &Seconds);
       std::cout << "\rLecture en cours... " << std::fixed << Seconds << " sec";
 
       alSource3f(Source, AL_POSITION, -1, -40 + 20*Seconds, 0);
 
       // Rcupration de l'tat du son
       alGetSourcei(Source, AL_SOURCE_STATE, &Status);
   }
   while (Status == AL_PLAYING);
 
   // Destruction du tampon
   alDeleteBuffers(1, &Buffer);
 
   // Destruction de la source
   alSourcei(Source, AL_BUFFER, 0);
   alDeleteSources(1, &Source);
 
   ShutdownOpenAL();
 
   return 0;
}

Regarde un peu comment sont utilisées les principales fonctions que tu devras utiliser. Ce programme joue un son de mouches qui se déplace de gauche à droite à vive allure. Tu observeras une augmentation puis une diminution de l'amplitude du son, accompagné d'un bel effet Doppler.

Tu devras te placer dans la peau du développeur qui utilisera tes classes. Ce qu'il souhaite, c'est que l'utilisation de tes classes soit très simple. Il faudrait que tu essaies de faire les classes qui permettent de compiler ce bout de code :


Les classes



A priori, il y aura 3 classes : SourceSonore, RecepteurSonore, ConteneurSon.

La première permettra de modéliser une source sonore dans un environnement 3D et de jouer du son. La deuxième modélisera l'écouteur (le joueur dans la scène 3D). La dernière permettra de gérer les différents sons. Elle permettra de charger et décharger un son. De plus un mécanisme interne permettra de ne pas charger deux fois le même son dans la carte son. Les mécanismes seront identique à ceux mis en place dans la gestion des textures. Faire des copier/coller modifiés.

Pour plus d'information, n'hésite pas à poser des questions à la suite de ce message.

________
Apprenez à créer votre propre FPS en C++ avec OpenGL. C'est pas dur ! :-)
  Profil
fabrizio



Grade : Connaisseur
Inscrit le: 30 Mai 2011, 15:09
Ecrit le: 09 Juillet 2011, 20:36             Message non corrigé

J'ai une question dans le site de la librairie il y a écrit que c'est pour le C et non pour le C++ ça change quelque chose ?

Sinon je regarde le code .

Je vais paraître très idiot mais en même temps ce topic sert a ça;

c'est bon j'ai compris comment l'installer  mais il n'y a que les include

________
Je recrute pour un projet indé utilisant UDK ! http://halfactory.forumactif.org/
  Profil
David



Grade : Maître
Inscrit le: 11 Mai 2005, 20:30
Ecrit le: 09 Juillet 2011, 21:36             Message non corrigé

Tu programmes en C++. Tu peux donc compiler aussi bien du C ou du C++. Si tu programmes en C, tu ne pourras compiler que du C.

J'ai l'impression que tu vas apprendre beaucoup de choses en développant ces classes. Mais on est là pour ça. ;-)

Installation de libsndfile sous Windows



Sur la page de téléchargement de libsndfile, télécharge la version Win32. Wop'putain c'est galère, j'avais oublié ! L'installeur est tellement galère que je viens de créer un zip avec seulement les éléments essentiels.

Dans la dossier include/ du zip tu trouvera le fichier sndfile.h à copier dans CodeBlocks\MinGW\include.
Dans la dossier lib/ du zip tu trouvera le fichier libsndfile-1.lib à copier dans CodeBlocks\MinGW\lib.

La bibliothèque libsndfile est maintenant installée.

Pour compiler, tu devras ajouter -llibsndfile-1 à l'éditeur de lien.

L'installation de cette bibliothèque ressemble beaucoup à l'installation de la bibliothèque SDL.

________
Apprenez à créer votre propre FPS en C++ avec OpenGL. C'est pas dur ! :-)
  Profil
fabrizio



Grade : Connaisseur
Inscrit le: 30 Mai 2011, 15:09
Ecrit le: 10 Juillet 2011, 11:36             Message non corrigé

J'aime bien ton Wop'poutain ^^.

Merci en faite je ne trouvai que les include et pas les lib.

Oui c'est vrai ça resemble beaucoup a la SDL

________
Je recrute pour un projet indé utilisant UDK ! http://halfactory.forumactif.org/
  Profil
David



Grade : Maître
Inscrit le: 11 Mai 2005, 20:30
Ecrit le: 10 Juillet 2011, 11:40             Message non corrigé

T'as réussi à jouer un son ?

Je ne sais plus comment on installe OpenAL. Si tu n'y arrive pas, je regarderais peut-être ça cette après midi.

________
Apprenez à créer votre propre FPS en C++ avec OpenGL. C'est pas dur ! :-)
  Profil
fabrizio



Grade : Connaisseur
Inscrit le: 30 Mai 2011, 15:09
Ecrit le: 10 Juillet 2011, 12:18             Message non corrigé

Je me suis débrouiiler tout seule j'ai trouvé un petit tuto qui explique comment l'installer et faire quelque ligne de code .

Mais il n'explique pas comment l'installer pas complétement quel link je dois méttre ?



________
Je recrute pour un projet indé utilisant UDK ! http://halfactory.forumactif.org/
  Profil
David



Grade : Maître
Inscrit le: 11 Mai 2005, 20:30
Ecrit le: 10 Juillet 2011, 21:06             Message non corrigé

Tu dois mettre -lOpenAL32.

Si ça ne marche pas, assure toi d'avoir le fichier OpenAL32.lib dans le dossier CodeBlocks\MinGW\lib.
Assure toi également d'avoir un dossier CodeBlocks\MinGW\include\AL contenant les fichiers al.h, alc.h, efx.h, efx-creative.h, EFX-Util.h et xram.h.

Ensuite, tu devrais pouvoir compiler et exécuter le programme que je t'ai donné plus haut.

________
Apprenez à créer votre propre FPS en C++ avec OpenGL. C'est pas dur ! :-)
  Profil
fabrizio



Grade : Connaisseur
Inscrit le: 30 Mai 2011, 15:09
Ecrit le: 10 Juillet 2011, 21:32             Message non corrigé

Il y a des messages d'ereurs pour des variables undefined sur :

"sf_open",

"sf_read_short",

"sf_close".

________
Je recrute pour un projet indé utilisant UDK ! http://halfactory.forumactif.org/
  Profil
 


Aller à la page : 1, 2.


Hébergeur du site : David
Version PHP : 5.4.45-0+deb7u2
Uptime : 60 jours 8 heures 4 minutes
Espace libre : 1484 Mo
Dernière sauvegarde : 03/04/2020
Taille de la sauvegarde : 1113 Mo


5897992 pages ont été consultées sur le site !
Dont 1904 pages pendant les 24 dernières heures.

Page générée en 1.656 secondes


Nos sites préférés
- Création d'un jeu de plateforme de A à Z avec SDL
- Zelda ROTH : Jeux amateurs sur le thème de Zelda
- Zeste de Savoir : la connaissance pour tous et sans pépins
- YunoHost : s'héberger soi-même en toute simplicité
- Site de Fvirtman : recueil de projets et de codes en C et C++
- Par ici la sortie : le site des idées de sorties


  © 2005-2020 linor.fr - Toute reproduction totale ou partielle du contenu de ce site est strictement interdite.