GameEngine: Capitulo 4 . Sound Manager

Hola a todos,

Bienvenidos a la entrega de antes del fin de semana (si, el fin de semana para mi es sagrado) de como aprender programar un game engine y que tu madre te siga queriendo más o menos igual...

En este capitulo vamos ha enseñar lo que en muchos tutoriales se olvida de explicar pero que sin el cual ningún juego podría ver la luz.. el sound manager. El audio de nuestro game engine lo implementaremos mediante OpenAL y Alut (el equivalente sonoro a OpenGL y Glut). Si nunca habeis trabajado con estas librerias os recomiendo que os leais este post ya que por la red hay poca información al respecto.

Como instalar OpenAL+Alut

Con unos sencillos pasos podremos instalar las librerias en nuestro PC:

1. Descargaros las librerias de aquí 
2. Instaladlas como os digan las instrucciones (pueden variar de un sistema a otro). A grandes rasgos lo que os hará falta será copiar los .a, .dll ,.h en las carpetas de sistema que haga falta para que nuestro proyecto pueda leerlas.
3. Linkar nuestro proyecto con openal. La forma más fácil de linkar las librerias es incluir estas lineas en el main.cpp justo despues de la eliminación de la consola que explicamos hace unos pocos capítulos:
   
   
   //Linking openal 
   #pragma comment(lib, "openal32.lib")
   #pragma comment(lib, "alut.lib")

Como usar OpenAL + Alut:

El funcionamiento de OpenAl es sencillo, cargamos un sonido, lo guardamos en un buffer de memoria y cuando hacemos un play de ese sonido lo asignamos a un canal. A nivel personal, esto que es tan sencillo se puede convertir en un excelente infierno. Mi recomendación, cargar todos los sonidos al principio (cargarlos en tiempo de ejecución acostumbra a acabar en desastre por liarla con los buffers) y encapsular muy bien openAl para no tener que acceder nunca directamente a ella desde nuestro juego.

Código:

El código de esta práctica es muy sencillo, como mucho habréis supuesto, la clase SoundManager es un singleton que se encarga de gestionar el sonido y solo se ha de modificar la clase core para poder unir este manager al proyecto. Miremos el código entones:

SoundManager.cpp:

/**************************************************************************************************/

// Código creado por F.Bordas (LordPakus) como ejemplo de creación de un game engine

// para el blog LordPakus (http://lordpakus.blogspot.com/).

// Prohibida la distribución fuera de este blog sin el permiso expreso del autor

/**************************************************************************************************/

/**************************************************************************************************/

// SoundManager.h : Código de la parte de audio del game engine

// Caracteristicas especiales: Esta clase implementa un singleton, es decir, solo podrá existir un objeto de esta clase en todo el proyecto

/**************************************************************************************************/

#include "SoundManager.h"

#include "MyGL.h"

#include <iostream> //Usada para imprimir por consola

using namespace std;

//Instancia única del sound manager

SoundManager SoundManager::instance;

SoundManager::SoundManager()

{

}

SoundManager::~SoundManager()

{

}

//Devolvemos el puntero al singleton

SoundManager& SoundManager::singleton()

{

return instance;

}

//Sounds functions

void SoundManager::Init(int* argc, char* argv[])

{

cout << "Inicializamos el sound manager\n";

alutInit(argc, argv) ;

//Toda esta carga de sonidos esta hardcodeada, por el momento. En breve publicaré un capitulo dedicado a los filemanager y a la eliminación de todo esto.

alGenBuffers(MAX_SOUNDS,buffer);

buffer[SOUND_BOOST] = alutCreateBufferFromFile ("Data\\Audio\\boost.wav");

buffer[SOUND_PASOS] = alutCreateBufferFromFile ("Data\\Audio\\pasos.wav");

buffer[SOUND_SALTO] = alutCreateBufferFromFile ("Data\\Audio\\salto.wav");

buffer[SOUND_COIN] = alutCreateBufferFromFile ("Data\\Audio\\coin-04.wav");

buffer[SOUND_DIE] = alutCreateBufferFromFile ("Data\\Audio\\evlaugh.wav");

alGenSources(MAX_SOUNDS, source);

}

void SoundManager::DeInit()

{

cout << "Desinicializamos el sound manager\n";

alutExit();

}

void SoundManager::Play(int id)

{

static unsigned int s = 0;

alSourcei (source[s], AL_BUFFER, buffer[id]);

alSourcePlay (source[s]);

if(++s == MAX_SOUNDS)

s = 0;

}

SoundManager.h

/**************************************************************************************************/

