- [FIX] Retocada paleta grayscale

Makefile

@@ -3,25 +3,25 @@ source = source/*.cpp
 
 windows:
 	@echo off
-	g++ $(source) bin/icon.res -lmingw32 -lSDL2main -lSDL2 -mwindows -o "$(executable).exe"
+	g++ $(source) bin/icon.res -lmingw32 -lSDL3 -mwindows -o "$(executable).exe"
 	strip -s -R .comment -R .gnu.version --strip-unneeded "$(executable).exe"
 
 windows_debug:
 	@echo off
-	g++ $(source) -D DEBUG -g -Wall -fvar-tracking -lmingw32 -lSDL2main -lSDL2 -o "$(executable)_debug.exe"
+	g++ $(source) -D DEBUG -g -Wall -fvar-tracking -lmingw32 -lSDL3 -o "$(executable)_debug.exe"
 
 macos:
-	clang++ $(source) -Wall -Os -std=c++11 -ffunction-sections -fdata-sections -lSDL2 -o "$(executable)"
+	clang++ $(source) -Wall -Os -std=c++11 -ffunction-sections -fdata-sections -lSDL3 -o "$(executable)"
 
 macos_debug:
-	clang++ $(source) -D DEBUG -g -Wall -std=c++11 -lSDL2 -o "$(executable)_debug"
+	clang++ $(source) -D DEBUG -g -Wall -std=c++11 -lSDL3 -o "$(executable)_debug"
 
 macos_bundle:
-	clang++ $(source) -D MACOS_BUNDLE -Wall -Os -std=c++11 -framework SDL2 -F /Library/Frameworks -ffunction-sections -fdata-sections -o mini_bundle -rpath @executable_path/../Frameworks/ -target x86_64-apple-macos10.12
+	clang++ $(source) -D MACOS_BUNDLE -Wall -Os -std=c++11 -framework SDL3 -F /Library/Frameworks -ffunction-sections -fdata-sections -o mini_bundle -rpath @executable_path/../Frameworks/ -target x86_64-apple-macos10.12
 
 linux:
-	g++ $(source) -Wall -Os -ffunction-sections -fdata-sections -Wl,--gc-sections -lSDL2 -o "$(executable)"
+	g++ $(source) -Wall -Os -ffunction-sections -fdata-sections -Wl,--gc-sections -lSDL3 -o "$(executable)"
 	strip -s -R .comment -R .gnu.version --strip-unneeded "$(executable)"
 
 linux_debug:
-	g++ $(source) -D DEBUG -g -lSDL2 -o "$(executable)_debug"
+	g++ $(source) -D DEBUG -g -lSDL3 -o "$(executable)_debug"

source/actor.cpp

@@ -2284,10 +2284,10 @@ namespace actor
         bool giveSkill(char *skill)
         {
             const int skill_number = getSkillFromString(skill);
-            if (skill_number | SKILL_SHOES) modules::game::setMissatge("  JA TENS LES SABATES!-   ARA JA POTS BOTAR!");
-            else if (skill_number | SKILL_GLOVES) modules::game::setMissatge("  JA TENS ELS GUANTS!- ARA JA POTS ESPENTAR!");
-            else if (skill_number | SKILL_PANTS) modules::game::setMissatge(" JA TENS ELS PANTALONS!- JA POTS AGAFAR COSES!");
-            else if (skill_number | SKILL_BAG) modules::game::setMissatge("  JA TENS LA MOTXILLA!-  A ARREPLEGAR PECES!");
+            if (skill_number & SKILL_SHOES) modules::game::setMissatge("  JA TENS LES SABATES!-   ARA JA POTS BOTAR!");
+            else if (skill_number & SKILL_GLOVES) modules::game::setMissatge("  JA TENS ELS GUANTS!- ARA JA POTS ESPENTAR!");
+            else if (skill_number & SKILL_PANTS) modules::game::setMissatge(" JA TENS ELS PANTALONS!- JA POTS AGAFAR COSES!");
+            else if (skill_number & SKILL_BAG) modules::game::setMissatge("  JA TENS LA MOTXILLA!-  A ARREPLEGAR PECES!");
             return giveSkill(skill_number);
         }
 

source/actor.h

@@ -1,5 +1,5 @@
 #pragma once
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "misc.h"
 #include "jdraw.h"
 #include <vector>

source/config.cpp

@@ -1,13 +1,13 @@
 #include "config.h"
 #include "jfile.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 
 namespace config
 {
     bool musicEnabled = true;
     int soundMode = SOUND_ALL;
     uint8_t keys[7] = {SDL_SCANCODE_UP, SDL_SCANCODE_DOWN, SDL_SCANCODE_LEFT, SDL_SCANCODE_RIGHT, SDL_SCANCODE_SPACE, SDL_SCANCODE_RETURN, SDL_SCANCODE_ESCAPE};
-    int8_t pad_btns[7] = {SDL_CONTROLLER_BUTTON_DPAD_UP, SDL_CONTROLLER_BUTTON_DPAD_DOWN, SDL_CONTROLLER_BUTTON_DPAD_LEFT, SDL_CONTROLLER_BUTTON_DPAD_RIGHT, SDL_CONTROLLER_BUTTON_A, SDL_CONTROLLER_BUTTON_B, SDL_CONTROLLER_BUTTON_START};
+    int8_t pad_btns[7] = {SDL_GAMEPAD_BUTTON_DPAD_UP, SDL_GAMEPAD_BUTTON_DPAD_DOWN, SDL_GAMEPAD_BUTTON_DPAD_LEFT, SDL_GAMEPAD_BUTTON_DPAD_RIGHT, SDL_GAMEPAD_BUTTON_SOUTH, SDL_GAMEPAD_BUTTON_EAST, SDL_GAMEPAD_BUTTON_START};
     bool prologo_desbloquejat = false;
 
     void setMusic(const bool value)

source/console.cpp

@@ -1,5 +1,5 @@
 #include "console.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "jdraw.h"
 #include "jinput.h"
 #include "room.h"

source/jail_audio.cpp

@@ -1,43 +1,51 @@
 #ifndef JA_USESDLMIXER
 #include "jail_audio.h"
 #include "stb_vorbis.c"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include <stdio.h>
 
 #define JA_MAX_SIMULTANEOUS_CHANNELS 5
 
-struct JA_Sound_t {
-    Uint32  length {0};
-    Uint8*  buffer {NULL};
+struct JA_Sound_t
+{
+    SDL_AudioSpec       spec        { SDL_AUDIO_S16, 2, 48000 };
+    Uint32              length      { 0 };
+    Uint8               *buffer     { NULL };
 };
 
-struct JA_Channel_t {
-    JA_Sound_t          *sound;
-    int                 pos {0};
-    int                 times {0};
-    JA_Channel_state    state { JA_CHANNEL_FREE };
+struct JA_Channel_t
+{
+    JA_Sound_t          *sound      { nullptr };
+    int                 pos         { 0 };
+    int                 times       { 0 };
+    SDL_AudioStream     *stream     { nullptr };
+    JA_Channel_state    state       { JA_CHANNEL_FREE };
 };
 
-struct JA_Music_t {
-    int             samples {0};
-    int             pos {0};
-    int             times {0};
-    short*          output {NULL};
-    JA_Music_state  state {JA_MUSIC_INVALID};
+struct JA_Music_t
+{
+    SDL_AudioSpec       spec        { SDL_AUDIO_S16, 2, 48000 };
+    Uint32              length      { 0 };
+    Uint8               *buffer     { nullptr };
+
+    int                 pos         { 0 };
+    int                 times       { 0 };
+    SDL_AudioStream     *stream     { nullptr };
+    JA_Music_state      state       { JA_MUSIC_INVALID };
 };
 
-JA_Music_t      *current_music{NULL};
-JA_Channel_t    channels[JA_MAX_SIMULTANEOUS_CHANNELS];
+JA_Music_t          *current_music  { nullptr };
+JA_Channel_t        channels[JA_MAX_SIMULTANEOUS_CHANNELS];
 
-int             JA_freq {48000};
-SDL_AudioFormat JA_format {AUDIO_S16};
-Uint8           JA_channels {2};
-int             JA_musicVolume = 128;
-int             JA_soundVolume = 64;
-bool            JA_musicEnabled = true;
-bool            JA_soundEnabled = true;
-SDL_AudioDeviceID sdlAudioDevice = 0;
+SDL_AudioSpec       JA_audioSpec    { SDL_AUDIO_S16, 2, 48000 };
+float               JA_musicVolume  { 1.0f };
+float               JA_soundVolume  { 0.5f };
+bool                JA_musicEnabled { true };
+bool                JA_soundEnabled { true };
+SDL_AudioDeviceID   sdlAudioDevice  { 0 };
+SDL_TimerID         JA_timerID      { 0 };
 
+/*
 void audioCallback(void * userdata, uint8_t * stream, int len) {
     SDL_memset(stream, 0, len);
     if (current_music != NULL && current_music->state == JA_MUSIC_PLAYING) {
@@ -73,42 +81,77 @@ void audioCallback(void * userdata, uint8_t * stream, int len) {
         }
     }
 }
+*/
 
