Actualizado jail_adudio y Menu

source/jail_audio.cpp

@@ -1,6 +1,7 @@
-#ifndef __MIPSEL__
 #include "jail_audio.h"
 #include "stb_vorbis.c"
+#include <SDL2/SDL.h>
+#include <stdio.h>
 
 #define JA_MAX_SIMULTANEOUS_CHANNELS 5
 
@@ -30,16 +31,17 @@ JA_Channel_t    channels[JA_MAX_SIMULTANEOUS_CHANNELS];
 int             JA_freq {48000};
 SDL_AudioFormat JA_format {AUDIO_S16};
 Uint8           JA_channels {2};
+int             JA_volume = 128;
 
 void audioCallback(void * userdata, uint8_t * stream, int len) {
     SDL_memset(stream, 0, len);
     if (current_music != NULL && current_music->state == JA_MUSIC_PLAYING) {
         const int size = SDL_min(len, current_music->samples*2-current_music->pos);
-        SDL_memcpy(stream, current_music->output+current_music->pos, size);
+        SDL_MixAudioFormat(stream, (Uint8*)(current_music->output+current_music->pos), AUDIO_S16, size, JA_volume);
         current_music->pos += size/2;
         if (size < len) {
             if (current_music->times != 0) {
-                SDL_memcpy(stream+size, current_music->output, len-size);
+                SDL_MixAudioFormat(stream+size, (Uint8*)current_music->output, AUDIO_S16, len-size, JA_volume);
                 current_music->pos = (len-size)/2;
                 if (current_music->times > 0) current_music->times--;
             } else {
@@ -52,11 +54,11 @@ void audioCallback(void * userdata, uint8_t * stream, int len) {
     for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
         if (channels[i].state == JA_CHANNEL_PLAYING) {
             const int size = SDL_min(len, channels[i].sound->length - channels[i].pos);
-            SDL_MixAudioFormat(stream, channels[i].sound->buffer + channels[i].pos, AUDIO_S16, size, 64);
+            SDL_MixAudioFormat(stream, channels[i].sound->buffer + channels[i].pos, AUDIO_S16, size, JA_volume/2);
             channels[i].pos += size;
             if (size < len) {
                 if (channels[i].times != 0) {
-                    SDL_MixAudioFormat(stream + size, channels[i].sound->buffer, AUDIO_S16, len-size, 64);
+                    SDL_MixAudioFormat(stream + size, channels[i].sound->buffer, AUDIO_S16, len-size, JA_volume/2);
                     channels[i].pos = len-size;
                     if (channels[i].times > 0) channels[i].times--;
                 } else {
@@ -79,7 +81,19 @@ void JA_Init(const int freq, const SDL_AudioFormat format, const int channels) {
 JA_Music JA_LoadMusic(const char* filename) {
     int chan, samplerate;
     JA_Music music = new JA_Music_t();
-    music->samples = stb_vorbis_decode_filename(filename, &chan, &samplerate, &music->output);
+
+    // [RZC 28/08/22] Carreguem primer el arxiu en memòria i després el descomprimim. Es algo més rapid.
+    FILE *f = fopen(filename, "rb");
+    fseek(f, 0, SEEK_END);
+    long fsize = ftell(f);
+    fseek(f, 0, SEEK_SET);
+    Uint8 *buffer = (Uint8*)malloc(fsize + 1);
+    fread(buffer, fsize, 1, f);
+    fclose(f);
+    music->samples = stb_vorbis_decode_memory(buffer, fsize, &chan, &samplerate, &music->output);
+    free(buffer);
+    // [RZC 28/08/22] Abans el descomprimiem mentre el teniem obert
+//    music->samples = stb_vorbis_decode_filename(filename, &chan, &samplerate, &music->output);
 
     SDL_AudioCVT cvt;
     SDL_BuildAudioCVT(&cvt, AUDIO_S16, chan, samplerate, JA_format, JA_channels, JA_freq);
@@ -134,6 +148,13 @@ void JA_DeleteMusic(JA_Music music) {
     delete music;
 }
 
+JA_Sound JA_NewSound(Uint8* buffer, Uint32 length) {
+    JA_Sound sound = new JA_Sound_t();
+    sound->buffer = buffer;
+    sound->length = length;
+    return sound;
+}
+
 JA_Sound JA_LoadSound(const char* filename) {
     JA_Sound sound = new JA_Sound_t();
     SDL_AudioSpec wavSpec;
@@ -210,4 +231,8 @@ JA_Channel_state JA_GetChannelState(const int channel) {
     if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return JA_CHANNEL_INVALID;
     return channels[channel].state;
 }
-#endif
+
+int JA_SetVolume(int volume) {
+    JA_volume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
+    return JA_volume;
+}

source/jail_audio.h

@@ -17,6 +17,7 @@ void JA_StopMusic();
 JA_Music_state JA_GetMusicState();
 void JA_DeleteMusic(JA_Music music);
 
+JA_Sound JA_NewSound(Uint8* buffer, Uint32 length);
 JA_Sound JA_LoadSound(const char* filename);
 int JA_PlaySound(JA_Sound sound, const int loop = 0);
 void JA_PauseChannel(const int channel);
@@ -24,3 +25,5 @@ void JA_ResumeChannel(const int channel);
 void JA_StopChannel(const int channel);
 JA_Channel_state JA_GetChannelState(const int channel);
 void JA_DeleteSound(JA_Sound sound);
+
+int JA_SetVolume(int volume);

source/menu.h

@@ -1,71 +1,54 @@
 #pragma once
+
 #include <SDL2/SDL.h>
+#include <vector>
 #include "sprite.h"
 #include "text.h"
+#include "asset.h"
 #include "input.h"
+#include "utils.h"
 #include "jail_audio.h"
+#include <sstream>
+#include <fstream>
 
 #ifndef MENU_H
 #define MENU_H
 
-#define MENU_MAX_ITEMS 50
+// Tipos de fondos para el menu
-
-#define MENU_NO_OPTION -1
-
 #define MENU_BACKGROUND_TRANSPARENT 0
 #define MENU_BACKGROUND_SOLID 1
 
-// Clase menu
+// Tipos de archivos de audio
+#define SOUND_ACCEPT 0
+#define SOUND_MOVE 1
+#define SOUND_CANCEL 2
+
+// Opciones de menu
+#define MENU_NO_OPTION -1
+
+// Clase Menu
 class Menu
 {
 private:
-	std::string mName;				// Nombre del menu
+	struct rectangle_t
-	int mPosX;						// Posición en el eje X de la primera letra del primer elemento
-	int mPosY;						// Posición en el eje Y de la primera letra del primer elemento
-	Uint16 mHeight;					// Altura del menu
-	Uint16 mWidth;					// Anchura del menu
-	Uint8 mTotalItems;				// Numero total de items del menu
-	int mItemSelected;				// Índice del item del menu que ha sido seleccionado
-	Uint8 mDefaultActionWhenCancel; // Indice del item del menu que se selecciona cuando se cancela el menu
-	Uint8 mBackgroundType;			// Tipo de fondo para el menu
-	bool mIsCenteredOnX;			// Variable para saber si el menu debe estar centrado respecto a un punto en el eje X
-	bool mIsCenteredOnY;			// Variable para saber si el menu debe estar centrado respecto a un punto en el eje Y
-	int mCenterX;					// Centro del menu en el eje X
-	int mCenterY;					// Centro del menu en el eje Y
-	bool mAreElementsCenteredOnX;	// Variable para saber si los elementos van centrados en el eje X
-	Uint16 mWidestItem;				// Anchura del elemento más ancho
-	JA_Sound mSoundAccept;			// Sonido al aceptar o elegir una opción del menu
-	JA_Sound mSoundCancel;			// Sonido al cancelar el menu
-	JA_Sound mSoundMove;			// Sonido al mover el selector
-	SDL_Renderer *mRenderer;		// Puntero al renderizador de la ventana
-	std::string *mFileList;			// Lista de ficheros
-	Text *mText;					// Texto para poder escribir los items del menu
-	Input *mInput;					// Gestor de eventos de entrada de teclado o gamepad
-	color_t mColorGreyed;			// Color para los elementos agrisados
-
-	struct rectangle
 	{
 		SDL_Rect rect; // Rectangulo
-		Uint8 r;	   // Rojo
+		color_t color; // Color
-		Uint8 g;	   // Verde
+		int a;		   // Transparencia
-		Uint8 b;	   // Azul
-		Uint8 a;	   // Transparencia
 	};
-	rectangle mRectBG; // Rectangulo de fondo del menu
 
-	struct item
+	struct item_t
 	{
 		std::string label; // Texto
 		SDL_Rect rect;	   // Rectangulo que delimita el elemento
-		Uint8 hPaddingDown; // Espaciado bajo el elemento
+		int hPaddingDown;  // Espaciado bajo el elemento
 		bool selectable;   // Indica si se puede seleccionar
 		bool greyed;	   // Indica si ha de aparecer con otro color mas oscuro
 		bool linkedDown;   // Indica si el elemento actual y el siguiente se tratan como uno solo. Afecta al selector
 		bool linkedUp;	   // Indica si el elemento actual y el anterior se tratan como uno solo. Afecta al selector
 	};
-	item mItem[MENU_MAX_ITEMS]; // Estructura para cada elemento del menu
 
-	struct selector
+	struct selector_t
 	{
 		float originY;	   // Coordenada de origen
 		float targetY;	   // Coordenada de destino
@@ -77,24 +60,53 @@ private:
 		bool resizing;	   // Indica si el selector está cambiando de tamaño
 		float y;		   // Coordenada actual, usado para el desplazamiento
 		float h;		   // Altura actual, usado para el cambio de tamaño
-		Uint8 numJumps; // Numero de pasos preestablecido para llegar al destino
+		int numJumps;	   // Numero de pasos preestablecido para llegar al destino
-		Uint8 index;	// Elemento del menu que tiene el foco
+		int index;		   // Elemento del menu que tiene el foco
 		SDL_Rect rect;	   // Rectangulo del selector
-		Uint8 r;		// Cantidad de color rojo para el rectangulo del selector
+		color_t color;	   // Color del selector
-		Uint8 g;		// Cantidad de color verde para el rectangulo del selector
+		color_t itemColor; // Color del item
-		Uint8 b;		// Cantidad de color azul para el rectangulo del selector
+		int a;			   // Cantidad de transparencia para el rectangulo del selector
-		Uint8 a;		// Cantidad de transparencia para el rectangulo del selector
-		Uint8 itemR;	// Cantidad de color rojo para el texto del elemento seleccionado
-		Uint8 itemG;	// Cantidad de color verde para el texto del elemento seleccionado
-		Uint8 itemB;	// Cantidad de color azul para el texto del elemento seleccionado
 	};
-	selector mSelector; // Variables para pintar el selector del menu
 
-	// Carga los recursos necesarios para la sección 'Title'
+	std::string name;			 // Nombre del menu
-	bool loadMedia();
+	int x;						 // Posición en el eje X de la primera letra del primer elemento
+	int y;						 // Posición en el eje Y de la primera letra del primer elemento
+	int h;						 // Altura del menu
+	int w;						 // Anchura del menu
+	int itemSelected;			 // Índice del item del menu que ha sido seleccionado
+	int defaultActionWhenCancel; // Indice del item del menu que se selecciona cuando se cancela el menu
+	int backgroundType;			 // Tipo de fondo para el menu
+	int centerX;				 // Centro del menu en el eje X
+	int centerY;				 // Centro del menu en el eje Y
+	bool isCenteredOnX;			 // Variable para saber si el menu debe estar centrado respecto a un punto en el eje X
+	bool isCenteredOnY;			 // Variable para saber si el menu debe estar centrado respecto a un punto en el eje Y
+	bool areElementsCenteredOnX; // Variable para saber si los elementos van centrados en el eje X
+	int widestItem;				 // Anchura del elemento más ancho
+	JA_Sound soundAccept;		 // Sonido al aceptar o elegir una opción del menu
+	JA_Sound soundCancel;		 // Sonido al cancelar el menu
+	JA_Sound soundMove;			 // Sonido al mover el selector
+	SDL_Renderer *renderer;		 // Puntero al renderizador de la ventana
+	Text *text;					 // Texto para poder escribir los items del menu
+	Input *input;				 // Gestor de eventos de entrada de teclado o gamepad
+	Asset *asset;				 // Objeto para gestionar los ficheros de recursos
+	color_t colorGreyed;		 // Color para los elementos agrisados
+	rectangle_t rectBG;			 // Rectangulo de fondo del menu
+	std::vector<item_t> item;	 // Estructura para cada elemento del menu
+	selector_t selector;		 // Variables para pintar el selector del menu
+	std::string font_png;
+	std::string font_txt;
 
-	// Establece el valor de la variable
+	// Carga la configuración del menu desde un archivo de texto
-	void setTotalItems(int num);
+	bool load(std::string file_path);
+
+	// Asigna variables a partir de dos cadenas
+	bool setVars(std::string var, std::string value);
+
+	// Asigna variables a partir de dos cadenas
+	bool setItem(item_t *item, std::string var, std::string value);
+
+	// Inicializa las variables
+	void init();
 
 	// Establece el rectangulo de fondo del menu
 	void setRectSize();
@@ -112,16 +124,16 @@ private:
 	void updateSelector();
 
 	// Obtiene la anchura del elemento más ancho del menu
-	Uint16 getWidestItem();
+	int getWidestItem();
 
 	// Gestiona la entrada de teclado y mando durante el menu
 	void checkMenuInput(Menu *menu);
 
 	// Calcula el ancho del menu
-	Uint16 findWidth();
+	int findWidth();
 
 	// Calcula el alto del menu
-	Uint16 findHeight();
+	int findHeight();
 
 	// Recoloca los elementos del menu en el eje Y
 	void replaceElementsOnY();
@@ -131,19 +143,19 @@ private:
 
 public:
 	// Constructor
-	Menu(SDL_Renderer *renderer, Text *text, Input *input, std::string *fileList);
+	Menu(SDL_Renderer *renderer, Asset *asset, Input *input, std::string file="");
 
 	// Destructor
 	~Menu();
 
-	// Inicializador
+	// Carga los ficheros de audio
-	void init(std::string name, int x, int y, int backgroundType);
+	void loadAudioFile(std::string file, int sound);
 
 	// Obtiene el nombre del menu
 	std::string getName();
 
 	// Obtiene el valor de la variable
-	Uint8 getItemSelected();
+	int getItemSelected();
 
 	// Deja el menu apuntando al primer elemento
 	void reset();
@@ -158,13 +170,13 @@ public:
 	void render();
 
 	// Establece el color del rectangulo de fondo
-	void setBackgroundColor(int r, int g, int b, int alpha);
+	void setBackgroundColor(color_t color, int alpha);
 
 	// Establece el color del rectangulo del selector
-	void setSelectorColor(int r, int g, int b, int alpha);
+	void setSelectorColor(color_t color, int alpha);
 
 	// Establece el color del texto del selector
-	void setSelectorTextColor(int r, int g, int b);
+	void setSelectorTextColor(color_t color);
 
 	// Centra el menu respecto a un punto en el eje X
 	void centerMenuOnX(int value);
@@ -176,25 +188,27 @@ public:
 	void centerMenuElementsOnX();
 
 	// Añade un item al menu
-	void addItem(std::string text, Uint8 hPaddingDown = 1, bool selectable = true, bool greyed = false, bool linkedDown = false);
+	void addItem(std::string text, int hPaddingDown = 1, bool selectable = true, bool greyed = false, bool linkedDown = false);
 
 	// Cambia el texto de un item
-	void setItemCaption(Uint8 index, std::string text);
+	void setItemCaption(int index, std::string text);
 
 	// Establece el indice del item que se usará por defecto al cancelar el menu
-	void setDefaultActionWhenCancel(Uint8 item);
+	void setDefaultActionWhenCancel(int item);
 
 	// Coloca el selector en una posición específica
-	void setSelectorPos(Uint8 index);
+	void setSelectorPos(int index);
 
 	// Establece el estado seleccionable de un item
-	void setSelectable(Uint8 index, bool value);
+	void setSelectable(int index, bool value);
 
 	// Establece el estado agrisado de un item
-	void setGreyed(Uint8 index, bool value);
+	void setGreyed(int index, bool value);
 
 	// Establece el estado de enlace de un item
-	void setLinkedDown(Uint8 index, bool value);
+	void setLinkedDown(int index, bool value);
+
+	// hacer procedimientos para establecer el titulo, la x, la y, la tipografia y el tipo de fondo
 };
 
 #endif