// Código creado por F.Bordas (LordPakus) como ejemplo de creación de un game engine

// para el blog LordPakus (http://lordpakus.blogspot.com/).

// Prohibida la distribución fuera de este blog sin el permiso expreso del autor

/**************************************************************************************************/

/**************************************************************************************************/

// SoundManager.h : Código de la parte de audio del game engine

// Caracteristicas especiales: Esta clase implementa un singleton, es decir, solo podrá existir un objeto de esta clase en todo el proyecto

/**************************************************************************************************/

#include "AL/Alut.h"

#include "MyGL.h"

#ifndef __SoundManager__

#define __SoundManager__

//SOUNDS: Esto es un parche temporal... en breve pondré un capitulo referente a los filemanager que permitirá quitar todo esto.

#define MAX_SOUNDS 100

#define SOUND_BOOST 0

#define SOUND_PASOS 1

#define SOUND_SALTO 2

#define SOUND_COIN 3

#define SOUND_DIE 4

class SoundManager

{

private:

// Constructor y destructor de la clase

static SoundManager instance;

SoundManager();

~SoundManager();

public:

static SoundManager& singleton();

public:

//Funcion para inicializar el motor de sonido

void Init(int* argc, char* argv[]);

//Funcion para desinicializar el motor de sonido

void DeInit();

public:

void Play(int id);

void PlayBackground(int id);

private:

//Variables usadas para almacenar la información de audio

ALuint buffer[MAX_SOUNDS];

ALuint source[MAX_SOUNDS];

};

#endif // __GameController__

Core.cpp:

/**************************************************************************************************/

// Código creado por F.Bordas (LordPakus) como ejemplo de creación de un game engine

// para el blog LordPakus (http://lordpakus.blogspot.com/).

// Prohibida la distribución fuera de este blog sin el permiso expreso del autor

/**************************************************************************************************/

/**************************************************************************************************/

// Core.cpp : Código del core manager.

/**************************************************************************************************/

#include "Core.h"

#include "MyGL.h" //Includes standar para opengl,glut y compañia

#include "GraphicsManager.h" //Inclusión del motor gráfico

#include "SoundManager.h" //Inclusión del motor de audio

#include <iostream> //Usada para imprimir por consola

#include <cmath>

using namespace std;

//Instancia única del core manager

Core Core::instance;

//Constructor

Core::Core()

{

}

//Destructor

Core::~Core()

{

}

//Devolvemos el puntero al singleton

Core& Core::singleton()

{

return instance;

}

//Funcion para inicializar el bucle principal

void Core::Init(int* argc, char* argv[])

{

cout << "Inicializamos el Core Manager\n";

//Inicializamos el motor gráfico

GraphicsManager::singleton().Init(argc,argv);

//Inicializamos el motor de audio

SoundManager::singleton().Init(argc,argv);

//Asignamos todas las funciones de callback del glut

//a las funciones que definiremos posteriormente

glutIdleFunc(glut_idle);

}

//Funcion para ejecutar el bucle principal

void Core::Run()

{

//Pasamos el control del bucle principal al glut

//que nos gestionara los eventos y llamara a las

//funciones de callback.

glutMainLoop();

}

//Funcion para desinicializar el bucle principal

void Core::DeInit()

{

cout << "Desinicializamos el Core Manager\n";

GraphicsManager::singleton().DeInit();

SoundManager::singleton().DeInit();

}

//CALLBACKS DE GLUT

//Esta funcion se llama cuando el sistema no hace nada (por ahora gestionada por glut)

void Core::glut_idle()

{

//Nos sacamos de la manga que de vez en cuando haga sonidos aleatorios

if(!(rand()%100))

SoundManager::singleton().Play(rand()%5);

//Repintamos la escena

glutPostRedisplay();

}

Resultados:

Si todo está bien hecho (y si no, pillad el ejemplo del “repositorio” ) os tendría que salir lo mismo que el último día, pero sonando de fondo unos sonidos aleatorios (yo he puesto unos sonidos, vosotros poned los que queráis).

NOTA IMPORTANTE: Vereis que la carga de sonidos está hardcodeada y que la posición en la que se graban los sonidos se ha conseguido mediante defines..... por ahora, aceptadlo como un mal menor. Arreglarlo y hacer que funcionara como yo quisiera me habría hecho imposible publicar hoy. En un futura (y no muy lejana) entrega os pasaré el código del FileManager que nos permitirá cargar listas de sonidos desde un archivo y hacer que este código sea mucho más mantenible.

Disfrutad de vuestro audio, buen fin de semana y nos vemos!!!