-void JA_Init(const int freq, const SDL_AudioFormat format, const int channels) {
-    JA_freq = freq;
-    JA_format = format;
-    JA_channels = channels;
-    SDL_AudioSpec audioSpec{JA_freq, JA_format, JA_channels, 0, 1024, 0, 0, audioCallback, NULL};
-    if (sdlAudioDevice != 0) SDL_CloseAudioDevice(sdlAudioDevice);
-    sdlAudioDevice = SDL_OpenAudioDevice(NULL, 0, &audioSpec, NULL, 0);
-    SDL_PauseAudioDevice(sdlAudioDevice, 0);
+Uint32 JA_UpdateCallback(void *userdata, SDL_TimerID timerID, Uint32 interval)
+{
+    if (JA_musicEnabled && current_music && current_music->state == JA_MUSIC_PLAYING)
+    {
+        if (current_music->times != 0)
+        {
+            if (SDL_GetAudioStreamAvailable(current_music->stream) < (current_music->length/2))
+                SDL_PutAudioStreamData(current_music->stream, current_music->buffer, current_music->length);
+            if (current_music->times>0) current_music->times--;
+        }
+        else
+        {
+            if (SDL_GetAudioStreamAvailable(current_music->stream) == 0) JA_StopMusic();
+        }
+    }
+
+    if (JA_soundEnabled)
+    {
+        for (int i=0; i < JA_MAX_SIMULTANEOUS_CHANNELS; ++i)
+            if (channels[i].state == JA_CHANNEL_PLAYING)
+            {
+                if (channels[i].times != 0)
+                {
+                    if (SDL_GetAudioStreamAvailable(channels[i].stream) < (channels[i].sound->length/2))
+                        SDL_PutAudioStreamData(channels[i].stream, channels[i].sound->buffer, channels[i].sound->length);
+                    if (channels[i].times>0) channels[i].times--;
+                }
+            }
+            else
+            {
+                if (SDL_GetAudioStreamAvailable(channels[i].stream) == 0) JA_StopChannel(i);
+            }
+
+    }
+
+    return 30;
 }
 
-void JA_Quit() {
-    SDL_PauseAudioDevice(sdlAudioDevice, 1);
-    if (sdlAudioDevice != 0) SDL_CloseAudioDevice(sdlAudioDevice);
+void JA_Init(const int freq, const SDL_AudioFormat format, const int channels)
+{
+    JA_audioSpec = {format, channels, freq };
+    if (!sdlAudioDevice) SDL_CloseAudioDevice(sdlAudioDevice);
+    sdlAudioDevice = SDL_OpenAudioDevice(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &JA_audioSpec);
+    SDL_PauseAudioDevice(sdlAudioDevice);
+    JA_timerID = SDL_AddTimer(30, JA_UpdateCallback, nullptr);
+}
+
+void JA_Quit()
+{
+    if (JA_timerID) SDL_RemoveTimer(JA_timerID);
+
+    if (!sdlAudioDevice) SDL_CloseAudioDevice(sdlAudioDevice);
     sdlAudioDevice = 0;
 }
 
 JA_Music_t *JA_LoadMusic(Uint8* buffer, Uint32 length)
 {
-    int chan, samplerate;
     JA_Music_t *music = new JA_Music_t();
 
-    music->samples = stb_vorbis_decode_memory(buffer, length, &chan, &samplerate, &music->output);
-    // [RZC 28/08/22] Abans el descomprimiem mentre el teniem obert
-//    music->samples = stb_vorbis_decode_filename(filename, &chan, &samplerate, &music->output);
+    int chan, samplerate;
+    short *output;
+    music->length = stb_vorbis_decode_memory(buffer, length, &chan, &samplerate, &output) * chan * 2;
 
-    SDL_AudioCVT cvt;
-    SDL_BuildAudioCVT(&cvt, AUDIO_S16, chan, samplerate, JA_format, JA_channels, JA_freq);
-    if (cvt.needed) {
-        cvt.len = music->samples * chan * 2;
-        cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
-        SDL_memcpy(cvt.buf, music->output, cvt.len);
-        SDL_ConvertAudio(&cvt);
-        free(music->output);
-        music->output = (short*)cvt.buf;
-    }
+    music->spec.channels = chan;
+    music->spec.freq = samplerate;
+    music->spec.format = SDL_AUDIO_S16;
+    music->buffer = (Uint8*)SDL_malloc(music->length);
+    SDL_memcpy(music->buffer, output, music->length);
+    SDL_free(output);
     music->pos = 0;
     music->state = JA_MUSIC_STOPPED;
 
@@ -145,55 +188,69 @@ void JA_PlayMusic(JA_Music_t *music, const int loop)
     current_music->pos = 0;
     current_music->state = JA_MUSIC_PLAYING;
     current_music->times = loop;
+
+    current_music->stream = SDL_CreateAudioStream(&current_music->spec, &JA_audioSpec);
+    if (!SDL_PutAudioStreamData(current_music->stream, current_music->buffer, current_music->length)) printf("[ERROR] SDL_PutAudioStreamData failed!\n");
+    SDL_SetAudioStreamGain(current_music->stream, JA_musicVolume);
+    if (!SDL_BindAudioStream(sdlAudioDevice, current_music->stream)) printf("[ERROR] SDL_BindAudioStream failed!\n");
 }
 
 void JA_PauseMusic()
 {
     if (!JA_musicEnabled) return;
+    if (!current_music || current_music->state == JA_MUSIC_INVALID) return;
 
-    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
     current_music->state = JA_MUSIC_PAUSED;
+    SDL_PauseAudioStreamDevice(current_music->stream);
 }
 
 void JA_ResumeMusic()
 {
     if (!JA_musicEnabled) return;
+    if (!current_music || current_music->state == JA_MUSIC_INVALID) return;
 
-    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
     current_music->state = JA_MUSIC_PLAYING;
+    SDL_ResumeAudioStreamDevice(current_music->stream);
 }
 
 void JA_StopMusic()
 {
     if (!JA_musicEnabled) return;
+    if (!current_music || current_music->state == JA_MUSIC_INVALID) return;
 
-    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
     current_music->pos = 0;
     current_music->state = JA_MUSIC_STOPPED;
+    SDL_PauseAudioStreamDevice(current_music->stream);
+    SDL_DestroyAudioStream(current_music->stream);
+    current_music->stream = nullptr;
 }
 
-JA_Music_state JA_GetMusicState() {
+JA_Music_state JA_GetMusicState()
+{
     if (!JA_musicEnabled) return JA_MUSIC_DISABLED;
+    if (!current_music) return JA_MUSIC_INVALID;
 
-    if (current_music == NULL) return JA_MUSIC_INVALID;
     return current_music->state;
 }
 
-void JA_DeleteMusic(JA_Music_t *music) {
-    if (current_music == music) current_music = NULL;
-    free(music->output);
+void JA_DeleteMusic(JA_Music_t *music)
+{
+    if (current_music == music) current_music = nullptr;
+    SDL_free(music->buffer);
+    SDL_DestroyAudioStream(music->stream);
     delete music;
 }
 
-int JA_SetMusicVolume(int volume)
+float JA_SetMusicVolume(float volume)
 {
-    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
+    JA_musicVolume = SDL_clamp( volume, 0.0f, 1.0f );
+    if (current_music) SDL_SetAudioStreamGain(current_music->stream, JA_musicVolume);
     return JA_musicVolume;
 }
 
 void JA_EnableMusic(const bool value)
 {
-    if (!value && current_music != NULL && current_music->state==JA_MUSIC_PLAYING) JA_StopMusic();
+    if ( !value && current_music && (current_music->state==JA_MUSIC_PLAYING) ) JA_StopMusic();
 
     JA_musicEnabled = value;
 }
@@ -202,45 +259,26 @@ void JA_EnableMusic(const bool value)
 
 
 
-JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length) {
+JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length)
+{
     JA_Sound_t *sound = new JA_Sound_t();
     sound->buffer = buffer;
     sound->length = length;
     return sound;
 }
 
-JA_Sound_t *JA_LoadSound(uint8_t* buffer, uint32_t size) {
+JA_Sound_t *JA_LoadSound(uint8_t* buffer, uint32_t size)
+{
     JA_Sound_t *sound = new JA_Sound_t();
-    SDL_AudioSpec wavSpec;
-    SDL_LoadWAV_RW(SDL_RWFromMem(buffer, size),1, &wavSpec, &sound->buffer, &sound->length);
-    
-    SDL_AudioCVT cvt;
-    SDL_BuildAudioCVT(&cvt, wavSpec.format, wavSpec.channels, wavSpec.freq, JA_format, JA_channels, JA_freq);
-    cvt.len = sound->length;
-    cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
-    SDL_memcpy(cvt.buf, sound->buffer, sound->length);
-    SDL_ConvertAudio(&cvt);
-    SDL_FreeWAV(sound->buffer);
-    sound->buffer = cvt.buf;
-    sound->length = cvt.len_cvt;
+    SDL_LoadWAV_IO(SDL_IOFromMem(buffer, size),1, &sound->spec, &sound->buffer, &sound->length);
 
     return sound;
 }
 
-JA_Sound_t *JA_LoadSound(const char* filename) {
+JA_Sound_t *JA_LoadSound(const char* filename)
+{
     JA_Sound_t *sound = new JA_Sound_t();
-    SDL_AudioSpec wavSpec;
-    SDL_LoadWAV(filename, &wavSpec, &sound->buffer, &sound->length);
-
-    SDL_AudioCVT cvt;
-    SDL_BuildAudioCVT(&cvt, wavSpec.format, wavSpec.channels, wavSpec.freq, JA_format, JA_channels, JA_freq);
-    cvt.len = sound->length;
-    cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
-    SDL_memcpy(cvt.buf, sound->buffer, sound->length);
-    SDL_ConvertAudio(&cvt);
-    SDL_FreeWAV(sound->buffer);
-    sound->buffer = cvt.buf;
-    sound->length = cvt.len_cvt;
+    SDL_LoadWAV(filename, &sound->spec, &sound->buffer, &sound->length);
 
     return sound;
 }
@@ -257,6 +295,11 @@ int JA_PlaySound(JA_Sound_t *sound, const int loop)
     channels[channel].times = loop;
     channels[channel].pos = 0;
     channels[channel].state = JA_CHANNEL_PLAYING;
+    channels[channel].stream = SDL_CreateAudioStream(&channels[channel].sound->spec, &JA_audioSpec);
+    SDL_PutAudioStreamData(channels[channel].stream, channels[channel].sound->buffer, channels[channel].sound->length);
+    SDL_SetAudioStreamGain(channels[channel].stream, JA_soundVolume);
+    SDL_BindAudioStream(sdlAudioDevice, channels[channel].stream);
+
     return channel;
 }
 
@@ -273,12 +316,22 @@ void JA_PauseChannel(const int channel)
 {
     if (!JA_soundEnabled) return;
 
-    if (channel == -1) {
-        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-            if (channels[i].state == JA_CHANNEL_PLAYING) channels[i].state = JA_CHANNEL_PAUSED;
+    if (channel == -1)
+    {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+            if (channels[i].state == JA_CHANNEL_PLAYING)
+            {
+                channels[i].state = JA_CHANNEL_PAUSED;
+                SDL_PauseAudioStreamDevice(channels[i].stream);
+            }
+    }
+    else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS)
+    {
+        if (channels[channel].state == JA_CHANNEL_PLAYING)
+        {
+            channels[channel].state = JA_CHANNEL_PAUSED;
+            SDL_PauseAudioStreamDevice(channels[channel].stream);
         }
-    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
-        if (channels[channel].state == JA_CHANNEL_PLAYING) channels[channel].state = JA_CHANNEL_PAUSED;
     }
 }
 
@@ -286,12 +339,22 @@ void JA_ResumeChannel(const int channel)
 {
     if (!JA_soundEnabled) return;
 
-    if (channel == -1) {
-        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-            if (channels[i].state == JA_CHANNEL_PAUSED) channels[i].state = JA_CHANNEL_PLAYING;
+    if (channel == -1)
+    {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+            if (channels[i].state == JA_CHANNEL_PAUSED)
+            {
+                channels[i].state = JA_CHANNEL_PLAYING;
+                SDL_ResumeAudioStreamDevice(channels[i].stream);
+            }
+    }
+    else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS)
+    {
+        if (channels[channel].state == JA_CHANNEL_PAUSED)
+        {
+            channels[channel].state = JA_CHANNEL_PLAYING;
+            SDL_ResumeAudioStreamDevice(channels[channel].stream);
         }
-    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
-        if (channels[channel].state == JA_CHANNEL_PAUSED) channels[channel].state = JA_CHANNEL_PLAYING;
     }
 }
 
@@ -299,16 +362,21 @@ void JA_StopChannel(const int channel)
 {
     if (!JA_soundEnabled) return;
 
-    if (channel == -1) {
+    if (channel == -1)
+    {
         for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
             channels[i].state = JA_CHANNEL_FREE;
             channels[i].pos = 0;
             channels[i].sound = NULL;
+            SDL_DestroyAudioStream(channels[i].stream);
         }
-    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
+    }
+    else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS)
+    {
         channels[channel].state = JA_CHANNEL_FREE;
         channels[channel].pos = 0;
         channels[channel].sound = NULL;
+        SDL_DestroyAudioStream(channels[channel].stream);
     }
 }
 
@@ -317,12 +385,18 @@ JA_Channel_state JA_GetChannelState(const int channel)
     if (!JA_soundEnabled) return JA_SOUND_DISABLED;
 
     if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return JA_CHANNEL_INVALID;
+
     return channels[channel].state;
 }
 
-int JA_SetSoundVolume(int volume)
+float JA_SetSoundVolume(float volume)
 {
-    JA_soundVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
+    JA_soundVolume = SDL_clamp( volume, 0.0f, 1.0f );
+
+    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+        if ( (channels[i].state == JA_CHANNEL_PLAYING) || (channels[i].state == JA_CHANNEL_PAUSED) )
+            SDL_SetAudioStreamGain(channels[i].stream, JA_soundVolume);
+
     return JA_soundVolume;
 }
 
@@ -335,10 +409,10 @@ void JA_EnableSound(const bool value)
     JA_soundEnabled = value;
 }
 
-int JA_SetVolume(int volume)
+float JA_SetVolume(float volume)
 {
-    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
-    JA_soundVolume = JA_musicVolume/2;
+    JA_SetSoundVolume(JA_SetMusicVolume(volume) / 2.0f);
+
     return JA_musicVolume;
 }
 

source/jail_audio.h

@@ -1,5 +1,5 @@
 #pragma once
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 
 enum JA_Channel_state { JA_CHANNEL_INVALID, JA_CHANNEL_FREE, JA_CHANNEL_PLAYING, JA_CHANNEL_PAUSED, JA_SOUND_DISABLED };
 enum JA_Music_state { JA_MUSIC_INVALID, JA_MUSIC_PLAYING, JA_MUSIC_PAUSED, JA_MUSIC_STOPPED, JA_MUSIC_DISABLED };
@@ -18,7 +18,7 @@ void JA_ResumeMusic();
 void JA_StopMusic();
 JA_Music_state JA_GetMusicState();
 void JA_DeleteMusic(JA_Music_t *music);
-int JA_SetMusicVolume(int volume);
+float JA_SetMusicVolume(float volume);
 void JA_EnableMusic(const bool value);
 
 JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length);
@@ -30,7 +30,7 @@ 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_t *sound);
-int JA_SetSoundVolume(int volume);
+float JA_SetSoundVolume(float volume);
 void JA_EnableSound(const bool value);
 
-int JA_SetVolume(int volume);
+float JA_SetVolume(float volume);

source/jaudio.cpp

@@ -1,6 +1,6 @@
 #include "jaudio.h"
 #include "jail_audio.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include <stdio.h>
 #include "jfile.h"
 #include <vector>
@@ -22,7 +22,7 @@ namespace audio
     // Inicialitza el sistema de só
     void init()
     {
-        JA_Init(48000, AUDIO_S16, 2);
+        JA_Init(48000, SDL_AUDIO_S16LE, 2);
         //Mix_Init(MIX_INIT_OGG);// | MIX_INIT_WAVPACK);
         //Mix_OpenAudio(48000, AUDIO_S16, 2, 512);
     }

source/jdraw.cpp

@@ -1,5 +1,5 @@
 #include "jdraw.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "gif.c"
 #include "jfile.h"
 #include <vector>
@@ -15,7 +15,7 @@ namespace draw
     SDL_Renderer *sdl_renderer = nullptr; // El renderer de SDL
     SDL_Texture *sdl_texture = nullptr;   // La textura de SDL a la que pintarem la nostra superficie "screen" i que despres volcarem a pantalla
 
-    SDL_Rect dest_rect = {0, 0, 320, 240};
+    SDL_FRect dest_rect = {0, 0, 320, 240};
     static int fullscreen_scale = 1;
 
     static int screen_zoom = 1;
@@ -89,23 +89,22 @@ namespace draw
         // [TODO] Incloure gestió de pantalla completa
 
         // Inicialització de les estructures de SDL
-        sdl_window = SDL_CreateWindow(screen_title.c_str(), SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, screen_width * screen_zoom, screen_height * screen_zoom, screen_fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : SDL_WINDOW_SHOWN);
-        sdl_renderer = SDL_CreateRenderer(sdl_window, -1, 0);
+        sdl_window = SDL_CreateWindow(screen_title.c_str(), screen_width * screen_zoom, screen_height * screen_zoom, screen_fullscreen ? SDL_WINDOW_FULLSCREEN : 0);
+        sdl_renderer = SDL_CreateRenderer(sdl_window, nullptr);
         sdl_texture = SDL_CreateTexture(sdl_renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, screen_width, screen_height);
 
-        SDL_RendererInfo info;
+        char *driver_name;
         const int num_render_drivers = SDL_GetNumRenderDrivers();
         printf("Available renderers:\n");
         for (int i=0; i<num_render_drivers; ++i)
         {
-            SDL_GetRenderDriverInfo(i, &info);
-            printf(" - %i: %s\n", i, info.name);
+            SDL_GetRenderDriver(i);
+            printf(" - %i: %s\n", i, driver_name);
         }
 
-        SDL_GetRendererInfo(sdl_renderer, &info);
-        printf("\nRenderer: %s\n", info.name);
+        printf("\nRenderer: %s\n", SDL_GetRendererName(sdl_renderer));
 
-        SDL_ShowCursor(false);
+        SDL_HideCursor();
         
         if (screen_fullscreen)        
         {
@@ -183,11 +182,11 @@ namespace draw
         SDL_DestroyWindow(sdl_window);
 
         const int zoom = screen_fullscreen ? 1 : screen_zoom;
-        sdl_window = SDL_CreateWindow(screen_title.c_str(), SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, screen_width * zoom, screen_height * zoom, screen_fullscreen?SDL_WINDOW_FULLSCREEN_DESKTOP:SDL_WINDOW_SHOWN);
-        sdl_renderer = SDL_CreateRenderer(sdl_window, -1, 0);
+        sdl_window = SDL_CreateWindow(screen_title.c_str(), screen_width * zoom, screen_height * zoom, screen_fullscreen?SDL_WINDOW_FULLSCREEN:0);
+        sdl_renderer = SDL_CreateRenderer(sdl_window, nullptr);
         sdl_texture = SDL_CreateTexture(sdl_renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, screen_width, screen_height);
 
-        SDL_ShowCursor(false);
+        SDL_HideCursor();
 
         if (screen_fullscreen)        
         {
@@ -213,12 +212,10 @@ namespace draw
     void setZoom(const int value)
     {
         if (value < 1) return;
+        const SDL_DisplayMode *dm = SDL_GetCurrentDisplayMode(SDL_GetDisplayForWindow(sdl_window));
 
-        SDL_DisplayMode dm;
-        SDL_GetCurrentDisplayMode(0, &dm);
-
-        if (screen_width*value > dm.w) return;
-        if (screen_height*value > dm.h) return;
+        if (screen_width*value > dm->w) return;
+        if (screen_height*value > dm->h) return;
 
         screen_zoom = value;
         reinit();
@@ -707,7 +704,7 @@ namespace draw
         }
 
         // Pintem la textura a pantalla
-        SDL_RenderCopy(sdl_renderer, sdl_texture, NULL, &dest_rect);
+        SDL_RenderTexture(sdl_renderer, sdl_texture, NULL, &dest_rect);
 
         if (screen_mode & SCREEN_MODE_SCANLINES)
         {
@@ -718,14 +715,14 @@ namespace draw
                 for (int y=0; y<screen_height; ++y)
                 {
                     SDL_SetRenderDrawColor(sdl_renderer, 0, 0, 0, 192);
-                    SDL_RenderDrawLine(sdl_renderer, dest_rect.x, dest_rect.y + y*zoom, dest_rect.x + dest_rect.w, dest_rect.y + y*zoom);
+                    SDL_RenderLine(sdl_renderer, dest_rect.x, dest_rect.y + y*zoom, dest_rect.x + dest_rect.w, dest_rect.y + y*zoom);
                     SDL_SetRenderDrawColor(sdl_renderer, 0, 0, 0, 96);
-                    if (zoom>3) SDL_RenderDrawLine(sdl_renderer, dest_rect.x, 1+dest_rect.y + y*zoom, dest_rect.x + dest_rect.w, 1+dest_rect.y + y*zoom);
+                    if (zoom>3) SDL_RenderLine(sdl_renderer, dest_rect.x, 1+dest_rect.y + y*zoom, dest_rect.x + dest_rect.w, 1+dest_rect.y + y*zoom);
                 }
                 SDL_SetRenderDrawColor(sdl_renderer, 0, 0, 0, 16);
                 for (int x=0; x<screen_width; ++x)
                 {
-                    SDL_RenderDrawLine(sdl_renderer, dest_rect.x + x*zoom, dest_rect.y, dest_rect.x + x*zoom, dest_rect.y + dest_rect.h);
+                    SDL_RenderLine(sdl_renderer, dest_rect.x + x*zoom, dest_rect.y, dest_rect.x + x*zoom, dest_rect.y + dest_rect.h);
                 }
             }
         }

source/jgame.cpp

@@ -2,7 +2,7 @@
 #include "jdraw.h"
 #include "jinput.h"
 #include "jaudio.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 
 namespace game
 {
@@ -34,7 +34,7 @@ int main(int argc, char *argv[])
     game::param_count = argc;
     game::params = argv;
 
-    SDL_Init(SDL_INIT_EVERYTHING);
+    SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_GAMEPAD);
     
     input::init();
     audio::init();
@@ -47,26 +47,26 @@ int main(int argc, char *argv[])
     {
         while(SDL_PollEvent(&e))
         {
-            if (e.type==SDL_QUIT) { game::should_exit = true; break; }
-            if (e.type==SDL_KEYDOWN)
+            if (e.type==SDL_EVENT_QUIT) { game::should_exit = true; break; }
+            if (e.type==SDL_EVENT_KEY_DOWN)
             {
-                input::updateKey(e.key.keysym.scancode);
+                input::updateKey(e.key.scancode);
             }
-            if (e.type==SDL_KEYUP)
+            if (e.type==SDL_EVENT_KEY_UP)
             {
-                input::updateKeypressed(e.key.keysym.scancode);
+                input::updateKeypressed(e.key.scancode);
             }
-            if (e.type==SDL_MOUSEBUTTONUP)
+            if (e.type==SDL_EVENT_MOUSE_BUTTON_UP)
             {
                 input::updateClk(e.button.button);
             }
-            if (e.type==SDL_MOUSEWHEEL)
+            if (e.type==SDL_EVENT_MOUSE_WHEEL)
             {
                 input::updateWheel(e.wheel.y);
             }
-            if (e.type==SDL_CONTROLLERBUTTONDOWN) {
-                input::updatePadBtn(e.cbutton.button);
-                input::updatePadBtnPressed(e.cbutton.button);
+            if (e.type==SDL_EVENT_GAMEPAD_BUTTON_DOWN) {
+                input::updatePadBtn(e.gbutton.button);
+                input::updatePadBtnPressed(e.gbutton.button);
             }
         }
 
@@ -78,8 +78,8 @@ int main(int argc, char *argv[])
             input::updateKeypressed(SDL_SCANCODE_UNKNOWN);
             input::updateClk(0);
             input::updateWheel(0);
-            input::updatePadBtn(SDL_CONTROLLER_BUTTON_INVALID);
-            input::updatePadBtnPressed(SDL_CONTROLLER_BUTTON_INVALID);
+            input::updatePadBtn(SDL_GAMEPAD_BUTTON_INVALID);
+            input::updatePadBtnPressed(SDL_GAMEPAD_BUTTON_INVALID);
         }
     }
 

source/jinput.cpp

@@ -1,31 +1,40 @@
 #include "jinput.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "jdraw.h"
 #include "jfile.h"
 
 namespace input
 {
-    static const uint8_t *keys = nullptr;
+    static const bool *keys = nullptr;
     static uint8_t keypressed = 0;
     static uint8_t keydown = 0;
     static uint8_t btnClicked = 0;
     static int wheel = 0;
-    static SDL_GameController *gamepad = NULL;
-    static int8_t pad_btn_pressed = SDL_CONTROLLER_BUTTON_INVALID;
-    static int8_t pad_btn_down = SDL_CONTROLLER_BUTTON_INVALID;
+    static SDL_Gamepad *gamepad = NULL;
+    static int8_t pad_btn_pressed = SDL_GAMEPAD_BUTTON_INVALID;
+    static int8_t pad_btn_down = SDL_GAMEPAD_BUTTON_INVALID;
 
     void initGamePad()
     {
         int size;
         char *buffer = file::getFileBuffer("gamecontrollerdb.txt", size);
-        if (SDL_GameControllerAddMappingsFromRW(SDL_RWFromMem(buffer, size), 1) < 0) printf("No s'ha pogut carregar el gamecontrollersdb.txt\n");
+        if (SDL_AddGamepadMappingsFromIO(SDL_IOFromMem(buffer, size), 1) < 0) printf("No s'ha pogut carregar el gamecontrollersdb.txt\n");
         free(buffer);
 
+        int num_gamepads;
+        SDL_JoystickID *gamepads = SDL_GetGamepads(&num_gamepads);
+        if (num_gamepads>0)
+        {
+            gamepad = SDL_OpenGamepad(gamepads[0]);
+            SDL_SetGamepadEventsEnabled(true);
+            SDL_free(gamepads);
+        }
+/*
         const int num_joysticks = SDL_NumJoysticks();
         if (num_joysticks>=1) {
             for (int i=0; i<num_joysticks; ++i) {
                 if (SDL_IsGameController(i)) {
-                    gamepad = SDL_GameControllerOpen(i);
+                    gamepad = SDL_OpenGamepad() GameControllerOpen(i);
                     if (SDL_GameControllerGetAttached(gamepad) == SDL_TRUE) {
                         SDL_GameControllerEventState(SDL_ENABLE);
                         return;
@@ -33,6 +42,7 @@ namespace input
                 }
             }
         }
+*/
     }
 
     void init()
@@ -76,7 +86,7 @@ namespace input
     bool padBtnDown(const int8_t btn)
     {
         if (!gamepad) return false;
-        return SDL_GameControllerGetButton(gamepad, SDL_GameControllerButton(btn)) == 1;
+        return SDL_GetGamepadButton(gamepad, SDL_GamepadButton(btn)) == 1;
     }
 
     // Determina si el botó del pad especificat ha sigut polsat, pero no tornarà a ser true fins
@@ -88,7 +98,7 @@ namespace input
     // Determina si hi ha algun botó del pad polsat ara mateix
     bool anyPadBtn()
     {
-        return pad_btn_down != SDL_CONTROLLER_BUTTON_INVALID;
+        return pad_btn_down != SDL_GAMEPAD_BUTTON_INVALID;
     }
 
     // Torna el codi del botó del pad que està sent polsat ara mateix
@@ -144,7 +154,7 @@ namespace input
     // Torna la posició X actual del ratolí
     const int mouseX()
     {
-        int x;
+        float x;
         SDL_GetMouseState(&x, NULL);
         return x/draw::getZoom();
     }
@@ -152,7 +162,7 @@ namespace input
     // Torna la posició Y actual del ratolí
     const int mouseY()
     {
-        int y;
+        float y;
         SDL_GetMouseState(NULL, &y);
         return y/draw::getZoom();
     }
@@ -160,7 +170,7 @@ namespace input
     // Determina si el botó del ratolí especificat està sent polsada ara mateix
     const bool mouseBtn(const int btn)
     {
-        return (SDL_GetMouseState(NULL, NULL) & SDL_BUTTON(btn));
+        return (SDL_GetMouseState(NULL, NULL) & SDL_BUTTON_MASK(btn));
     }
 
     // Determina si el botó especificat ha sigut polsat, pero no tornarà a ser true fins

source/jui.cpp

@@ -2,7 +2,7 @@
 #include "jdraw.h"
 #include "jinput.h"
 #include <string.h>
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 
 namespace ui
 {

source/jutil.cpp

@@ -1,7 +1,7 @@
 #include "jutil.h"
 #include <string.h>
 #include <ctype.h>
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 namespace util
 {
     int stringToInt(const char *value, std::vector<const char*> strings, std::vector<int> values)

source/m_catslife.cpp

@@ -6,7 +6,7 @@
 #include "actor.h"
 #include "room.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 
 namespace modules
 {

source/m_editor_bitmap.cpp

@@ -1,7 +1,7 @@
 #include "m_editor_bitmap.h"
 #include "jdraw.h"
 #include "jinput.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "room.h"
 #include "actor.h"
 #include "m_game.h"

source/m_editor_bitmap_file.cpp

@@ -2,7 +2,7 @@
 #include "jdraw.h"
 #include "jinput.h"
 #include "jfile.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "room.h"
 #include "actor.h"
 #include "m_game.h"

source/m_editor_colors.cpp

@@ -1,7 +1,7 @@
 #include "m_editor_colors.h"
 #include "jdraw.h"
 #include "jinput.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "room.h"
 
 namespace modules

source/m_editor_map.cpp

@@ -2,7 +2,7 @@
 #include "jdraw.h"
 #include "jinput.h"
 #include "misc.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "room.h"
 #include "actor.h"
 

source/m_editor_templates.cpp

@@ -2,7 +2,7 @@
 #include "jdraw.h"
 #include "jinput.h"
 #include "misc.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "actor.h"
 #include <vector>
 #include "room.h"

source/m_end_prologo_sequence.cpp

@@ -5,7 +5,7 @@
 #include "jaudio.h"
 #include "controller.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "actor.h"
 
 namespace modules

source/m_end_sequence.cpp

@@ -5,7 +5,7 @@
 #include "jaudio.h"
 #include "controller.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "actor.h"
 
 namespace modules

source/m_gameover.cpp

@@ -6,7 +6,7 @@
 #include "actor.h"
 #include "room.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 
 namespace modules
 {

source/m_ingame.cpp

@@ -7,7 +7,7 @@
 #include "actor.h"
 #include "room.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 
 namespace modules
 {

source/m_intro.cpp

@@ -4,7 +4,7 @@
 #include "jaudio.h"
 #include "controller.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "actor.h"
 
 namespace modules

source/m_logo.cpp

@@ -4,7 +4,8 @@
 #include "controller.h"
 #include "jaudio.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
+#include <math.h>
 
 namespace modules
 {

source/m_menu.cpp

@@ -4,7 +4,7 @@
 #include "controller.h"
 #include "jdraw.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "jaudio.h"
 #include "actor.h"
 namespace modules
@@ -120,7 +120,7 @@ namespace modules
             //draw::print2(input::getPadBtnPressed(), 3, 0, 24, RED, FONT_ZOOM_NONE);
 
             draw::print2("(C) JAILDOCTOR 2024", 11, 28, TEAL, FONT_ZOOM_NONE);
-            draw::print2("v1.5", 36, 28, WHITE, FONT_ZOOM_NONE);
+            draw::print("v1.5b", 299, 233, WHITE, PAPER);
 
             draw::render();
             return OPTION_NONE;

source/m_menu_audio.cpp

@@ -4,7 +4,7 @@
 #include "controller.h"
 #include "jdraw.h"
 #include "jaudio.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "config.h"
 
 namespace modules

source/m_menu_gamepad.cpp

@@ -4,7 +4,7 @@
 #include "jaudio.h"
 #include "controller.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 
 namespace modules
 {
@@ -57,7 +57,7 @@ namespace modules
                 }
             } else {
                 const int8_t btn = input::getPadBtnPressed();
-                if (btn != SDL_CONTROLLER_BUTTON_INVALID) {
+                if (btn != SDL_GAMEPAD_BUTTON_INVALID) {
                     config::definePadBtn(selected_option, btn);
                     selected_option++;
                     if (selected_option==6) state = STATE_SELECTING;

source/m_menu_tecles.cpp

@@ -4,7 +4,7 @@
 #include "jaudio.h"
 #include "controller.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 
 namespace modules
 {

source/m_prologo_intro.cpp

@@ -4,7 +4,7 @@
 #include "jaudio.h"
 #include "controller.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "actor.h"
 
 namespace modules

source/main.cpp

@@ -7,7 +7,7 @@
 #include "console.h"
 #include <string.h>
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 
 #include "actor.h"
 #include "room.h"
@@ -106,7 +106,7 @@ void game::init()
 
     if (editor::isDevMode()) {
         draw::init("The Pool", 520, 240, zoom);
-        SDL_ShowCursor(true);
+        SDL_ShowCursor();
     } else {
         loadConfig();
         draw::init("The Pool", 320, 240, zoom, fullscreen);