mpo/VVVVVV
1
0
Fork 0
mirror of https://github.com/TerryCavanagh/VVVVVV.git synced 2024-12-23 01:59:43 +01:00
Code Issues Releases Wiki Activity
VVVVVV/desktop_version/src/Music.cpp

1319 lines
35 KiB
C++
Raw Normal View History

Clean up and prevent unnecessary qualifiers to self By "unnecessary qualifiers to self", I mean something like using the 'game.' qualifier for a variable on the Game class when you're inside a function on the Game class itself. This patch is to enforce consistency as most of the code doesn't have these unnecessary qualifiers. To prevent further unnecessary qualifiers to self, I made it so the extern in each header file can be omitted by using a define. That way, if someone writes something referring to 'game.' on a Game function, there will be a compile error. However, if you really need to have a reference to the global name, and you're within the same .cpp file as the implementation of that object, you can just do the extern at the function-level. A good example of this is editorinput()/editorrender()/editorlogic() in editor.cpp. In my opinion, they should probably be split off into their own separate file because editor.cpp is getting way too big, but this will do for now.
2020-09-28 04:15:06 +02:00
#define MUSIC_DEFINITION
Separate includes into sections and alphabetize them Okay, so basically here's the include layout that this game now consistently uses: [The "main" header file, if any (e.g. Graphics.h for Graphics.cpp)] [blank line] [All system includes, such as tinyxml2/physfs/utfcpp/SDL] [blank line] [All project includes, such as Game.h/Entity.h/etc.] And if applicable, another blank line, and then some special-case include screwy stuff (take a look at editor.cpp or FileSystemUtils.cpp, for example, they have ifdefs and defines with their includes).
2020-07-19 21:43:29 +02:00
#include "Music.h"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#include <SDL.h>
Port to FAudio
2022-03-09 22:35:29 +01:00
#include <FAudio.h>
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
#include <physfsrwops.h>
Separate includes into sections and alphabetize them Okay, so basically here's the include layout that this game now consistently uses: [The "main" header file, if any (e.g. Graphics.h for Graphics.cpp)] [blank line] [All system includes, such as tinyxml2/physfs/utfcpp/SDL] [blank line] [All project includes, such as Game.h/Entity.h/etc.] And if applicable, another blank line, and then some special-case include screwy stuff (take a look at editor.cpp or FileSystemUtils.cpp, for example, they have ifdefs and defines with their includes).
2020-07-19 21:43:29 +02:00
Replace all free calls with `VVV_free[func]` This replaces all calls to SDL_free with a new macro, VVV_free, that nulls the pointer afterwards. This mitigates any use-after-frees and also completely eliminates double-frees. The same is done for any function to free specific objects such as SDL_FreeSurface, with the VVV_freefunc macro. No exceptions for any of these calls, even if the pointer is discarded or zeroed afterwards anyway. Better safe than sorry. This is a macro rather than a function that takes in a pointer-to-pointer because such a function would have type issues that require casting and that's just not safe. Even though SDL_free and other SDL functions already check for NULL, the macro has a NULL check for other functions that don't. For example, FAudioVoice_DestroyVoice does not check for NULL. FILESYSTEM_freeMemory has been axed in favor of VVV_free because it functionally does the same thing except for `unsigned char*` only.
2022-12-01 07:30:16 +01:00
#include "Alloc.h"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#include "BinaryBlob.h"
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
#include "FileSystemUtils.h"
Factor fade amount calculation to separate function This makes it so to reuse this code, we don't have to copy-paste it. Additionally, I added a check for the milliseconds being 0, to avoid a division by zero. Logically and mathematically, if the fade amount is 0 milliseconds, then that means the fade should happen instantly - however, dividing by zero is undefined (both in math and in C/C++), so this check needs to be added.
2021-04-02 21:02:01 +02:00
#include "Game.h"
Replace main game music with music area map The main game used a set of copy-pasted code to set the music of each area. There WAS some redundancy built-in, but only three rooms in each direction from the entrance of a zone. Given this, it's completely possible for players to mismatch the music of the area and level. In fact, it's easy to do it even on accident, especially since 2.3 now lets you quicksave and quit during cutscenes. Just play a cutscene that has Pause music, then quicksave, quit, and reload. Also some other accidental ways that I've forgotten about. To fix this, I've done what mapclass has and made an areamap. Except for music. This map is the map of the track number of every single room, except for three special cases: -1 for do nothing and don't change music (usually because multiple different tracks can be played in this room), -2 for Tower music (needs to be track 2 or 9 depending on Flip Mode), and -3 for the start of Space Station 2 (track 1 in time trials, track 4 otherwise). I've thoroughly tested this areamap by playing through the game and entering every single room. Additionally I've also thoroughly tested all special cases (entering the Ship through the teleporter or main entrance, using the Ship's jukebox, the Tower in Flip Mode and regular mode, and the start of Space Station 2 in time trial and in regular mode). Closes #449.
2021-05-12 04:59:02 +02:00
#include "Graphics.h"
Un-fix using-PPPPPP-while-MMMMMM-present for custom levels As discussed earlier, some custom levels have taken advantage of the fact that songs 0 and 7 loop and also fade in when using PPPPPP while having an mmmmmm.vvv file present.
2020-04-04 00:37:59 +02:00
#include "Map.h"
Replace main game music with music area map The main game used a set of copy-pasted code to set the music of each area. There WAS some redundancy built-in, but only three rooms in each direction from the entrance of a zone. Given this, it's completely possible for players to mismatch the music of the area and level. In fact, it's easy to do it even on accident, especially since 2.3 now lets you quicksave and quit during cutscenes. Just play a cutscene that has Pause music, then quicksave, quit, and reload. Also some other accidental ways that I've forgotten about. To fix this, I've done what mapclass has and made an areamap. Except for music. This map is the map of the track number of every single room, except for three special cases: -1 for do nothing and don't change music (usually because multiple different tracks can be played in this room), -2 for Tower music (needs to be track 2 or 9 depending on Flip Mode), and -3 for the start of Space Station 2 (track 1 in time trials, track 4 otherwise). I've thoroughly tested this areamap by playing through the game and entering every single room. Additionally I've also thoroughly tested all special cases (entering the Ship through the teleporter or main entrance, using the Ship's jukebox, the Tower in Flip Mode and regular mode, and the start of Space Station 2 in time trial and in regular mode). Closes #449.
2021-05-12 04:59:02 +02:00
#include "Script.h"
Port to FAudio
2022-03-09 22:35:29 +01:00
#include "Unused.h"
Remove unnecessary includes from header files Including a header file inside another header file means a bunch of files are going to be unnecessarily recompiled whenever that inner header file is changed. So I minimized the amount of header files included in a header file, and only included the ones that were necessary (system includes don't count, I'm only talking about includes from within this project). Then the includes are only in the .cpp files themselves. This also minimizes problems such as a NO_CUSTOM_LEVELS build failing because some file depended on an include that got included in editor.h, which is another benefit of removing unnecessary includes from header files.
2020-07-19 21:05:41 +02:00
#include "UtilityClass.h"
Replace all print calls with vlog calls This is pretty straight-forward to do.
2021-02-24 00:21:29 +01:00
#include "Vlogging.h"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
SDL_mixer is now entirely contained in Music.cpp. This meant making the track vectors static, but that's kind of what we do with musicclass anyway? In any case, this will make the transition to FAudio MUCH less invasive.
2021-12-26 14:57:38 +01:00
#include <vector>
Port to FAudio
2022-03-09 22:35:29 +01:00
/* stb_vorbis */
#define malloc SDL_malloc
#define realloc SDL_realloc
Replace all free calls with `VVV_free[func]` This replaces all calls to SDL_free with a new macro, VVV_free, that nulls the pointer afterwards. This mitigates any use-after-frees and also completely eliminates double-frees. The same is done for any function to free specific objects such as SDL_FreeSurface, with the VVV_freefunc macro. No exceptions for any of these calls, even if the pointer is discarded or zeroed afterwards anyway. Better safe than sorry. This is a macro rather than a function that takes in a pointer-to-pointer because such a function would have type issues that require casting and that's just not safe. Even though SDL_free and other SDL functions already check for NULL, the macro has a NULL check for other functions that don't. For example, FAudioVoice_DestroyVoice does not check for NULL. FILESYSTEM_freeMemory has been axed in favor of VVV_free because it functionally does the same thing except for `unsigned char*` only.
2022-12-01 07:30:16 +01:00
#define free VVV_free
Port to FAudio
2022-03-09 22:35:29 +01:00
#ifdef memset /* Thanks, Apple! */
#undef memset
#endif
#define memset SDL_memset
#ifdef memcpy /* Thanks, Apple! */
#undef memcpy
#endif
#define memcpy SDL_memcpy
#define memcmp SDL_memcmp
#define pow SDL_pow
#define log(x) SDL_log(x)
#define sin(x) SDL_sin(x)
#define cos(x) SDL_cos(x)
#define floor SDL_floor
#define abs(x) SDL_abs(x)
#define ldexp(v, e) SDL_scalbn((v), (e))
#define exp(x) SDL_exp(x)
#define qsort SDL_qsort
#define assert SDL_assert
#define FILE SDL_RWops
#ifdef SEEK_SET
#undef SEEK_SET
#endif
#ifdef SEEK_CUR
#undef SEEK_CUR
#endif
#ifdef SEEK_END
#undef SEEK_END
#endif
#ifdef EOF
#undef EOF
#endif
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
#define EOF -1
#define fopen(path, mode) SDL_RWFromFile(path, mode)
#define fopen_s(io, path, mode) (!(*io = fopen(path, mode)))
#define fclose(io) SDL_RWclose(io)
#define fread(dst, size, count, io) SDL_RWread(io, dst, size, count)
#define fseek(io, offset, whence) SDL_RWseek(io, offset, whence)
#define ftell(io) SDL_RWtell(io)
#define FAudio_alloca(x) SDL_stack_alloc(uint8_t, x)
#define FAudio_dealloca(x) SDL_stack_free(x)
#define STB_VORBIS_NO_PUSHDATA_API 1
#define STB_VORBIS_NO_INTEGER_CONVERSION 1
#include <stb_vorbis.h>
/* End stb_vorbis include */
#define VVV_MAX_VOLUME 128
#define VVV_MAX_CHANNELS 8
class SoundTrack;
class MusicTrack;
static std::vector<SoundTrack> soundTracks;
static std::vector<MusicTrack> musicTracks;
static FAudio* faudioctx = NULL;
static FAudioMasteringVoice* masteringvoice = NULL;
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
SDL_mixer is now entirely contained in Music.cpp. This meant making the track vectors static, but that's kind of what we do with musicclass anyway? In any case, this will make the transition to FAudio MUCH less invasive.
2021-12-26 14:57:38 +01:00
class SoundTrack
{
public:
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
SoundTrack(const char* fileName)
{
Add support for sound OGG files This adds support for OGG files as sound effects (via renaming them to the wrong .wav file extension), because in previous versions of the game, SDL_mixer didn't care what the file extension was, and so some people relied on this, as described in #900. This is accomplished by copy-pasting the OGG loading code for music tracks. For a bit of cleanliness, I put the WAV and OGG loading code in separate functions. This is mostly the same code, except that because sound effects don't loop and can't be paused or resumed, there's no reserve buffer, and there's no data for loop points. Also, for some reason, the music loading code divided by 20 in the `size` calculation. I found that this prematurely cut off sound effects, and that it made more sense to just not do the division. I don't know why it was there, but removing it works. Also also, some OGG files don't work with this. Namely, ones produced by FFmpeg. To test this, I just extracted 0levelcomplete.ogg from vvvvvvmusic.vvv and replaced terminal.wav with it. And it works, so hopefully I won't have to touch audio code again, although I might if someone complains about this. But either way, I'm committing this because it's better than it was before. Fixes #900.
2023-03-19 02:24:30 +01:00
unsigned char* mem;
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
size_t length;
Copy rest of music code to OGG sound effects The missing piece from sound effects was handling what to do when the buffer ran out. Which seems to happen often when decoding from OGG, unlike WAV. This handling involves callbacks to functions named refillReserve and swapBuffers. Without this code,some sound effects would be cut off early, as documented in #953. This might also explain the division by 20 - which I've copied too, just in case. Now OGG sound effect tracks should be identical to music tracks (except I've stripped the looping code out). Fixes #953.
2023-03-29 05:48:43 +02:00
voice_index = -1;
Add support for sound OGG files This adds support for OGG files as sound effects (via renaming them to the wrong .wav file extension), because in previous versions of the game, SDL_mixer didn't care what the file extension was, and so some people relied on this, as described in #900. This is accomplished by copy-pasting the OGG loading code for music tracks. For a bit of cleanliness, I put the WAV and OGG loading code in separate functions. This is mostly the same code, except that because sound effects don't loop and can't be paused or resumed, there's no reserve buffer, and there's no data for loop points. Also, for some reason, the music loading code divided by 20 in the `size` calculation. I found that this prematurely cut off sound effects, and that it made more sense to just not do the division. I don't know why it was there, but removing it works. Also also, some OGG files don't work with this. Namely, ones produced by FFmpeg. To test this, I just extracted 0levelcomplete.ogg from vvvvvvmusic.vvv and replaced terminal.wav with it. And it works, so hopefully I won't have to touch audio code again, although I might if someone complains about this. But either way, I'm committing this because it's better than it was before. Fixes #900.
2023-03-19 02:24:30 +01:00
Always add null terminator when loading files This removes the `addnull` argument from `FILESYSTEM_loadFileToMemory` and `FILESYSTEM_loadAssetToMemory`, and makes it so a null terminator is always appended no matter what. This simplifies things and removes the need for callers to make the decision about null termination and what its implications are. Then you get cases where null termination might not happen when it should be, such as the one df577c59ef16df8893e0628559de1b304e84b951 (#947) fixed. When FIQ added the `addnull` argument in 5862af4445bfd9c056de7ef9694f8cb31f9d469a (#117), I'm guessing he did it because he wanted to be cautious about adding the null terminator to every file, so he only did it for XML files, which was the only case needed at the time. But really, there's no downsides to always appending a null terminator. In fact, it's already always done whenever the STDIN buffer is loaded.
2023-03-18 23:12:24 +01:00
FILESYSTEM_loadAssetToMemory(fileName, &mem, &length);
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
if (mem == NULL)
{
Add support for sound OGG files This adds support for OGG files as sound effects (via renaming them to the wrong .wav file extension), because in previous versions of the game, SDL_mixer didn't care what the file extension was, and so some people relied on this, as described in #900. This is accomplished by copy-pasting the OGG loading code for music tracks. For a bit of cleanliness, I put the WAV and OGG loading code in separate functions. This is mostly the same code, except that because sound effects don't loop and can't be paused or resumed, there's no reserve buffer, and there's no data for loop points. Also, for some reason, the music loading code divided by 20 in the `size` calculation. I found that this prematurely cut off sound effects, and that it made more sense to just not do the division. I don't know why it was there, but removing it works. Also also, some OGG files don't work with this. Namely, ones produced by FFmpeg. To test this, I just extracted 0levelcomplete.ogg from vvvvvvmusic.vvv and replaced terminal.wav with it. And it works, so hopefully I won't have to touch audio code again, although I might if someone complains about this. But either way, I'm committing this because it's better than it was before. Fixes #900.
2023-03-19 02:24:30 +01:00
vlog_error("Unable to load sound file %s", fileName);
SDL_assert(0 && "Sound file missing!");
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
return;
}
Add support for sound OGG files This adds support for OGG files as sound effects (via renaming them to the wrong .wav file extension), because in previous versions of the game, SDL_mixer didn't care what the file extension was, and so some people relied on this, as described in #900. This is accomplished by copy-pasting the OGG loading code for music tracks. For a bit of cleanliness, I put the WAV and OGG loading code in separate functions. This is mostly the same code, except that because sound effects don't loop and can't be paused or resumed, there's no reserve buffer, and there's no data for loop points. Also, for some reason, the music loading code divided by 20 in the `size` calculation. I found that this prematurely cut off sound effects, and that it made more sense to just not do the division. I don't know why it was there, but removing it works. Also also, some OGG files don't work with this. Namely, ones produced by FFmpeg. To test this, I just extracted 0levelcomplete.ogg from vvvvvvmusic.vvv and replaced terminal.wav with it. And it works, so hopefully I won't have to touch audio code again, although I might if someone complains about this. But either way, I'm committing this because it's better than it was before. Fixes #900.
2023-03-19 02:24:30 +01:00
SDL_zerop(this);
Add length check to OGG check Dav999 pointed out this potential issue on Discord. While basically all memcmp implementations will terminate early here if there's a null byte (because it's mismatched), it doesn't hurt to add the check here.
2023-03-19 22:00:34 +01:00
if (length >= 4 && SDL_memcmp(mem, "OggS", 4) == 0)
Add support for sound OGG files This adds support for OGG files as sound effects (via renaming them to the wrong .wav file extension), because in previous versions of the game, SDL_mixer didn't care what the file extension was, and so some people relied on this, as described in #900. This is accomplished by copy-pasting the OGG loading code for music tracks. For a bit of cleanliness, I put the WAV and OGG loading code in separate functions. This is mostly the same code, except that because sound effects don't loop and can't be paused or resumed, there's no reserve buffer, and there's no data for loop points. Also, for some reason, the music loading code divided by 20 in the `size` calculation. I found that this prematurely cut off sound effects, and that it made more sense to just not do the division. I don't know why it was there, but removing it works. Also also, some OGG files don't work with this. Namely, ones produced by FFmpeg. To test this, I just extracted 0levelcomplete.ogg from vvvvvvmusic.vvv and replaced terminal.wav with it. And it works, so hopefully I won't have to touch audio code again, although I might if someone complains about this. But either way, I'm committing this because it's better than it was before. Fixes #900.
2023-03-19 02:24:30 +01:00
{
LoadOGG(fileName, mem, length);
Copy rest of music code to OGG sound effects The missing piece from sound effects was handling what to do when the buffer ran out. Which seems to happen often when decoding from OGG, unlike WAV. This handling involves callbacks to functions named refillReserve and swapBuffers. Without this code,some sound effects would be cut off early, as documented in #953. This might also explain the division by 20 - which I've copied too, just in case. Now OGG sound effect tracks should be identical to music tracks (except I've stripped the looping code out). Fixes #953.
2023-03-29 05:48:43 +02:00
callbacks.OnBufferStart = &SoundTrack::refillReserve;
callbacks.OnBufferEnd = &SoundTrack::swapBuffers;
Add support for sound OGG files This adds support for OGG files as sound effects (via renaming them to the wrong .wav file extension), because in previous versions of the game, SDL_mixer didn't care what the file extension was, and so some people relied on this, as described in #900. This is accomplished by copy-pasting the OGG loading code for music tracks. For a bit of cleanliness, I put the WAV and OGG loading code in separate functions. This is mostly the same code, except that because sound effects don't loop and can't be paused or resumed, there's no reserve buffer, and there's no data for loop points. Also, for some reason, the music loading code divided by 20 in the `size` calculation. I found that this prematurely cut off sound effects, and that it made more sense to just not do the division. I don't know why it was there, but removing it works. Also also, some OGG files don't work with this. Namely, ones produced by FFmpeg. To test this, I just extracted 0levelcomplete.ogg from vvvvvvmusic.vvv and replaced terminal.wav with it. And it works, so hopefully I won't have to touch audio code again, although I might if someone complains about this. But either way, I'm committing this because it's better than it was before. Fixes #900.
2023-03-19 02:24:30 +01:00
}
else
{
LoadWAV(fileName, mem, length);
}
}
void LoadWAV(const char* fileName, unsigned char* mem, const size_t length)
{
SDL_AudioSpec spec;
SDL_RWops *fileIn;
Port to FAudio
2022-03-09 22:35:29 +01:00
fileIn = SDL_RWFromConstMem(mem, length);
if (SDL_LoadWAV_RW(fileIn, 1, &spec, &wav_buffer, &wav_length) == NULL)
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
{
Port to FAudio
2022-03-09 22:35:29 +01:00
vlog_error("Unable to load WAV file %s", fileName);
goto end;
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
}
Port to FAudio
2022-03-09 22:35:29 +01:00
format.nChannels = spec.channels;
format.nSamplesPerSec = spec.freq;
format.wFormatTag = FAUDIO_FORMAT_PCM;
Fix loading sounds with non-16 bit depths This fixes an issue where sound effects of bit depths that weren't 16, such as 8, were being played incorrectly, as described in #886. The problem is that when loading the sound effect, we would always set the bit depth to 16 no matter what! Instead, we should set the bit depth to the actual bit depth of the file. Fixes #886.
2023-03-18 23:59:17 +01:00
format.wBitsPerSample = SDL_AUDIO_BITSIZE(spec.format);
Port to FAudio
2022-03-09 22:35:29 +01:00
format.nBlockAlign = format.nChannels * format.wBitsPerSample;
format.nAvgBytesPerSec = format.nSamplesPerSec * format.nBlockAlign;
format.cbSize = 0;
valid = true;
end:
Replace all free calls with `VVV_free[func]` This replaces all calls to SDL_free with a new macro, VVV_free, that nulls the pointer afterwards. This mitigates any use-after-frees and also completely eliminates double-frees. The same is done for any function to free specific objects such as SDL_FreeSurface, with the VVV_freefunc macro. No exceptions for any of these calls, even if the pointer is discarded or zeroed afterwards anyway. Better safe than sorry. This is a macro rather than a function that takes in a pointer-to-pointer because such a function would have type issues that require casting and that's just not safe. Even though SDL_free and other SDL functions already check for NULL, the macro has a NULL check for other functions that don't. For example, FAudioVoice_DestroyVoice does not check for NULL. FILESYSTEM_freeMemory has been axed in favor of VVV_free because it functionally does the same thing except for `unsigned char*` only.
2022-12-01 07:30:16 +01:00
VVV_free(mem);
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
}
Add support for sound OGG files This adds support for OGG files as sound effects (via renaming them to the wrong .wav file extension), because in previous versions of the game, SDL_mixer didn't care what the file extension was, and so some people relied on this, as described in #900. This is accomplished by copy-pasting the OGG loading code for music tracks. For a bit of cleanliness, I put the WAV and OGG loading code in separate functions. This is mostly the same code, except that because sound effects don't loop and can't be paused or resumed, there's no reserve buffer, and there's no data for loop points. Also, for some reason, the music loading code divided by 20 in the `size` calculation. I found that this prematurely cut off sound effects, and that it made more sense to just not do the division. I don't know why it was there, but removing it works. Also also, some OGG files don't work with this. Namely, ones produced by FFmpeg. To test this, I just extracted 0levelcomplete.ogg from vvvvvvmusic.vvv and replaced terminal.wav with it. And it works, so hopefully I won't have to touch audio code again, although I might if someone complains about this. But either way, I'm committing this because it's better than it was before. Fixes #900.
2023-03-19 02:24:30 +01:00
void LoadOGG(const char* fileName, unsigned char* mem, const size_t length)
{
int err;
stb_vorbis_info vorbis_info;
vorbis = stb_vorbis_open_memory(mem, length, &err, NULL);
if (vorbis == NULL)
{
vlog_error("Unable to create Vorbis handle for %s, error %d", fileName, err);
VVV_free(mem);
return;
}
vorbis_info = stb_vorbis_get_info(vorbis);
format.wFormatTag = FAUDIO_FORMAT_IEEE_FLOAT;
format.wBitsPerSample = sizeof(float) * 8;
format.nChannels = vorbis_info.channels;
format.nSamplesPerSec = vorbis_info.sample_rate;
format.nBlockAlign = format.nChannels * format.wBitsPerSample;
format.nAvgBytesPerSec = format.nSamplesPerSec * format.nBlockAlign;
format.cbSize = 0;
channels = format.nChannels;
Copy rest of music code to OGG sound effects The missing piece from sound effects was handling what to do when the buffer ran out. Which seems to happen often when decoding from OGG, unlike WAV. This handling involves callbacks to functions named refillReserve and swapBuffers. Without this code,some sound effects would be cut off early, as documented in #953. This might also explain the division by 20 - which I've copied too, just in case. Now OGG sound effect tracks should be identical to music tracks (except I've stripped the looping code out). Fixes #953.
2023-03-29 05:48:43 +02:00
size = format.nAvgBytesPerSec / 20;
Add support for sound OGG files This adds support for OGG files as sound effects (via renaming them to the wrong .wav file extension), because in previous versions of the game, SDL_mixer didn't care what the file extension was, and so some people relied on this, as described in #900. This is accomplished by copy-pasting the OGG loading code for music tracks. For a bit of cleanliness, I put the WAV and OGG loading code in separate functions. This is mostly the same code, except that because sound effects don't loop and can't be paused or resumed, there's no reserve buffer, and there's no data for loop points. Also, for some reason, the music loading code divided by 20 in the `size` calculation. I found that this prematurely cut off sound effects, and that it made more sense to just not do the division. I don't know why it was there, but removing it works. Also also, some OGG files don't work with this. Namely, ones produced by FFmpeg. To test this, I just extracted 0levelcomplete.ogg from vvvvvvmusic.vvv and replaced terminal.wav with it. And it works, so hopefully I won't have to touch audio code again, although I might if someone complains about this. But either way, I'm committing this because it's better than it was before. Fixes #900.
2023-03-19 02:24:30 +01:00
decoded_buf_playing = (Uint8*) SDL_malloc(size);
Copy rest of music code to OGG sound effects The missing piece from sound effects was handling what to do when the buffer ran out. Which seems to happen often when decoding from OGG, unlike WAV. This handling involves callbacks to functions named refillReserve and swapBuffers. Without this code,some sound effects would be cut off early, as documented in #953. This might also explain the division by 20 - which I've copied too, just in case. Now OGG sound effect tracks should be identical to music tracks (except I've stripped the looping code out). Fixes #953.
2023-03-29 05:48:43 +02:00
decoded_buf_reserve = (Uint8*) SDL_malloc(size);
Add support for sound OGG files This adds support for OGG files as sound effects (via renaming them to the wrong .wav file extension), because in previous versions of the game, SDL_mixer didn't care what the file extension was, and so some people relied on this, as described in #900. This is accomplished by copy-pasting the OGG loading code for music tracks. For a bit of cleanliness, I put the WAV and OGG loading code in separate functions. This is mostly the same code, except that because sound effects don't loop and can't be paused or resumed, there's no reserve buffer, and there's no data for loop points. Also, for some reason, the music loading code divided by 20 in the `size` calculation. I found that this prematurely cut off sound effects, and that it made more sense to just not do the division. I don't know why it was there, but removing it works. Also also, some OGG files don't work with this. Namely, ones produced by FFmpeg. To test this, I just extracted 0levelcomplete.ogg from vvvvvvmusic.vvv and replaced terminal.wav with it. And it works, so hopefully I won't have to touch audio code again, although I might if someone complains about this. But either way, I'm committing this because it's better than it was before. Fixes #900.
2023-03-19 02:24:30 +01:00
ogg_file = mem;
valid = true;
}
Style: Fixup instances of `void` arguments The style we have here is that functions with no arguments are to have explicit `void` arguments, even though this doesn't apply in C++, because it does apply in C. Unfortunately, some have slipped through the cracks. This commit fixes them.
2023-03-18 23:24:14 +01:00
void Dispose(void)
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
{
Replace all free calls with `VVV_free[func]` This replaces all calls to SDL_free with a new macro, VVV_free, that nulls the pointer afterwards. This mitigates any use-after-frees and also completely eliminates double-frees. The same is done for any function to free specific objects such as SDL_FreeSurface, with the VVV_freefunc macro. No exceptions for any of these calls, even if the pointer is discarded or zeroed afterwards anyway. Better safe than sorry. This is a macro rather than a function that takes in a pointer-to-pointer because such a function would have type issues that require casting and that's just not safe. Even though SDL_free and other SDL functions already check for NULL, the macro has a NULL check for other functions that don't. For example, FAudioVoice_DestroyVoice does not check for NULL. FILESYSTEM_freeMemory has been axed in favor of VVV_free because it functionally does the same thing except for `unsigned char*` only.
2022-12-01 07:30:16 +01:00
VVV_free(wav_buffer);
Add support for sound OGG files This adds support for OGG files as sound effects (via renaming them to the wrong .wav file extension), because in previous versions of the game, SDL_mixer didn't care what the file extension was, and so some people relied on this, as described in #900. This is accomplished by copy-pasting the OGG loading code for music tracks. For a bit of cleanliness, I put the WAV and OGG loading code in separate functions. This is mostly the same code, except that because sound effects don't loop and can't be paused or resumed, there's no reserve buffer, and there's no data for loop points. Also, for some reason, the music loading code divided by 20 in the `size` calculation. I found that this prematurely cut off sound effects, and that it made more sense to just not do the division. I don't know why it was there, but removing it works. Also also, some OGG files don't work with this. Namely, ones produced by FFmpeg. To test this, I just extracted 0levelcomplete.ogg from vvvvvvmusic.vvv and replaced terminal.wav with it. And it works, so hopefully I won't have to touch audio code again, although I might if someone complains about this. But either way, I'm committing this because it's better than it was before. Fixes #900.
2023-03-19 02:24:30 +01:00
VVV_free(decoded_buf_playing);
Copy rest of music code to OGG sound effects The missing piece from sound effects was handling what to do when the buffer ran out. Which seems to happen often when decoding from OGG, unlike WAV. This handling involves callbacks to functions named refillReserve and swapBuffers. Without this code,some sound effects would be cut off early, as documented in #953. This might also explain the division by 20 - which I've copied too, just in case. Now OGG sound effect tracks should be identical to music tracks (except I've stripped the looping code out). Fixes #953.
2023-03-29 05:48:43 +02:00
VVV_free(decoded_buf_reserve);
Add support for sound OGG files This adds support for OGG files as sound effects (via renaming them to the wrong .wav file extension), because in previous versions of the game, SDL_mixer didn't care what the file extension was, and so some people relied on this, as described in #900. This is accomplished by copy-pasting the OGG loading code for music tracks. For a bit of cleanliness, I put the WAV and OGG loading code in separate functions. This is mostly the same code, except that because sound effects don't loop and can't be paused or resumed, there's no reserve buffer, and there's no data for loop points. Also, for some reason, the music loading code divided by 20 in the `size` calculation. I found that this prematurely cut off sound effects, and that it made more sense to just not do the division. I don't know why it was there, but removing it works. Also also, some OGG files don't work with this. Namely, ones produced by FFmpeg. To test this, I just extracted 0levelcomplete.ogg from vvvvvvmusic.vvv and replaced terminal.wav with it. And it works, so hopefully I won't have to touch audio code again, although I might if someone complains about this. But either way, I'm committing this because it's better than it was before. Fixes #900.
2023-03-19 02:24:30 +01:00
VVV_freefunc(stb_vorbis_close, vorbis);
VVV_free(ogg_file);
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
}
Style: Fixup instances of `void` arguments The style we have here is that functions with no arguments are to have explicit `void` arguments, even though this doesn't apply in C++, because it does apply in C. Unfortunately, some have slipped through the cracks. This commit fixes them.
2023-03-18 23:24:14 +01:00
void Play(void)
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
{
Port to FAudio
2022-03-09 22:35:29 +01:00
if (!valid)
{
return;
}
for (int i = 0; i < VVV_MAX_CHANNELS; i++)
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
{
Port to FAudio
2022-03-09 22:35:29 +01:00
FAudioVoiceState voicestate;
FAudioSourceVoice_GetState(voices[i], &voicestate, 0);
if (voicestate.BuffersQueued == 0)
{
Don't use `FAudioVoice_GetVoiceDetails` We were using this function to check if the format of the existing voice is different from the format of the voice we intended to play. However, whereas the format we use is the FAudioWaveFormatEx struct, the only details we get from FAudioVoice_GetVoiceDetails is the FAudioVoiceDetails struct, which has much less details and is missing important things like whether the format is 8-bit or 16-bit or something else. And of course, if we don't check that the number of bits matches, then it still leads to playback issues as described in #953. There are no other functions in FAudio that operate on FAudioWaveFormatEx structs. So instead, we'll just have to do it ourselves, and store the format of the existing voice alongside the format of the intended voice. And then use SDL_memcmp to make sure the formats are the same before playing, and if not, then destroy and re-create the voice. Fixes #953.
2023-03-27 06:14:02 +02:00
if (SDL_memcmp(&voice_formats[i], &format, sizeof(format)) != 0)
Port to FAudio
2022-03-09 22:35:29 +01:00
{
Replace all free calls with `VVV_free[func]` This replaces all calls to SDL_free with a new macro, VVV_free, that nulls the pointer afterwards. This mitigates any use-after-frees and also completely eliminates double-frees. The same is done for any function to free specific objects such as SDL_FreeSurface, with the VVV_freefunc macro. No exceptions for any of these calls, even if the pointer is discarded or zeroed afterwards anyway. Better safe than sorry. This is a macro rather than a function that takes in a pointer-to-pointer because such a function would have type issues that require casting and that's just not safe. Even though SDL_free and other SDL functions already check for NULL, the macro has a NULL check for other functions that don't. For example, FAudioVoice_DestroyVoice does not check for NULL. FILESYSTEM_freeMemory has been axed in favor of VVV_free because it functionally does the same thing except for `unsigned char*` only.
2022-12-01 07:30:16 +01:00
VVV_freefunc(FAudioVoice_DestroyVoice, voices[i]);
Copy rest of music code to OGG sound effects The missing piece from sound effects was handling what to do when the buffer ran out. Which seems to happen often when decoding from OGG, unlike WAV. This handling involves callbacks to functions named refillReserve and swapBuffers. Without this code,some sound effects would be cut off early, as documented in #953. This might also explain the division by 20 - which I've copied too, just in case. Now OGG sound effect tracks should be identical to music tracks (except I've stripped the looping code out). Fixes #953.
2023-03-29 05:48:43 +02:00
if (vorbis != NULL)
{
FAudio_CreateSourceVoice(faudioctx, &voices[i], &format, 0, 2.0f, &callbacks, NULL, NULL);
}
else
{
FAudio_CreateSourceVoice(faudioctx, &voices[i], &format, 0, 2.0f, NULL, NULL, NULL);
}
Don't use `FAudioVoice_GetVoiceDetails` We were using this function to check if the format of the existing voice is different from the format of the voice we intended to play. However, whereas the format we use is the FAudioWaveFormatEx struct, the only details we get from FAudioVoice_GetVoiceDetails is the FAudioVoiceDetails struct, which has much less details and is missing important things like whether the format is 8-bit or 16-bit or something else. And of course, if we don't check that the number of bits matches, then it still leads to playback issues as described in #953. There are no other functions in FAudio that operate on FAudioWaveFormatEx structs. So instead, we'll just have to do it ourselves, and store the format of the existing voice alongside the format of the intended voice. And then use SDL_memcmp to make sure the formats are the same before playing, and if not, then destroy and re-create the voice. Fixes #953.
2023-03-27 06:14:02 +02:00
voice_formats[i] = format;
Port to FAudio
2022-03-09 22:35:29 +01:00
}
Add support for sound OGG files This adds support for OGG files as sound effects (via renaming them to the wrong .wav file extension), because in previous versions of the game, SDL_mixer didn't care what the file extension was, and so some people relied on this, as described in #900. This is accomplished by copy-pasting the OGG loading code for music tracks. For a bit of cleanliness, I put the WAV and OGG loading code in separate functions. This is mostly the same code, except that because sound effects don't loop and can't be paused or resumed, there's no reserve buffer, and there's no data for loop points. Also, for some reason, the music loading code divided by 20 in the `size` calculation. I found that this prematurely cut off sound effects, and that it made more sense to just not do the division. I don't know why it was there, but removing it works. Also also, some OGG files don't work with this. Namely, ones produced by FFmpeg. To test this, I just extracted 0levelcomplete.ogg from vvvvvvmusic.vvv and replaced terminal.wav with it. And it works, so hopefully I won't have to touch audio code again, although I might if someone complains about this. But either way, I'm committing this because it's better than it was before. Fixes #900.
2023-03-19 02:24:30 +01:00
FAudioBuffer faudio_buffer = {
Port to FAudio
2022-03-09 22:35:29 +01:00
FAUDIO_END_OF_STREAM, /* Flags */
wav_length * 8, /* AudioBytes */
wav_buffer, /* AudioData */
0, /* playbegin */
0, /* playlength */
0, /* LoopBegin */
0, /* LoopLength */
0, /* LoopCount */
NULL
};
Add support for sound OGG files This adds support for OGG files as sound effects (via renaming them to the wrong .wav file extension), because in previous versions of the game, SDL_mixer didn't care what the file extension was, and so some people relied on this, as described in #900. This is accomplished by copy-pasting the OGG loading code for music tracks. For a bit of cleanliness, I put the WAV and OGG loading code in separate functions. This is mostly the same code, except that because sound effects don't loop and can't be paused or resumed, there's no reserve buffer, and there's no data for loop points. Also, for some reason, the music loading code divided by 20 in the `size` calculation. I found that this prematurely cut off sound effects, and that it made more sense to just not do the division. I don't know why it was there, but removing it works. Also also, some OGG files don't work with this. Namely, ones produced by FFmpeg. To test this, I just extracted 0levelcomplete.ogg from vvvvvvmusic.vvv and replaced terminal.wav with it. And it works, so hopefully I won't have to touch audio code again, although I might if someone complains about this. But either way, I'm committing this because it's better than it was before. Fixes #900.
2023-03-19 02:24:30 +01:00
if (vorbis != NULL)
{
stb_vorbis_seek_start(vorbis);
faudio_buffer.PlayLength = stb_vorbis_get_samples_float_interleaved(
vorbis,
channels,
(float*) decoded_buf_playing,
size / sizeof(float)
);
faudio_buffer.AudioBytes = size;
faudio_buffer.pAudioData = decoded_buf_playing;
Copy rest of music code to OGG sound effects The missing piece from sound effects was handling what to do when the buffer ran out. Which seems to happen often when decoding from OGG, unlike WAV. This handling involves callbacks to functions named refillReserve and swapBuffers. Without this code,some sound effects would be cut off early, as documented in #953. This might also explain the division by 20 - which I've copied too, just in case. Now OGG sound effect tracks should be identical to music tracks (except I've stripped the looping code out). Fixes #953.
2023-03-29 05:48:43 +02:00
faudio_buffer.pContext = this;
Add support for sound OGG files This adds support for OGG files as sound effects (via renaming them to the wrong .wav file extension), because in previous versions of the game, SDL_mixer didn't care what the file extension was, and so some people relied on this, as described in #900. This is accomplished by copy-pasting the OGG loading code for music tracks. For a bit of cleanliness, I put the WAV and OGG loading code in separate functions. This is mostly the same code, except that because sound effects don't loop and can't be paused or resumed, there's no reserve buffer, and there's no data for loop points. Also, for some reason, the music loading code divided by 20 in the `size` calculation. I found that this prematurely cut off sound effects, and that it made more sense to just not do the division. I don't know why it was there, but removing it works. Also also, some OGG files don't work with this. Namely, ones produced by FFmpeg. To test this, I just extracted 0levelcomplete.ogg from vvvvvvmusic.vvv and replaced terminal.wav with it. And it works, so hopefully I won't have to touch audio code again, although I might if someone complains about this. But either way, I'm committing this because it's better than it was before. Fixes #900.
2023-03-19 02:24:30 +01:00
}
Port to FAudio
2022-03-09 22:35:29 +01:00
if (FAudioSourceVoice_SubmitSourceBuffer(voices[i], &faudio_buffer, NULL))
{
vlog_error("Unable to queue sound buffer");
Copy rest of music code to OGG sound effects The missing piece from sound effects was handling what to do when the buffer ran out. Which seems to happen often when decoding from OGG, unlike WAV. This handling involves callbacks to functions named refillReserve and swapBuffers. Without this code,some sound effects would be cut off early, as documented in #953. This might also explain the division by 20 - which I've copied too, just in case. Now OGG sound effect tracks should be identical to music tracks (except I've stripped the looping code out). Fixes #953.
2023-03-29 05:48:43 +02:00
voice_index = -1;
Port to FAudio
2022-03-09 22:35:29 +01:00
return;
}
Fix semi random volume jumps
2022-06-09 21:46:40 +02:00
FAudioVoice_SetVolume(voices[i], volume, FAUDIO_COMMIT_NOW);
Port to FAudio
2022-03-09 22:35:29 +01:00
if (FAudioSourceVoice_Start(voices[i], 0, FAUDIO_COMMIT_NOW))
{
vlog_error("Unable to start voice processing");
Copy rest of music code to OGG sound effects The missing piece from sound effects was handling what to do when the buffer ran out. Which seems to happen often when decoding from OGG, unlike WAV. This handling involves callbacks to functions named refillReserve and swapBuffers. Without this code,some sound effects would be cut off early, as documented in #953. This might also explain the division by 20 - which I've copied too, just in case. Now OGG sound effect tracks should be identical to music tracks (except I've stripped the looping code out). Fixes #953.
2023-03-29 05:48:43 +02:00
voice_index = -1;
Port to FAudio
2022-03-09 22:35:29 +01:00
}
Copy rest of music code to OGG sound effects The missing piece from sound effects was handling what to do when the buffer ran out. Which seems to happen often when decoding from OGG, unlike WAV. This handling involves callbacks to functions named refillReserve and swapBuffers. Without this code,some sound effects would be cut off early, as documented in #953. This might also explain the division by 20 - which I've copied too, just in case. Now OGG sound effect tracks should be identical to music tracks (except I've stripped the looping code out). Fixes #953.
2023-03-29 05:48:43 +02:00
voice_index = i;
Port to FAudio
2022-03-09 22:35:29 +01:00
return;
}
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
}
}
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
`SoundTrack::Init`: Remove unused `audio_channels` arg Missed this when reviewing the FAudio PR, so I'll just remove it now.
2022-03-31 20:13:57 +02:00
static void Init(int audio_rate)
Move the Mix_OpenAudio call to SoundTrack, from MusicTrack. In hindsight, the FAudio pointer will likely be in SoundTrack since we will want to keep the mastering voice closer to the sounds and their source voice arrays, while the MusicTrack will likely just be one source voice that gets PCM from different streams.
2022-01-14 22:52:52 +01:00
{
Port to FAudio
2022-03-09 22:35:29 +01:00
if (voices == NULL)
Move the Mix_OpenAudio call to SoundTrack, from MusicTrack. In hindsight, the FAudio pointer will likely be in SoundTrack since we will want to keep the mastering voice closer to the sounds and their source voice arrays, while the MusicTrack will likely just be one source voice that gets PCM from different streams.
2022-01-14 22:52:52 +01:00
{
Port to FAudio
2022-03-09 22:35:29 +01:00
voices = (FAudioSourceVoice**) SDL_malloc(sizeof(FAudioSourceVoice*) * VVV_MAX_CHANNELS);
for (int i = 0; i < VVV_MAX_CHANNELS; i++)
{
FAudioWaveFormatEx format;
format.nChannels = 1; /* Assume 1 for SoundTracks. Will be recreated if mismatched during play */
format.nSamplesPerSec = audio_rate;
format.wFormatTag = FAUDIO_FORMAT_PCM;
format.wBitsPerSample = 16;
format.nBlockAlign = format.nChannels * format.wBitsPerSample;
format.nAvgBytesPerSec = format.nSamplesPerSec * format.nBlockAlign;
format.cbSize = 0;
Don't use `FAudioVoice_GetVoiceDetails` We were using this function to check if the format of the existing voice is different from the format of the voice we intended to play. However, whereas the format we use is the FAudioWaveFormatEx struct, the only details we get from FAudioVoice_GetVoiceDetails is the FAudioVoiceDetails struct, which has much less details and is missing important things like whether the format is 8-bit or 16-bit or something else. And of course, if we don't check that the number of bits matches, then it still leads to playback issues as described in #953. There are no other functions in FAudio that operate on FAudioWaveFormatEx structs. So instead, we'll just have to do it ourselves, and store the format of the existing voice alongside the format of the intended voice. And then use SDL_memcmp to make sure the formats are the same before playing, and if not, then destroy and re-create the voice. Fixes #953.
2023-03-27 06:14:02 +02:00
voice_formats[i] = format;
Port to FAudio
2022-03-09 22:35:29 +01:00
if (FAudio_CreateSourceVoice(faudioctx, &voices[i], &format, 0, 2.0f, NULL, NULL, NULL))
{
vlog_error("Unable to create source voice no. %i", i);
return;
}
}
Move the Mix_OpenAudio call to SoundTrack, from MusicTrack. In hindsight, the FAudio pointer will likely be in SoundTrack since we will want to keep the mastering voice closer to the sounds and their source voice arrays, while the MusicTrack will likely just be one source voice that gets PCM from different streams.
2022-01-14 22:52:52 +01:00
}
}
Style: Fixup instances of `void` arguments The style we have here is that functions with no arguments are to have explicit `void` arguments, even though this doesn't apply in C++, because it does apply in C. Unfortunately, some have slipped through the cracks. This commit fixes them.
2023-03-18 23:24:14 +01:00
static void Pause(void)
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
{
Port to FAudio
2022-03-09 22:35:29 +01:00
for (size_t i = 0; i < VVV_MAX_CHANNELS; i++)
{
FAudioSourceVoice_Stop(voices[i], 0, FAUDIO_COMMIT_NOW);
}
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
}
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
Style: Fixup instances of `void` arguments The style we have here is that functions with no arguments are to have explicit `void` arguments, even though this doesn't apply in C++, because it does apply in C. Unfortunately, some have slipped through the cracks. This commit fixes them.
2023-03-18 23:24:14 +01:00
static void Resume(void)
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
{
Port to FAudio
2022-03-09 22:35:29 +01:00
for (size_t i = 0; i < VVV_MAX_CHANNELS; i++)
{
FAudioSourceVoice_Start(voices[i], 0, FAUDIO_COMMIT_NOW);
}
}
Style: Fixup instances of `void` arguments The style we have here is that functions with no arguments are to have explicit `void` arguments, even though this doesn't apply in C++, because it does apply in C. Unfortunately, some have slipped through the cracks. This commit fixes them.
2023-03-18 23:24:14 +01:00
static void Destroy(void)
Port to FAudio
2022-03-09 22:35:29 +01:00
{
if (voices != NULL)
{
for (int i = 0; i < VVV_MAX_CHANNELS; i++)
{
Replace all free calls with `VVV_free[func]` This replaces all calls to SDL_free with a new macro, VVV_free, that nulls the pointer afterwards. This mitigates any use-after-frees and also completely eliminates double-frees. The same is done for any function to free specific objects such as SDL_FreeSurface, with the VVV_freefunc macro. No exceptions for any of these calls, even if the pointer is discarded or zeroed afterwards anyway. Better safe than sorry. This is a macro rather than a function that takes in a pointer-to-pointer because such a function would have type issues that require casting and that's just not safe. Even though SDL_free and other SDL functions already check for NULL, the macro has a NULL check for other functions that don't. For example, FAudioVoice_DestroyVoice does not check for NULL. FILESYSTEM_freeMemory has been axed in favor of VVV_free because it functionally does the same thing except for `unsigned char*` only.
2022-12-01 07:30:16 +01:00
VVV_freefunc(FAudioVoice_DestroyVoice, voices[i]);
Port to FAudio
2022-03-09 22:35:29 +01:00
}
Replace all free calls with `VVV_free[func]` This replaces all calls to SDL_free with a new macro, VVV_free, that nulls the pointer afterwards. This mitigates any use-after-frees and also completely eliminates double-frees. The same is done for any function to free specific objects such as SDL_FreeSurface, with the VVV_freefunc macro. No exceptions for any of these calls, even if the pointer is discarded or zeroed afterwards anyway. Better safe than sorry. This is a macro rather than a function that takes in a pointer-to-pointer because such a function would have type issues that require casting and that's just not safe. Even though SDL_free and other SDL functions already check for NULL, the macro has a NULL check for other functions that don't. For example, FAudioVoice_DestroyVoice does not check for NULL. FILESYSTEM_freeMemory has been axed in favor of VVV_free because it functionally does the same thing except for `unsigned char*` only.
2022-12-01 07:30:16 +01:00
VVV_free(voices);
Port to FAudio
2022-03-09 22:35:29 +01:00
}
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
}
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
static void SetVolume(int soundVolume)
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
{
Fix semi random volume jumps
2022-06-09 21:46:40 +02:00
volume = (float) soundVolume / VVV_MAX_VOLUME;
Port to FAudio
2022-03-09 22:35:29 +01:00
for (size_t i = 0; i < VVV_MAX_CHANNELS; i++)
{
Fix semi random volume jumps
2022-06-09 21:46:40 +02:00
FAudioVoice_SetVolume(voices[i], volume, FAUDIO_COMMIT_NOW);
Port to FAudio
2022-03-09 22:35:29 +01:00
}
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
}
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
Copy rest of music code to OGG sound effects The missing piece from sound effects was handling what to do when the buffer ran out. Which seems to happen often when decoding from OGG, unlike WAV. This handling involves callbacks to functions named refillReserve and swapBuffers. Without this code,some sound effects would be cut off early, as documented in #953. This might also explain the division by 20 - which I've copied too, just in case. Now OGG sound effect tracks should be identical to music tracks (except I've stripped the looping code out). Fixes #953.
2023-03-29 05:48:43 +02:00
static void refillReserve(FAudioVoiceCallback* callback, void* ctx)
{
bool inbounds;
SoundTrack* t = (SoundTrack*) ctx;
FAudioBuffer faudio_buffer;
SDL_zero(faudio_buffer);
UNUSED(callback);
faudio_buffer.PlayLength = stb_vorbis_get_samples_float_interleaved(t->vorbis, t->channels, (float*) t->decoded_buf_reserve, t->size / sizeof(float));
faudio_buffer.AudioBytes = t->size;
faudio_buffer.pAudioData = t->decoded_buf_reserve;
faudio_buffer.pContext = t;
if (faudio_buffer.PlayLength == 0)
{
return;
}
inbounds = t->voice_index >= 0 && t->voice_index < VVV_MAX_CHANNELS;
if (!inbounds)
{
return;
}
FAudioSourceVoice_SubmitSourceBuffer(voices[t->voice_index], &faudio_buffer, NULL);
}
static void swapBuffers(FAudioVoiceCallback* callback, void* ctx)
{
SoundTrack* t = (SoundTrack*) ctx;
Uint8* tmp = t->decoded_buf_playing;
UNUSED(callback);
t->decoded_buf_playing = t->decoded_buf_reserve;
t->decoded_buf_reserve = tmp;
}
Fix warning: use of non-static data member initialization This fixes the following warnings: desktop_version/src/Music.cpp: At global scope: desktop_version/src/Music.cpp:240:23: warning: non-static data member initializers only available with ‘-std=c++11’ or ‘-std=gnu++11’ [-Wc++11-extensions] 240 | Uint8 *wav_buffer = NULL; | ^ desktop_version/src/Music.cpp:414:32: warning: non-static data member initializers only available with ‘-std=c++11’ or ‘-std=gnu++11’ [-Wc++11-extensions] 414 | Uint8* decoded_buf_playing = NULL; | ^ desktop_version/src/Music.cpp:415:32: warning: non-static data member initializers only available with ‘-std=c++11’ or ‘-std=gnu++11’ [-Wc++11-extensions] 415 | Uint8* decoded_buf_reserve = NULL; | ^ desktop_version/src/Music.cpp:416:21: warning: non-static data member initializers only available with ‘-std=c++11’ or ‘-std=gnu++11’ [-Wc++11-extensions] 416 | Uint8* read_buf = NULL; | ^ These warnings are because the non-static data members (i.e. data members that will be different for each instance of a class) are being initialized at the same time as they're being declared, which means that's what their value will be when the class instance is initialized. However, this is only a C++11 feature, and we don't use C++11. Luckily, we don't need to do this, and this is in fact redundant because we already zero out the class instance in its constructor using SDL_zerop(). Therefore, we should remove these initializers to fix compliance with C++03.
2022-07-29 01:48:58 +02:00
Uint8 *wav_buffer;
Port to FAudio
2022-03-09 22:35:29 +01:00
Uint32 wav_length;
FAudioWaveFormatEx format;
Copy rest of music code to OGG sound effects The missing piece from sound effects was handling what to do when the buffer ran out. Which seems to happen often when decoding from OGG, unlike WAV. This handling involves callbacks to functions named refillReserve and swapBuffers. Without this code,some sound effects would be cut off early, as documented in #953. This might also explain the division by 20 - which I've copied too, just in case. Now OGG sound effect tracks should be identical to music tracks (except I've stripped the looping code out). Fixes #953.
2023-03-29 05:48:43 +02:00
int voice_index;
Add support for sound OGG files This adds support for OGG files as sound effects (via renaming them to the wrong .wav file extension), because in previous versions of the game, SDL_mixer didn't care what the file extension was, and so some people relied on this, as described in #900. This is accomplished by copy-pasting the OGG loading code for music tracks. For a bit of cleanliness, I put the WAV and OGG loading code in separate functions. This is mostly the same code, except that because sound effects don't loop and can't be paused or resumed, there's no reserve buffer, and there's no data for loop points. Also, for some reason, the music loading code divided by 20 in the `size` calculation. I found that this prematurely cut off sound effects, and that it made more sense to just not do the division. I don't know why it was there, but removing it works. Also also, some OGG files don't work with this. Namely, ones produced by FFmpeg. To test this, I just extracted 0levelcomplete.ogg from vvvvvvmusic.vvv and replaced terminal.wav with it. And it works, so hopefully I won't have to touch audio code again, although I might if someone complains about this. But either way, I'm committing this because it's better than it was before. Fixes #900.
2023-03-19 02:24:30 +01:00
unsigned char* ogg_file;
stb_vorbis* vorbis;
int channels;
Uint32 size;
Uint8* decoded_buf_playing;
Copy rest of music code to OGG sound effects The missing piece from sound effects was handling what to do when the buffer ran out. Which seems to happen often when decoding from OGG, unlike WAV. This handling involves callbacks to functions named refillReserve and swapBuffers. Without this code,some sound effects would be cut off early, as documented in #953. This might also explain the division by 20 - which I've copied too, just in case. Now OGG sound effect tracks should be identical to music tracks (except I've stripped the looping code out). Fixes #953.
2023-03-29 05:48:43 +02:00
Uint8* decoded_buf_reserve;
FAudioVoiceCallback callbacks;
Add support for sound OGG files This adds support for OGG files as sound effects (via renaming them to the wrong .wav file extension), because in previous versions of the game, SDL_mixer didn't care what the file extension was, and so some people relied on this, as described in #900. This is accomplished by copy-pasting the OGG loading code for music tracks. For a bit of cleanliness, I put the WAV and OGG loading code in separate functions. This is mostly the same code, except that because sound effects don't loop and can't be paused or resumed, there's no reserve buffer, and there's no data for loop points. Also, for some reason, the music loading code divided by 20 in the `size` calculation. I found that this prematurely cut off sound effects, and that it made more sense to just not do the division. I don't know why it was there, but removing it works. Also also, some OGG files don't work with this. Namely, ones produced by FFmpeg. To test this, I just extracted 0levelcomplete.ogg from vvvvvvmusic.vvv and replaced terminal.wav with it. And it works, so hopefully I won't have to touch audio code again, although I might if someone complains about this. But either way, I'm committing this because it's better than it was before. Fixes #900.
2023-03-19 02:24:30 +01:00
Port to FAudio
2022-03-09 22:35:29 +01:00
bool valid;
static FAudioSourceVoice** voices;
Don't use `FAudioVoice_GetVoiceDetails` We were using this function to check if the format of the existing voice is different from the format of the voice we intended to play. However, whereas the format we use is the FAudioWaveFormatEx struct, the only details we get from FAudioVoice_GetVoiceDetails is the FAudioVoiceDetails struct, which has much less details and is missing important things like whether the format is 8-bit or 16-bit or something else. And of course, if we don't check that the number of bits matches, then it still leads to playback issues as described in #953. There are no other functions in FAudio that operate on FAudioWaveFormatEx structs. So instead, we'll just have to do it ourselves, and store the format of the existing voice alongside the format of the intended voice. And then use SDL_memcmp to make sure the formats are the same before playing, and if not, then destroy and re-create the voice. Fixes #953.
2023-03-27 06:14:02 +02:00
static FAudioWaveFormatEx voice_formats[VVV_MAX_CHANNELS];
Fix semi random volume jumps
2022-06-09 21:46:40 +02:00
static float volume;
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
};
Port to FAudio
2022-03-09 22:35:29 +01:00
FAudioSourceVoice** SoundTrack::voices = NULL;
Don't use `FAudioVoice_GetVoiceDetails` We were using this function to check if the format of the existing voice is different from the format of the voice we intended to play. However, whereas the format we use is the FAudioWaveFormatEx struct, the only details we get from FAudioVoice_GetVoiceDetails is the FAudioVoiceDetails struct, which has much less details and is missing important things like whether the format is 8-bit or 16-bit or something else. And of course, if we don't check that the number of bits matches, then it still leads to playback issues as described in #953. There are no other functions in FAudio that operate on FAudioWaveFormatEx structs. So instead, we'll just have to do it ourselves, and store the format of the existing voice alongside the format of the intended voice. And then use SDL_memcmp to make sure the formats are the same before playing, and if not, then destroy and re-create the voice. Fixes #953.
2023-03-27 06:14:02 +02:00
FAudioWaveFormatEx SoundTrack::voice_formats[VVV_MAX_CHANNELS];
Explicitly initialize `SoundTrack::volume` While this is not needed because it's a static variable, it doesn't hurt to be explicit, especially if it's going to be refactored in the future.
2022-06-10 20:17:38 +02:00
float SoundTrack::volume = 0.0f;
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
Move MusicTrack below SoundTrack. It's very likely that MusicTrack will be pulling from the SoundTrack FAudio context, so make it so forward declarations are unnecessary.
2022-01-14 23:24:22 +01:00
class MusicTrack
{
public:
MusicTrack(SDL_RWops *rw)
{
Port to FAudio
2022-03-09 22:35:29 +01:00
SDL_zerop(this);
read_buf = (Uint8*) SDL_malloc(rw->size(rw));
SDL_RWread(rw, read_buf, rw->size(rw), 1);
int err;
stb_vorbis_info vorbis_info;
stb_vorbis_comment vorbis_comment;
vorbis = stb_vorbis_open_memory(read_buf, rw->size(rw), &err, NULL);
if (vorbis == NULL)
Move MusicTrack below SoundTrack. It's very likely that MusicTrack will be pulling from the SoundTrack FAudio context, so make it so forward declarations are unnecessary.
2022-01-14 23:24:22 +01:00
{
Port to FAudio
2022-03-09 22:35:29 +01:00
vlog_error("Unable to create Vorbis handle, error %d", err);
Replace all free calls with `VVV_free[func]` This replaces all calls to SDL_free with a new macro, VVV_free, that nulls the pointer afterwards. This mitigates any use-after-frees and also completely eliminates double-frees. The same is done for any function to free specific objects such as SDL_FreeSurface, with the VVV_freefunc macro. No exceptions for any of these calls, even if the pointer is discarded or zeroed afterwards anyway. Better safe than sorry. This is a macro rather than a function that takes in a pointer-to-pointer because such a function would have type issues that require casting and that's just not safe. Even though SDL_free and other SDL functions already check for NULL, the macro has a NULL check for other functions that don't. For example, FAudioVoice_DestroyVoice does not check for NULL. FILESYSTEM_freeMemory has been axed in favor of VVV_free because it functionally does the same thing except for `unsigned char*` only.
2022-12-01 07:30:16 +01:00
VVV_free(read_buf);
Port to FAudio
2022-03-09 22:35:29 +01:00
goto end;
Move MusicTrack below SoundTrack. It's very likely that MusicTrack will be pulling from the SoundTrack FAudio context, so make it so forward declarations are unnecessary.
2022-01-14 23:24:22 +01:00
}
Port to FAudio
2022-03-09 22:35:29 +01:00
vorbis_info = stb_vorbis_get_info(vorbis);
format.wFormatTag = FAUDIO_FORMAT_IEEE_FLOAT;
format.wBitsPerSample = sizeof(float) * 8;
format.nChannels = vorbis_info.channels;
format.nSamplesPerSec = vorbis_info.sample_rate;
format.nBlockAlign = format.nChannels * format.wBitsPerSample;
format.nAvgBytesPerSec = format.nSamplesPerSec * format.nBlockAlign;
format.cbSize = 0;
channels = format.nChannels;
size = format.nAvgBytesPerSec / 20;
decoded_buf_playing = (Uint8*) SDL_malloc(size);
decoded_buf_reserve = (Uint8*) SDL_malloc(size);
loopbegin = 0;
looplength = 0;
vorbis_comment = stb_vorbis_get_comment(vorbis);
parseComments(this, vorbis_comment.comment_list, vorbis_comment.comment_list_length);
valid = true;
end:
SDL_RWclose(rw);
Move MusicTrack below SoundTrack. It's very likely that MusicTrack will be pulling from the SoundTrack FAudio context, so make it so forward declarations are unnecessary.
2022-01-14 23:24:22 +01:00
}
Style: Fixup instances of `void` arguments The style we have here is that functions with no arguments are to have explicit `void` arguments, even though this doesn't apply in C++, because it does apply in C. Unfortunately, some have slipped through the cracks. This commit fixes them.
2023-03-18 23:24:14 +01:00
void Dispose(void)
Move MusicTrack below SoundTrack. It's very likely that MusicTrack will be pulling from the SoundTrack FAudio context, so make it so forward declarations are unnecessary.
2022-01-14 23:24:22 +01:00
{
Use `VVV_freefunc` to call `stb_vorbis_close` I noticed that this call wasn't using VVV_freefunc. I missed it earlier when going through Music.cpp and checking for instances when VVV_freefunc should have been used (a926ce98513f04b751f22907e9ce324da82b30d8).
2023-03-19 01:51:55 +01:00
VVV_freefunc(stb_vorbis_close, vorbis);
Replace all free calls with `VVV_free[func]` This replaces all calls to SDL_free with a new macro, VVV_free, that nulls the pointer afterwards. This mitigates any use-after-frees and also completely eliminates double-frees. The same is done for any function to free specific objects such as SDL_FreeSurface, with the VVV_freefunc macro. No exceptions for any of these calls, even if the pointer is discarded or zeroed afterwards anyway. Better safe than sorry. This is a macro rather than a function that takes in a pointer-to-pointer because such a function would have type issues that require casting and that's just not safe. Even though SDL_free and other SDL functions already check for NULL, the macro has a NULL check for other functions that don't. For example, FAudioVoice_DestroyVoice does not check for NULL. FILESYSTEM_freeMemory has been axed in favor of VVV_free because it functionally does the same thing except for `unsigned char*` only.
2022-12-01 07:30:16 +01:00
VVV_free(read_buf);
VVV_free(decoded_buf_playing);
VVV_free(decoded_buf_reserve);
Port to FAudio
2022-03-09 22:35:29 +01:00
if (!IsHalted())
{
Replace all free calls with `VVV_free[func]` This replaces all calls to SDL_free with a new macro, VVV_free, that nulls the pointer afterwards. This mitigates any use-after-frees and also completely eliminates double-frees. The same is done for any function to free specific objects such as SDL_FreeSurface, with the VVV_freefunc macro. No exceptions for any of these calls, even if the pointer is discarded or zeroed afterwards anyway. Better safe than sorry. This is a macro rather than a function that takes in a pointer-to-pointer because such a function would have type issues that require casting and that's just not safe. Even though SDL_free and other SDL functions already check for NULL, the macro has a NULL check for other functions that don't. For example, FAudioVoice_DestroyVoice does not check for NULL. FILESYSTEM_freeMemory has been axed in favor of VVV_free because it functionally does the same thing except for `unsigned char*` only.
2022-12-01 07:30:16 +01:00
VVV_freefunc(FAudioVoice_DestroyVoice, musicVoice);
Port to FAudio
2022-03-09 22:35:29 +01:00
}
Move MusicTrack below SoundTrack. It's very likely that MusicTrack will be pulling from the SoundTrack FAudio context, so make it so forward declarations are unnecessary.
2022-01-14 23:24:22 +01:00
}
bool Play(bool loop)
{
Port to FAudio
2022-03-09 22:35:29 +01:00
if (!valid)
Move MusicTrack below SoundTrack. It's very likely that MusicTrack will be pulling from the SoundTrack FAudio context, so make it so forward declarations are unnecessary.
2022-01-14 23:24:22 +01:00
{
return false;
}
Port to FAudio
2022-03-09 22:35:29 +01:00
shouldloop = loop;
sample_pos = 0;
stb_vorbis_seek_start(vorbis);
Fix remaining audio speedup/slowdown bug Fixes #1057. Based on Ethan's hunch, I simply removed the format comparison that decides whether to halt and restart, or reuse the voice. Voices are now always restarted when playing a new track. This also simplifies the code somewhat: `MusicTrack::musicVoiceFormat` was now no longer used, and an `if (!IsHalted())` was no longer necessary because `Halt()` already does that. So those are now removed as well.
2023-11-28 21:29:44 +01:00
Halt();
Fix music playing wrong if played after track of different format As described in #886, if a track was played when an existing track was already playing, and the sample rates of the two tracks differ, then the second track would play wrong and distorted. This is because the second track would play with the sample rate of the first. To fix this, halt the track if the sample rate is mismatched, which destroys the voice. This results in the voice being recreated later in the Play() function. The track is also halted if the number of channels or bit depth is mismatched. Fixes #886.
2023-03-18 23:33:30 +01:00
Fix remaining audio speedup/slowdown bug Fixes #1057. Based on Ethan's hunch, I simply removed the format comparison that decides whether to halt and restart, or reuse the voice. Voices are now always restarted when playing a new track. This also simplifies the code somewhat: `MusicTrack::musicVoiceFormat` was now no longer used, and an `if (!IsHalted())` was no longer necessary because `Halt()` already does that. So those are now removed as well.
2023-11-28 21:29:44 +01:00
SDL_zero(callbacks);
callbacks.OnBufferStart = &MusicTrack::refillReserve;
callbacks.OnBufferEnd = &MusicTrack::swapBuffers;
FAudio_CreateSourceVoice(faudioctx, &musicVoice, &format, 0, 2.0f, &callbacks, NULL, NULL);
Port to FAudio
2022-03-09 22:35:29 +01:00
FAudioBuffer faudio_buffer;
SDL_zero(faudio_buffer);
if (looplength == 0)
{
faudio_buffer.PlayLength = stb_vorbis_get_samples_float_interleaved(vorbis, channels, (float*) decoded_buf_playing, size / sizeof(float));
}
else
{
int samples_read = stb_vorbis_get_samples_float_interleaved(vorbis, channels, (float*) decoded_buf_playing, size / sizeof(float));
faudio_buffer.PlayLength = SDL_min(samples_read, (loopbegin + looplength) - sample_pos);
}
faudio_buffer.AudioBytes = size;
faudio_buffer.pAudioData = decoded_buf_playing;
faudio_buffer.pContext = this;
sample_pos += faudio_buffer.PlayLength;
if (FAudioSourceVoice_SubmitSourceBuffer(musicVoice, &faudio_buffer, NULL))
{
vlog_error("Unable to queue sound buffer");
return false;
}
Resume();
Move MusicTrack below SoundTrack. It's very likely that MusicTrack will be pulling from the SoundTrack FAudio context, so make it so forward declarations are unnecessary.
2022-01-14 23:24:22 +01:00
return true;
}
Style: Fixup instances of `void` arguments The style we have here is that functions with no arguments are to have explicit `void` arguments, even though this doesn't apply in C++, because it does apply in C. Unfortunately, some have slipped through the cracks. This commit fixes them.
2023-03-18 23:24:14 +01:00
static void Halt(void)
Move MusicTrack below SoundTrack. It's very likely that MusicTrack will be pulling from the SoundTrack FAudio context, so make it so forward declarations are unnecessary.
2022-01-14 23:24:22 +01:00
{
Port to FAudio
2022-03-09 22:35:29 +01:00
if (!IsHalted())
{
FAudioSourceVoice_FlushSourceBuffers(musicVoice);
Replace all free calls with `VVV_free[func]` This replaces all calls to SDL_free with a new macro, VVV_free, that nulls the pointer afterwards. This mitigates any use-after-frees and also completely eliminates double-frees. The same is done for any function to free specific objects such as SDL_FreeSurface, with the VVV_freefunc macro. No exceptions for any of these calls, even if the pointer is discarded or zeroed afterwards anyway. Better safe than sorry. This is a macro rather than a function that takes in a pointer-to-pointer because such a function would have type issues that require casting and that's just not safe. Even though SDL_free and other SDL functions already check for NULL, the macro has a NULL check for other functions that don't. For example, FAudioVoice_DestroyVoice does not check for NULL. FILESYSTEM_freeMemory has been axed in favor of VVV_free because it functionally does the same thing except for `unsigned char*` only.
2022-12-01 07:30:16 +01:00
VVV_freefunc(FAudioVoice_DestroyVoice, musicVoice);
Fix music changes between areas
2022-04-10 21:50:15 +02:00
paused = true;
Port to FAudio
2022-03-09 22:35:29 +01:00
}
Move MusicTrack below SoundTrack. It's very likely that MusicTrack will be pulling from the SoundTrack FAudio context, so make it so forward declarations are unnecessary.
2022-01-14 23:24:22 +01:00
}
Style: Fixup instances of `void` arguments The style we have here is that functions with no arguments are to have explicit `void` arguments, even though this doesn't apply in C++, because it does apply in C. Unfortunately, some have slipped through the cracks. This commit fixes them.
2023-03-18 23:24:14 +01:00
static bool IsHalted(void)
Move MusicTrack below SoundTrack. It's very likely that MusicTrack will be pulling from the SoundTrack FAudio context, so make it so forward declarations are unnecessary.
2022-01-14 23:24:22 +01:00
{
Port to FAudio
2022-03-09 22:35:29 +01:00
return musicVoice == NULL;
Move MusicTrack below SoundTrack. It's very likely that MusicTrack will be pulling from the SoundTrack FAudio context, so make it so forward declarations are unnecessary.
2022-01-14 23:24:22 +01:00
}
Style: Fixup instances of `void` arguments The style we have here is that functions with no arguments are to have explicit `void` arguments, even though this doesn't apply in C++, because it does apply in C. Unfortunately, some have slipped through the cracks. This commit fixes them.
2023-03-18 23:24:14 +01:00
static void Pause(void)
Move MusicTrack below SoundTrack. It's very likely that MusicTrack will be pulling from the SoundTrack FAudio context, so make it so forward declarations are unnecessary.
2022-01-14 23:24:22 +01:00
{
Port to FAudio
2022-03-09 22:35:29 +01:00
if (!IsHalted())
{
FAudioSourceVoice_Stop(musicVoice, 0, FAUDIO_COMMIT_NOW);
Fix music changes between areas
2022-04-10 21:50:15 +02:00
paused = true;
Port to FAudio
2022-03-09 22:35:29 +01:00
}
Move MusicTrack below SoundTrack. It's very likely that MusicTrack will be pulling from the SoundTrack FAudio context, so make it so forward declarations are unnecessary.
2022-01-14 23:24:22 +01:00
}
Style: Fixup instances of `void` arguments The style we have here is that functions with no arguments are to have explicit `void` arguments, even though this doesn't apply in C++, because it does apply in C. Unfortunately, some have slipped through the cracks. This commit fixes them.
2023-03-18 23:24:14 +01:00
static bool IsPaused(void)
Fix music changes between areas
2022-04-10 21:50:15 +02:00
{
return paused || IsHalted();
}
Style: Fixup instances of `void` arguments The style we have here is that functions with no arguments are to have explicit `void` arguments, even though this doesn't apply in C++, because it does apply in C. Unfortunately, some have slipped through the cracks. This commit fixes them.
2023-03-18 23:24:14 +01:00
static void Resume(void)
Move MusicTrack below SoundTrack. It's very likely that MusicTrack will be pulling from the SoundTrack FAudio context, so make it so forward declarations are unnecessary.
2022-01-14 23:24:22 +01:00
{
Port to FAudio
2022-03-09 22:35:29 +01:00
if (!IsHalted())
{
FAudioSourceVoice_Start(musicVoice, 0, FAUDIO_COMMIT_NOW);
Fix music changes between areas
2022-04-10 21:50:15 +02:00
paused = false;
Port to FAudio
2022-03-09 22:35:29 +01:00
}
Move MusicTrack below SoundTrack. It's very likely that MusicTrack will be pulling from the SoundTrack FAudio context, so make it so forward declarations are unnecessary.
2022-01-14 23:24:22 +01:00
}
static void SetVolume(int musicVolume)
{
Port to FAudio
2022-03-09 22:35:29 +01:00
float adj_vol = (float) musicVolume / VVV_MAX_VOLUME;
if (!IsHalted())
{
FAudioVoice_SetVolume(musicVoice, adj_vol, FAUDIO_COMMIT_NOW);
}
Move MusicTrack below SoundTrack. It's very likely that MusicTrack will be pulling from the SoundTrack FAudio context, so make it so forward declarations are unnecessary.
2022-01-14 23:24:22 +01:00
}
Port to FAudio
2022-03-09 22:35:29 +01:00
stb_vorbis* vorbis;
int channels;
Uint32 size;
int loopbegin;
int looplength;
int sample_pos; //stb_vorbis offset not yet functional on pulldata API. TODO Replace when fixed
Move MusicTrack below SoundTrack. It's very likely that MusicTrack will be pulling from the SoundTrack FAudio context, so make it so forward declarations are unnecessary.
2022-01-14 23:24:22 +01:00
Port to FAudio
2022-03-09 22:35:29 +01:00
FAudioVoiceCallback callbacks;
FAudioWaveFormatEx format;
Fix warning: use of non-static data member initialization This fixes the following warnings: desktop_version/src/Music.cpp: At global scope: desktop_version/src/Music.cpp:240:23: warning: non-static data member initializers only available with ‘-std=c++11’ or ‘-std=gnu++11’ [-Wc++11-extensions] 240 | Uint8 *wav_buffer = NULL; | ^ desktop_version/src/Music.cpp:414:32: warning: non-static data member initializers only available with ‘-std=c++11’ or ‘-std=gnu++11’ [-Wc++11-extensions] 414 | Uint8* decoded_buf_playing = NULL; | ^ desktop_version/src/Music.cpp:415:32: warning: non-static data member initializers only available with ‘-std=c++11’ or ‘-std=gnu++11’ [-Wc++11-extensions] 415 | Uint8* decoded_buf_reserve = NULL; | ^ desktop_version/src/Music.cpp:416:21: warning: non-static data member initializers only available with ‘-std=c++11’ or ‘-std=gnu++11’ [-Wc++11-extensions] 416 | Uint8* read_buf = NULL; | ^ These warnings are because the non-static data members (i.e. data members that will be different for each instance of a class) are being initialized at the same time as they're being declared, which means that's what their value will be when the class instance is initialized. However, this is only a C++11 feature, and we don't use C++11. Luckily, we don't need to do this, and this is in fact redundant because we already zero out the class instance in its constructor using SDL_zerop(). Therefore, we should remove these initializers to fix compliance with C++03.
2022-07-29 01:48:58 +02:00
Uint8* decoded_buf_playing;
Uint8* decoded_buf_reserve;
Uint8* read_buf;
Port to FAudio
2022-03-09 22:35:29 +01:00
bool shouldloop;
bool valid;
SDL_mixer is now entirely contained in Music.cpp. This meant making the track vectors static, but that's kind of what we do with musicclass anyway? In any case, this will make the transition to FAudio MUCH less invasive.
2021-12-26 14:57:38 +01:00
Fix music changes between areas
2022-04-10 21:50:15 +02:00
static bool paused;
Port to FAudio
2022-03-09 22:35:29 +01:00
static FAudioSourceVoice* musicVoice;
static void refillReserve(FAudioVoiceCallback* callback, void* ctx)
{
MusicTrack* t = (MusicTrack*) ctx;
FAudioBuffer faudio_buffer;
SDL_zero(faudio_buffer);
UNUSED(callback);
if (t->looplength == 0)
{
faudio_buffer.PlayLength = stb_vorbis_get_samples_float_interleaved(t->vorbis, t->channels, (float*) t->decoded_buf_reserve, t->size / sizeof(float));
}
else
{
int samples_read = stb_vorbis_get_samples_float_interleaved(t->vorbis, t->channels, (float*) t->decoded_buf_reserve, t->size / sizeof(float));
faudio_buffer.PlayLength = SDL_min(samples_read, (t->loopbegin + t->looplength) - t->sample_pos);
}
faudio_buffer.AudioBytes = t->size;
faudio_buffer.pAudioData = t->decoded_buf_reserve;
faudio_buffer.pContext = t;
if (faudio_buffer.PlayLength == 0)
{
if (t->shouldloop)
{
stb_vorbis_seek(t->vorbis, t->loopbegin);
t->sample_pos = t->loopbegin;
if (t->looplength != 0)
{
int samples_read = stb_vorbis_get_samples_float_interleaved(t->vorbis, t->channels, (float*) t->decoded_buf_reserve, t->size / sizeof(float));
faudio_buffer.PlayLength = SDL_min(samples_read, (t->loopbegin + t->looplength) - t->sample_pos);
}
else
{
faudio_buffer.PlayLength = stb_vorbis_get_samples_float_interleaved(t->vorbis, t->channels, (float*) t->decoded_buf_reserve, t->size / sizeof(float));
}
if (faudio_buffer.PlayLength == 0)
{
return;
}
}
else
{
return;
}
}
t->sample_pos += faudio_buffer.PlayLength;
FAudioSourceVoice_SubmitSourceBuffer(musicVoice, &faudio_buffer, NULL);
}
static void swapBuffers(FAudioVoiceCallback* callback, void* ctx)
{
MusicTrack* t = (MusicTrack*) ctx;
Uint8* tmp = t->decoded_buf_playing;
UNUSED(callback);
t->decoded_buf_playing = t->decoded_buf_reserve;
t->decoded_buf_reserve = tmp;
}
/* Lifted from SDL_mixer, we used it in 2.3 and previous */
Fix up style in `parseComments` This does the following: - Wrap lines that are too long (around 80 columns) - Place the asterisk with the type instead of the variable name
2022-11-14 04:27:58 +01:00
static void parseComments(
MusicTrack* t, char** comments, const int comment_list_length
) {
Port to FAudio
2022-03-09 22:35:29 +01:00
int loopend = 0;
for (int i = 0; i < comment_list_length; i++)
{
Fix up style in `parseComments` This does the following: - Wrap lines that are too long (around 80 columns) - Place the asterisk with the type instead of the variable name
2022-11-14 04:27:58 +01:00
char* param = SDL_strdup(comments[i]);
Check for `SDL_strdup` failure in `parseComments` Just in case it happens. Comments aren't really important to the game (at worst a track will just loop in the wrong place) so it's fine to carry on here and ignore all comments if this happens.
2022-11-14 04:41:32 +01:00
if (param == NULL)
{
vlog_error(
"Could not allocate memory to parse '%s'. Ignoring comments.",
comments[i]
);
break;
}
Fix up style in `parseComments` This does the following: - Wrap lines that are too long (around 80 columns) - Place the asterisk with the type instead of the variable name
2022-11-14 04:27:58 +01:00
char* argument = param;
char* value = SDL_strchr(param, '=');
Port to FAudio
2022-03-09 22:35:29 +01:00
if (value == NULL)
{
value = param + SDL_strlen(param);
}
else
{
*(value++) = '\0';
}
/* Want to match LOOP-START, LOOP_START, etc. Remove - or _ from
* string if it is present at position 4. */
char buf[5];
SDL_strlcpy(buf, argument, sizeof(buf));
Fix up style in `parseComments` This does the following: - Wrap lines that are too long (around 80 columns) - Place the asterisk with the type instead of the variable name
2022-11-14 04:27:58 +01:00
if (SDL_strcasecmp(buf, "LOOP") == 0
&& ((argument[4] == '_') || (argument[4] == '-')))
Port to FAudio
2022-03-09 22:35:29 +01:00
{
SDL_memmove(argument + 4, argument + 5, SDL_strlen(argument) - 4);
}
if (SDL_strcasecmp(argument, "LOOPSTART") == 0)
{
t->loopbegin = _Mix_ParseTime(value, t->format.nSamplesPerSec);
}
else if (SDL_strcasecmp(argument, "LOOPLENGTH") == 0)
{
t->looplength = SDL_strtoll(value, NULL, 10);
}
else if (SDL_strcasecmp(argument, "LOOPEND") == 0)
{
loopend = _Mix_ParseTime(value, t->format.nSamplesPerSec);
}
Ignore comments of tracks with a negative loop comment If a music track has a loop comment with a negative value, ignore all comments of the track. This is just to prevent any weirdness from happening as it's safer to just let the track loop improperly. Also log to the console to let users know. This is the same thing that SDL_mixer does now: libsdl-org/SDL_mixer@e819489459d5e9942851b9547854ba988fe50291 This commit happened as a result of discussion on the VVVVVV Discord server about SDL_mixer 2.0.4 behavior with weird loop comment values (e.g. octal input with leading zeroes). This is simply updating the code to be in line with what newer versions of SDL_mixer do.
2022-11-14 04:47:37 +01:00
if (t->loopbegin < 0 || t->looplength < 0 || loopend < 0)
{
vlog_warn(
"A track loop comment had a negative value. "
"Ignoring all comments for the track."
);
t->loopbegin = 0;
t->looplength = 0;
loopend = 0;
Replace all free calls with `VVV_free[func]` This replaces all calls to SDL_free with a new macro, VVV_free, that nulls the pointer afterwards. This mitigates any use-after-frees and also completely eliminates double-frees. The same is done for any function to free specific objects such as SDL_FreeSurface, with the VVV_freefunc macro. No exceptions for any of these calls, even if the pointer is discarded or zeroed afterwards anyway. Better safe than sorry. This is a macro rather than a function that takes in a pointer-to-pointer because such a function would have type issues that require casting and that's just not safe. Even though SDL_free and other SDL functions already check for NULL, the macro has a NULL check for other functions that don't. For example, FAudioVoice_DestroyVoice does not check for NULL. FILESYSTEM_freeMemory has been axed in favor of VVV_free because it functionally does the same thing except for `unsigned char*` only.
2022-12-01 07:30:16 +01:00
VVV_free(param);
Ignore comments of tracks with a negative loop comment If a music track has a loop comment with a negative value, ignore all comments of the track. This is just to prevent any weirdness from happening as it's safer to just let the track loop improperly. Also log to the console to let users know. This is the same thing that SDL_mixer does now: libsdl-org/SDL_mixer@e819489459d5e9942851b9547854ba988fe50291 This commit happened as a result of discussion on the VVVVVV Discord server about SDL_mixer 2.0.4 behavior with weird loop comment values (e.g. octal input with leading zeroes). This is simply updating the code to be in line with what newer versions of SDL_mixer do.
2022-11-14 04:47:37 +01:00
break;
}
Replace all free calls with `VVV_free[func]` This replaces all calls to SDL_free with a new macro, VVV_free, that nulls the pointer afterwards. This mitigates any use-after-frees and also completely eliminates double-frees. The same is done for any function to free specific objects such as SDL_FreeSurface, with the VVV_freefunc macro. No exceptions for any of these calls, even if the pointer is discarded or zeroed afterwards anyway. Better safe than sorry. This is a macro rather than a function that takes in a pointer-to-pointer because such a function would have type issues that require casting and that's just not safe. Even though SDL_free and other SDL functions already check for NULL, the macro has a NULL check for other functions that don't. For example, FAudioVoice_DestroyVoice does not check for NULL. FILESYSTEM_freeMemory has been axed in favor of VVV_free because it functionally does the same thing except for `unsigned char*` only.
2022-12-01 07:30:16 +01:00
VVV_free(param);
Port to FAudio
2022-03-09 22:35:29 +01:00
}
if (loopend != 0)
{
t->looplength = loopend - t->loopbegin;
}
}
Fix up style in `_Mix_ParseTime` This does the following: - Const-qualify variables if they are not modified - Place each statement onto their own separate lines - Place the asterisk with the type instead of the variable name - Combine declarations and initializations where possible
2022-11-14 04:03:26 +01:00
static int _Mix_ParseTime(char* time, const long samplerate_hz)
Port to FAudio
2022-03-09 22:35:29 +01:00
{
Fix up style in `_Mix_ParseTime` This does the following: - Const-qualify variables if they are not modified - Place each statement onto their own separate lines - Place the asterisk with the type instead of the variable name - Combine declarations and initializations where possible
2022-11-14 04:03:26 +01:00
char* num_start = time;
char* p;
Sint64 result = 0;
Port to FAudio
2022-03-09 22:35:29 +01:00
int val;
/* Time is directly expressed as a sample position */
if (SDL_strchr(time, ':') == NULL)
{
return SDL_strtoll(time, NULL, 10);
}
for (p = time; *p != '\0'; ++p)
{
if (*p == '.' || *p == ':')
{
Fix up style in `_Mix_ParseTime` This does the following: - Const-qualify variables if they are not modified - Place each statement onto their own separate lines - Place the asterisk with the type instead of the variable name - Combine declarations and initializations where possible
2022-11-14 04:03:26 +01:00
const char c = *p;
*p = '\0';
val = SDL_atoi(num_start);
if (val < 0)
Port to FAudio
2022-03-09 22:35:29 +01:00
{
return -1;
}
result = result * 60 + val;
num_start = p + 1;
*p = c;
}
if (*p == '.')
{
Fix up style in `_Mix_ParseTime` This does the following: - Const-qualify variables if they are not modified - Place each statement onto their own separate lines - Place the asterisk with the type instead of the variable name - Combine declarations and initializations where possible
2022-11-14 04:03:26 +01:00
const double val_f = SDL_atof(p);
Port to FAudio
2022-03-09 22:35:29 +01:00
if (val_f < 0)
{
return -1;
}
return result * samplerate_hz + (Sint64) (val_f * samplerate_hz);
}
}
Fix up style in `_Mix_ParseTime` This does the following: - Const-qualify variables if they are not modified - Place each statement onto their own separate lines - Place the asterisk with the type instead of the variable name - Combine declarations and initializations where possible
2022-11-14 04:03:26 +01:00
val = SDL_atoi(num_start);
if (val < 0)
Port to FAudio
2022-03-09 22:35:29 +01:00
{
return -1;
}
return (result * 60 + val) * samplerate_hz;
}
};
Fix music changes between areas
2022-04-10 21:50:15 +02:00
bool MusicTrack::paused = false;
Port to FAudio
2022-03-09 22:35:29 +01:00
FAudioSourceVoice* MusicTrack::musicVoice = NULL;
Inline SoundSystem into musicclass constructor
2021-12-26 14:41:01 +01:00
musicclass::musicclass(void)
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
safeToProcessMusic= false;
m_doFadeInVol = false;
m_doFadeOutVol = false;
musicVolume = 0;
Don't reset entire musicclass when mounting and unmounting assets musicclass::init() re-initializes every attribute of musicclass unnecessarily, when initialization should be put in a constructor instead. This is bad, because music.init() gets called whenever we enter and exit a custom level that has assets. Otherwise, this would result in a bug where music.usingmmmmmm would be reset, causing you to revert to PPPPPP on the title screen whenever you enter a level with MMMMMM selected and exit it. This also causes a confusing desync between game.usingmmmmmm and music.usingmmmmmm since the values of the two variables are now different (these duplicate variables should probably be removed, too, and a lot of other duplicate variables like these exist, too, which are a real headache). Which means despite MMMMMM playing on the title screen, exiting the game and re-launching it will play PPPPPP instead. What's even more is that going to game options and switching to PPPPPP will play PPPPPP, but afterwards launching and re-entering will play MMMMMM. Again, having duplicate variables is very bad, and should probably be fixed, but that's a separate patch.
2020-11-13 00:55:58 +01:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
user_music_volume = USER_VOLUME_MAX;
user_sound_volume = USER_VOLUME_MAX;
Add music and sound volume config options This adds <musicvolume> and <soundvolume> tags to unlock.vvv and settings.vvv, so users' volume preferences will be persistent across game sessions. This does not add the user interface to change them from in-game; the next commit will do that.
2021-04-12 02:41:46 +02:00
Initialize currentsong to -1 There's not any ill effects of it being initialized to 0 that I am aware of (because in most cases, it either gets overwritten anyways or there isn't a track playing in the first place), but it shouldn't be 0, because that's Path Complete, so fixing this just in case.
2023-06-04 00:52:24 +02:00
currentsong = -1;
Implement haltedsong This fixes a bug where if a track was resumed, pausing it by unfocusing the window (if enabled, of course) would not resume it after refocusing the window. This happens because resuming the music doesn't change currentsong back from -1, and the window refocusing code checks that currentsong isn't -1 before resuming music. haltedsong is only used when resuming music. It is set back to -1 when resuming music or when playing a new track.
2023-06-09 00:38:26 +02:00
haltedsong = -1;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
nicechange = -1;
nicefade = false;
quick_fade = true;
Don't reset entire musicclass when mounting and unmounting assets musicclass::init() re-initializes every attribute of musicclass unnecessarily, when initialization should be put in a constructor instead. This is bad, because music.init() gets called whenever we enter and exit a custom level that has assets. Otherwise, this would result in a bug where music.usingmmmmmm would be reset, causing you to revert to PPPPPP on the title screen whenever you enter a level with MMMMMM selected and exit it. This also causes a confusing desync between game.usingmmmmmm and music.usingmmmmmm since the values of the two variables are now different (these duplicate variables should probably be removed, too, and a lot of other duplicate variables like these exist, too, which are a real headache). Which means despite MMMMMM playing on the title screen, exiting the game and re-launching it will play PPPPPP instead. What's even more is that going to game options and switching to PPPPPP will play PPPPPP, but afterwards launching and re-entering will play MMMMMM. Again, having duplicate variables is very bad, and should probably be fixed, but that's a separate patch.
2020-11-13 00:55:58 +01:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
usingmmmmmm = false;
Don't reset entire musicclass when mounting and unmounting assets musicclass::init() re-initializes every attribute of musicclass unnecessarily, when initialization should be put in a constructor instead. This is bad, because music.init() gets called whenever we enter and exit a custom level that has assets. Otherwise, this would result in a bug where music.usingmmmmmm would be reset, causing you to revert to PPPPPP on the title screen whenever you enter a level with MMMMMM selected and exit it. This also causes a confusing desync between game.usingmmmmmm and music.usingmmmmmm since the values of the two variables are now different (these duplicate variables should probably be removed, too, and a lot of other duplicate variables like these exist, too, which are a real headache). Which means despite MMMMMM playing on the title screen, exiting the game and re-launching it will play PPPPPP instead. What's even more is that going to game options and switching to PPPPPP will play PPPPPP, but afterwards launching and re-entering will play MMMMMM. Again, having duplicate variables is very bad, and should probably be fixed, but that's a separate patch.
2020-11-13 00:55:58 +01:00
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void musicclass::init(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Port to FAudio
2022-03-09 22:35:29 +01:00
if (FAudioCreate(&faudioctx, 0, FAUDIO_DEFAULT_PROCESSOR))
{
vlog_error("Unable to initialize FAudio");
return;
}
if (FAudio_CreateMasteringVoice(faudioctx, &masteringvoice, 2, 44100, 0, 0, NULL))
{
vlog_error("Unable to create mastering voice");
return;
}
`SoundTrack::Init`: Remove unused `audio_channels` arg Missed this when reviewing the FAudio PR, so I'll just remove it now.
2022-03-31 20:13:57 +02:00
SoundTrack::Init(44100);
Port to FAudio
2022-03-09 22:35:29 +01:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
soundTracks.push_back(SoundTrack( "sounds/jump.wav" ));
soundTracks.push_back(SoundTrack( "sounds/jump2.wav" ));
soundTracks.push_back(SoundTrack( "sounds/hurt.wav" ));
soundTracks.push_back(SoundTrack( "sounds/souleyeminijingle.wav" ));
soundTracks.push_back(SoundTrack( "sounds/coin.wav" ));
soundTracks.push_back(SoundTrack( "sounds/save.wav" ));
soundTracks.push_back(SoundTrack( "sounds/crumble.wav" ));
soundTracks.push_back(SoundTrack( "sounds/vanish.wav" ));
soundTracks.push_back(SoundTrack( "sounds/blip.wav" ));
soundTracks.push_back(SoundTrack( "sounds/preteleport.wav" ));
soundTracks.push_back(SoundTrack( "sounds/teleport.wav" ));
soundTracks.push_back(SoundTrack( "sounds/crew1.wav" ));
soundTracks.push_back(SoundTrack( "sounds/crew2.wav" ));
soundTracks.push_back(SoundTrack( "sounds/crew3.wav" ));
soundTracks.push_back(SoundTrack( "sounds/crew4.wav" ));
soundTracks.push_back(SoundTrack( "sounds/crew5.wav" ));
soundTracks.push_back(SoundTrack( "sounds/crew6.wav" ));
soundTracks.push_back(SoundTrack( "sounds/terminal.wav" ));
soundTracks.push_back(SoundTrack( "sounds/gamesaved.wav" ));
soundTracks.push_back(SoundTrack( "sounds/crashing.wav" ));
soundTracks.push_back(SoundTrack( "sounds/blip2.wav" ));
soundTracks.push_back(SoundTrack( "sounds/countdown.wav" ));
soundTracks.push_back(SoundTrack( "sounds/go.wav" ));
soundTracks.push_back(SoundTrack( "sounds/crash.wav" ));
soundTracks.push_back(SoundTrack( "sounds/combine.wav" ));
soundTracks.push_back(SoundTrack( "sounds/newrecord.wav" ));
soundTracks.push_back(SoundTrack( "sounds/trophy.wav" ));
soundTracks.push_back(SoundTrack( "sounds/rescue.wav" ));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#ifdef VVV_COMPILEMUSIC
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
binaryBlob musicWriteBlob;
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
#define FOREACH_TRACK(blob, track_name) blob.AddFileToBinaryBlob("data/" track_name);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
TRACK_NAMES(musicWriteBlob)
De-duplicate track names Instead of copy-pasting the entire list three times over, why not put it in an easy to use "X" macro?
2020-07-01 00:17:02 +02:00
#undef FOREACH_TRACK
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
musicWriteBlob.writeBinaryBlob("data/BinaryMusic.vvv");
musicWriteBlob.clear();
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#endif
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
num_mmmmmm_tracks = 0;
num_pppppp_tracks = 0;
Account for extra tracks in musicclass::play() Since each soundtrack is no longer guaranteed to be 16, we'll have to account for their different lengths when playing music.
2020-07-01 02:08:37 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (!mmmmmm_blob.unPackBinary("mmmmmm.vvv"))
{
if (pppppp_blob.unPackBinary("vvvvvvmusic.vvv"))
{
vlog_info("Loading music from PPPPPP blob...");
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
mmmmmm = false;
usingmmmmmm=false;
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
int index;
SDL_RWops* rw;
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
Clean up and harden music loading code During review of #869, I looked at this part of the codebase again. I have no idea how or why, but during the course of 2.4 this whole area just became a mess. The issues I fixed (in no particular order): - Copy-pasting the code that loads from the binary blobs - Making sure SDL_RWFromConstMem is used over SDL_RWFromMem wherever possible - Adding checks to make sure the index from the binary blob is valid (it's possible it could not exist) - Adding checks to make sure we gracefully handle SDL_RWFromConstMem/PHYSFSRWOPS_openRead returning NULL - Moving the pointer asterisk to the type instead of the name :)
2022-03-24 17:35:01 +01:00
#define TRACK_LOAD_BLOB(blob, track_name) \
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
index = blob.getIndex("data/" track_name); \
Clean up and harden music loading code During review of #869, I looked at this part of the codebase again. I have no idea how or why, but during the course of 2.4 this whole area just became a mess. The issues I fixed (in no particular order): - Copy-pasting the code that loads from the binary blobs - Making sure SDL_RWFromConstMem is used over SDL_RWFromMem wherever possible - Adding checks to make sure the index from the binary blob is valid (it's possible it could not exist) - Adding checks to make sure we gracefully handle SDL_RWFromConstMem/PHYSFSRWOPS_openRead returning NULL - Moving the pointer asterisk to the type instead of the name :)
2022-03-24 17:35:01 +01:00
if (index >= 0 && index < blob.max_headers) \
{ \
rw = SDL_RWFromConstMem(blob.getAddress(index), blob.getSize(index)); \
if (rw == NULL) \
{ \
vlog_error("Unable to read music file header: %s", SDL_GetError()); \
} \
else \
{ \
musicTracks.push_back(MusicTrack(rw)); \
} \
}
#define FOREACH_TRACK(blob, track_name) TRACK_LOAD_BLOB(blob, track_name)
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
TRACK_NAMES(pppppp_blob)
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
#undef FOREACH_TRACK
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else
{
vlog_info("Loading music from loose files...");
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
SDL_RWops* rw;
Clean up and harden music loading code During review of #869, I looked at this part of the codebase again. I have no idea how or why, but during the course of 2.4 this whole area just became a mess. The issues I fixed (in no particular order): - Copy-pasting the code that loads from the binary blobs - Making sure SDL_RWFromConstMem is used over SDL_RWFromMem wherever possible - Adding checks to make sure the index from the binary blob is valid (it's possible it could not exist) - Adding checks to make sure we gracefully handle SDL_RWFromConstMem/PHYSFSRWOPS_openRead returning NULL - Moving the pointer asterisk to the type instead of the name :)
2022-03-24 17:35:01 +01:00
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
#define FOREACH_TRACK(_, track_name) \
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
rw = PHYSFSRWOPS_openRead(track_name); \
Clean up and harden music loading code During review of #869, I looked at this part of the codebase again. I have no idea how or why, but during the course of 2.4 this whole area just became a mess. The issues I fixed (in no particular order): - Copy-pasting the code that loads from the binary blobs - Making sure SDL_RWFromConstMem is used over SDL_RWFromMem wherever possible - Adding checks to make sure the index from the binary blob is valid (it's possible it could not exist) - Adding checks to make sure we gracefully handle SDL_RWFromConstMem/PHYSFSRWOPS_openRead returning NULL - Moving the pointer asterisk to the type instead of the name :)
2022-03-24 17:35:01 +01:00
if (rw == NULL) \
{ \
vlog_error("Unable to read loose music file: %s", SDL_GetError()); \
} \
else \
{ \
musicTracks.push_back(MusicTrack(rw)); \
}
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
TRACK_NAMES(_)
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
#undef FOREACH_TRACK
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
}
else
{
vlog_info("Loading PPPPPP and MMMMMM blobs...");
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
mmmmmm = true;
int index;
Clean up and harden music loading code During review of #869, I looked at this part of the codebase again. I have no idea how or why, but during the course of 2.4 this whole area just became a mess. The issues I fixed (in no particular order): - Copy-pasting the code that loads from the binary blobs - Making sure SDL_RWFromConstMem is used over SDL_RWFromMem wherever possible - Adding checks to make sure the index from the binary blob is valid (it's possible it could not exist) - Adding checks to make sure we gracefully handle SDL_RWFromConstMem/PHYSFSRWOPS_openRead returning NULL - Moving the pointer asterisk to the type instead of the name :)
2022-03-24 17:35:01 +01:00
SDL_RWops* rw;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Clean up and harden music loading code During review of #869, I looked at this part of the codebase again. I have no idea how or why, but during the course of 2.4 this whole area just became a mess. The issues I fixed (in no particular order): - Copy-pasting the code that loads from the binary blobs - Making sure SDL_RWFromConstMem is used over SDL_RWFromMem wherever possible - Adding checks to make sure the index from the binary blob is valid (it's possible it could not exist) - Adding checks to make sure we gracefully handle SDL_RWFromConstMem/PHYSFSRWOPS_openRead returning NULL - Moving the pointer asterisk to the type instead of the name :)
2022-03-24 17:35:01 +01:00
#define FOREACH_TRACK(blob, track_name) TRACK_LOAD_BLOB(blob, track_name)
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
TRACK_NAMES(mmmmmm_blob)
num_mmmmmm_tracks += musicTracks.size();
size_t index_ = 0;
while (mmmmmm_blob.nextExtra(&index_))
{
rw = SDL_RWFromConstMem(mmmmmm_blob.getAddress(index_), mmmmmm_blob.getSize(index_));
musicTracks.push_back(MusicTrack( rw ));
num_mmmmmm_tracks++;
index_++;
}
bool ohCrap = pppppp_blob.unPackBinary("vvvvvvmusic.vvv");
SDL_assert(ohCrap && "Music not found!");
TRACK_NAMES(pppppp_blob)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
De-duplicate track names Instead of copy-pasting the entire list three times over, why not put it in an easy to use "X" macro?
2020-07-01 00:17:02 +02:00
#undef FOREACH_TRACK
Clean up and harden music loading code During review of #869, I looked at this part of the codebase again. I have no idea how or why, but during the course of 2.4 this whole area just became a mess. The issues I fixed (in no particular order): - Copy-pasting the code that loads from the binary blobs - Making sure SDL_RWFromConstMem is used over SDL_RWFromMem wherever possible - Adding checks to make sure the index from the binary blob is valid (it's possible it could not exist) - Adding checks to make sure we gracefully handle SDL_RWFromConstMem/PHYSFSRWOPS_openRead returning NULL - Moving the pointer asterisk to the type instead of the name :)
2022-03-24 17:35:01 +01:00
#undef TRACK_LOAD_BLOB
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
num_pppppp_tracks += musicTracks.size() - num_mmmmmm_tracks;
Account for extra tracks in musicclass::play() Since each soundtrack is no longer guaranteed to be 16, we'll have to account for their different lengths when playing music.
2020-07-01 02:08:37 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
SDL_RWops* rw;
size_t index_ = 0;
while (pppppp_blob.nextExtra(&index_))
{
rw = SDL_RWFromConstMem(pppppp_blob.getAddress(index_), pppppp_blob.getSize(index_));
musicTracks.push_back(MusicTrack( rw ));
Account for extra tracks in musicclass::play() Since each soundtrack is no longer guaranteed to be 16, we'll have to account for their different lengths when playing music.
2020-07-01 02:08:37 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
num_pppppp_tracks++;
index_++;
}
Fix resumemusic/musicfadein not working It seems like they were unfinished. This commit makes them properly work. When a track is stopped with stopmusic() or musicfadeout(), resumemusic() will resume from where the track stopped. musicfadein() does the same but does it with a gradual fade instead of suddenly playing it at full volume. I changed several interfaces around for this. First, setting currentsong to -1 when music is stopped is handled in the hook callback that gets called by SDL_mixer whenever the music stops. Otherwise, it'd be problematic if currentsong was set to -1 when the song starts fading out instead of when the song actually ends. Also, music.play() has a few optional arguments now, to reduce the copying-and-pasting of music code. Lastly, we have to roll our own tracker of music length by using SDL_GetPerformanceCounter(), because there's no way to get the music position if a song fades out. (We could implicitly keep the music position if we abruptly stopped the song using Mix_PauseMusic(), and resume it using Mix_ResumeMusic(), but ignoring the fact that those two functions are also used on the unfocus-pause (which, as it turns out, is basically a non-issue because the unfocus-pause can use some other functions), there's no equivalent for fading out, i.e. there's no "fade out and pause when it fully fades out" function in SDL_mixer.) And then we have to account for the unfocus-pause in our manual tracker. Other than that, these commands are now fully functional.
2020-06-27 10:31:09 +02:00
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void musicclass::destroy(void)
Move musicclass cleanup to separate function musicclass::destroy() This removes the music cleanup code from musicclass::init(), and requires that we also call destroy() in Graphics::reloadresources(). This is because we'll need to re-use the musicclass cleanup code elsewhere, and we don't want to copy-paste the cleanup code. Or at least, I don't (but I'm not a game dev, game devs copy-paste all the friggin' time).
2021-02-16 01:24:21 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
for (size_t i = 0; i < soundTracks.size(); ++i)
{
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
soundTracks[i].Dispose();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
soundTracks.clear();
Port to FAudio
2022-03-09 22:35:29 +01:00
SoundTrack::Destroy();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
for (size_t i = 0; i < musicTracks.size(); ++i)
{
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
musicTracks[i].Dispose();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
musicTracks.clear();
pppppp_blob.clear();
mmmmmm_blob.clear();
Replace all free calls with `VVV_free[func]` This replaces all calls to SDL_free with a new macro, VVV_free, that nulls the pointer afterwards. This mitigates any use-after-frees and also completely eliminates double-frees. The same is done for any function to free specific objects such as SDL_FreeSurface, with the VVV_freefunc macro. No exceptions for any of these calls, even if the pointer is discarded or zeroed afterwards anyway. Better safe than sorry. This is a macro rather than a function that takes in a pointer-to-pointer because such a function would have type issues that require casting and that's just not safe. Even though SDL_free and other SDL functions already check for NULL, the macro has a NULL check for other functions that don't. For example, FAudioVoice_DestroyVoice does not check for NULL. FILESYSTEM_freeMemory has been axed in favor of VVV_free because it functionally does the same thing except for `unsigned char*` only.
2022-12-01 07:30:16 +01:00
VVV_freefunc(FAudioVoice_DestroyVoice, masteringvoice);
VVV_freefunc(FAudio_Release, faudioctx);
Move musicclass cleanup to separate function musicclass::destroy() This removes the music cleanup code from musicclass::init(), and requires that we also call destroy() in Graphics::reloadresources(). This is because we'll need to re-use the musicclass cleanup code elsewhere, and we don't want to copy-paste the cleanup code. Or at least, I don't (but I'm not a game dev, game devs copy-paste all the friggin' time).
2021-02-16 01:24:21 +01:00
}
Re-fix resumemusic/musicfadein once again So it looks like facb079b3597b380f876537523cd351a0e637b62 (PR #316) had a few issues. The SDL performance counter doesn't really work that well. Testing reveals that unfocusing and focusing the game again results in the resumemusic() script command resuming the track at the wrong time. Even when not unfocusing the game at all, stopping a track and resuming it resumes it at the wrong time. (Only disabling the unfocus pause fixes this.) Furthermore, there's also the fact that the SDL performance counter keeps incrementing when the game is paused under GDB. So... yeah. Instead of dealing with the SDL performance counter, I'm just going to pause and resume the music directly (so the stopmusic() script command just pauses the music instead). As a result, we no longer can keep constantly calling Mix_PauseMusic() or Mix_ResumeMusic() when focused or unfocused, so I've moved those calls to happen directly when the relevant SDL events are received (the constant calls were originally in VCE, and whoever added them (I'm pretty sure it was Leo) was not the sharpest tool in the shed...). And we are going to switch over to using our own fade system instead of the SDL mixer fade system. In fact, we were already using our own fade system for fadeins after collecting a trinket or a custom level crewmate, but we were still using the mixer system for the rest. This is an inconsistency that I am glad to correct, so we're also doing our own fadeouts now. There is, however, an issue with the fade system where the length it goes for is inaccurate, because it's based on a volume-per-frame second calculation that gets truncated. But that's an issue to fix later - at least what I'm doing right now makes resumemusic() and musicfadein() work better than before.
2021-04-02 21:56:25 +02:00
void musicclass::play(int t)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (mmmmmm && usingmmmmmm)
{
// Don't conjoin this if-statement with the above one...
if (num_mmmmmm_tracks > 0)
{
t %= num_mmmmmm_tracks;
}
}
else if (num_pppppp_tracks > 0)
{
t %= num_pppppp_tracks;
}
if (mmmmmm && !usingmmmmmm)
{
t += num_mmmmmm_tracks;
}
safeToProcessMusic = true;
if (currentsong == t && !m_doFadeOutVol)
{
return;
}
currentsong = t;
Implement haltedsong This fixes a bug where if a track was resumed, pausing it by unfocusing the window (if enabled, of course) would not resume it after refocusing the window. This happens because resuming the music doesn't change currentsong back from -1, and the window refocusing code checks that currentsong isn't -1 before resuming music. haltedsong is only used when resuming music. It is set back to -1 when resuming music or when playing a new track.
2023-06-09 00:38:26 +02:00
haltedsong = -1;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (t == -1)
{
return;
}
if (!INBOUNDS_VEC(t, musicTracks))
{
vlog_error("play() out-of-bounds!");
currentsong = -1;
return;
}
Use enums for music tracks This adds an anonymous enum for music tracks and replaces all calls to music.play and music.niceplay that use integer literals. Additionally, this is also done for integer literals for cl.levmusic (except 0) and music.currentsong where appropriate, but _not_ the music areamap because that would not make it look very aesthetically pleasing in the code. This is not a named enum (that can be used for strict typechecking) because music track IDs are essentially part of the API of the game - almost every custom level uses these numbers. This is just to make the source code more readable without needing a comment to denote what number is what track.
2023-05-24 03:37:32 +02:00
if (currentsong == Music_PATHCOMPLETE ||
currentsong == Music_PLENARY ||
(!map.custommode && (currentsong == Music_PATHCOMPLETE + num_mmmmmm_tracks
|| currentsong == Music_PLENARY + num_mmmmmm_tracks)))
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
Use enums for music tracks This adds an anonymous enum for music tracks and replaces all calls to music.play and music.niceplay that use integer literals. Additionally, this is also done for integer literals for cl.levmusic (except 0) and music.currentsong where appropriate, but _not_ the music areamap because that would not make it look very aesthetically pleasing in the code. This is not a named enum (that can be used for strict typechecking) because music track IDs are essentially part of the API of the game - almost every custom level uses these numbers. This is just to make the source code more readable without needing a comment to denote what number is what track.
2023-05-24 03:37:32 +02:00
// No fade in or repeat
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
if (musicTracks[t].Play(false))
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
m_doFadeInVol = false;
m_doFadeOutVol = false;
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
musicVolume = VVV_MAX_VOLUME;
MusicTrack::SetVolume(musicVolume);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
}
else
{
if (m_doFadeOutVol)
{
// We're already fading out
nicechange = t;
nicefade = true;
currentsong = -1;
if (quick_fade)
{
fadeMusicVolumeOut(500); // fade out quicker
}
else
{
quick_fade = true;
}
}
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
else if (musicTracks[t].Play(true))
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
m_doFadeInVol = false;
m_doFadeOutVol = false;
fadeMusicVolumeIn(3000);
}
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Style: Fixup instances of `void` arguments The style we have here is that functions with no arguments are to have explicit `void` arguments, even though this doesn't apply in C++, because it does apply in C. Unfortunately, some have slipped through the cracks. This commit fixes them.
2023-03-18 23:24:14 +01:00
void musicclass::resume(void)
Fix resumemusic/musicfadein not working It seems like they were unfinished. This commit makes them properly work. When a track is stopped with stopmusic() or musicfadeout(), resumemusic() will resume from where the track stopped. musicfadein() does the same but does it with a gradual fade instead of suddenly playing it at full volume. I changed several interfaces around for this. First, setting currentsong to -1 when music is stopped is handled in the hook callback that gets called by SDL_mixer whenever the music stops. Otherwise, it'd be problematic if currentsong was set to -1 when the song starts fading out instead of when the song actually ends. Also, music.play() has a few optional arguments now, to reduce the copying-and-pasting of music code. Lastly, we have to roll our own tracker of music length by using SDL_GetPerformanceCounter(), because there's no way to get the music position if a song fades out. (We could implicitly keep the music position if we abruptly stopped the song using Mix_PauseMusic(), and resume it using Mix_ResumeMusic(), but ignoring the fact that those two functions are also used on the unfocus-pause (which, as it turns out, is basically a non-issue because the unfocus-pause can use some other functions), there's no equivalent for fading out, i.e. there's no "fade out and pause when it fully fades out" function in SDL_mixer.) And then we have to account for the unfocus-pause in our manual tracker. Other than that, these commands are now fully functional.
2020-06-27 10:31:09 +02:00
{
Implement haltedsong This fixes a bug where if a track was resumed, pausing it by unfocusing the window (if enabled, of course) would not resume it after refocusing the window. This happens because resuming the music doesn't change currentsong back from -1, and the window refocusing code checks that currentsong isn't -1 before resuming music. haltedsong is only used when resuming music. It is set back to -1 when resuming music or when playing a new track.
2023-06-09 00:38:26 +02:00
if (currentsong == -1)
{
currentsong = haltedsong;
haltedsong = -1;
}
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
MusicTrack::Resume();
Re-fix resumemusic/musicfadein once again So it looks like facb079b3597b380f876537523cd351a0e637b62 (PR #316) had a few issues. The SDL performance counter doesn't really work that well. Testing reveals that unfocusing and focusing the game again results in the resumemusic() script command resuming the track at the wrong time. Even when not unfocusing the game at all, stopping a track and resuming it resumes it at the wrong time. (Only disabling the unfocus pause fixes this.) Furthermore, there's also the fact that the SDL performance counter keeps incrementing when the game is paused under GDB. So... yeah. Instead of dealing with the SDL performance counter, I'm just going to pause and resume the music directly (so the stopmusic() script command just pauses the music instead). As a result, we no longer can keep constantly calling Mix_PauseMusic() or Mix_ResumeMusic() when focused or unfocused, so I've moved those calls to happen directly when the relevant SDL events are received (the constant calls were originally in VCE, and whoever added them (I'm pretty sure it was Leo) was not the sharpest tool in the shed...). And we are going to switch over to using our own fade system instead of the SDL mixer fade system. In fact, we were already using our own fade system for fadeins after collecting a trinket or a custom level crewmate, but we were still using the mixer system for the rest. This is an inconsistency that I am glad to correct, so we're also doing our own fadeouts now. There is, however, an issue with the fade system where the length it goes for is inaccurate, because it's based on a volume-per-frame second calculation that gets truncated. But that's an issue to fix later - at least what I'm doing right now makes resumemusic() and musicfadein() work better than before.
2021-04-02 21:56:25 +02:00
}
Fix resumemusic/musicfadein not working It seems like they were unfinished. This commit makes them properly work. When a track is stopped with stopmusic() or musicfadeout(), resumemusic() will resume from where the track stopped. musicfadein() does the same but does it with a gradual fade instead of suddenly playing it at full volume. I changed several interfaces around for this. First, setting currentsong to -1 when music is stopped is handled in the hook callback that gets called by SDL_mixer whenever the music stops. Otherwise, it'd be problematic if currentsong was set to -1 when the song starts fading out instead of when the song actually ends. Also, music.play() has a few optional arguments now, to reduce the copying-and-pasting of music code. Lastly, we have to roll our own tracker of music length by using SDL_GetPerformanceCounter(), because there's no way to get the music position if a song fades out. (We could implicitly keep the music position if we abruptly stopped the song using Mix_PauseMusic(), and resume it using Mix_ResumeMusic(), but ignoring the fact that those two functions are also used on the unfocus-pause (which, as it turns out, is basically a non-issue because the unfocus-pause can use some other functions), there's no equivalent for fading out, i.e. there's no "fade out and pause when it fully fades out" function in SDL_mixer.) And then we have to account for the unfocus-pause in our manual tracker. Other than that, these commands are now fully functional.
2020-06-27 10:31:09 +02:00
Re-fix resumemusic/musicfadein once again So it looks like facb079b3597b380f876537523cd351a0e637b62 (PR #316) had a few issues. The SDL performance counter doesn't really work that well. Testing reveals that unfocusing and focusing the game again results in the resumemusic() script command resuming the track at the wrong time. Even when not unfocusing the game at all, stopping a track and resuming it resumes it at the wrong time. (Only disabling the unfocus pause fixes this.) Furthermore, there's also the fact that the SDL performance counter keeps incrementing when the game is paused under GDB. So... yeah. Instead of dealing with the SDL performance counter, I'm just going to pause and resume the music directly (so the stopmusic() script command just pauses the music instead). As a result, we no longer can keep constantly calling Mix_PauseMusic() or Mix_ResumeMusic() when focused or unfocused, so I've moved those calls to happen directly when the relevant SDL events are received (the constant calls were originally in VCE, and whoever added them (I'm pretty sure it was Leo) was not the sharpest tool in the shed...). And we are going to switch over to using our own fade system instead of the SDL mixer fade system. In fact, we were already using our own fade system for fadeins after collecting a trinket or a custom level crewmate, but we were still using the mixer system for the rest. This is an inconsistency that I am glad to correct, so we're also doing our own fadeouts now. There is, however, an issue with the fade system where the length it goes for is inaccurate, because it's based on a volume-per-frame second calculation that gets truncated. But that's an issue to fix later - at least what I'm doing right now makes resumemusic() and musicfadein() work better than before.
2021-04-02 21:56:25 +02:00
void musicclass::resumefade(const int fadein_ms)
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
resume();
fadeMusicVolumeIn(fadein_ms);
Fix resumemusic/musicfadein not working It seems like they were unfinished. This commit makes them properly work. When a track is stopped with stopmusic() or musicfadeout(), resumemusic() will resume from where the track stopped. musicfadein() does the same but does it with a gradual fade instead of suddenly playing it at full volume. I changed several interfaces around for this. First, setting currentsong to -1 when music is stopped is handled in the hook callback that gets called by SDL_mixer whenever the music stops. Otherwise, it'd be problematic if currentsong was set to -1 when the song starts fading out instead of when the song actually ends. Also, music.play() has a few optional arguments now, to reduce the copying-and-pasting of music code. Lastly, we have to roll our own tracker of music length by using SDL_GetPerformanceCounter(), because there's no way to get the music position if a song fades out. (We could implicitly keep the music position if we abruptly stopped the song using Mix_PauseMusic(), and resume it using Mix_ResumeMusic(), but ignoring the fact that those two functions are also used on the unfocus-pause (which, as it turns out, is basically a non-issue because the unfocus-pause can use some other functions), there's no equivalent for fading out, i.e. there's no "fade out and pause when it fully fades out" function in SDL_mixer.) And then we have to account for the unfocus-pause in our manual tracker. Other than that, these commands are now fully functional.
2020-06-27 10:31:09 +02:00
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void musicclass::fadein(void)
Fix resumemusic/musicfadein not working It seems like they were unfinished. This commit makes them properly work. When a track is stopped with stopmusic() or musicfadeout(), resumemusic() will resume from where the track stopped. musicfadein() does the same but does it with a gradual fade instead of suddenly playing it at full volume. I changed several interfaces around for this. First, setting currentsong to -1 when music is stopped is handled in the hook callback that gets called by SDL_mixer whenever the music stops. Otherwise, it'd be problematic if currentsong was set to -1 when the song starts fading out instead of when the song actually ends. Also, music.play() has a few optional arguments now, to reduce the copying-and-pasting of music code. Lastly, we have to roll our own tracker of music length by using SDL_GetPerformanceCounter(), because there's no way to get the music position if a song fades out. (We could implicitly keep the music position if we abruptly stopped the song using Mix_PauseMusic(), and resume it using Mix_ResumeMusic(), but ignoring the fact that those two functions are also used on the unfocus-pause (which, as it turns out, is basically a non-issue because the unfocus-pause can use some other functions), there's no equivalent for fading out, i.e. there's no "fade out and pause when it fully fades out" function in SDL_mixer.) And then we have to account for the unfocus-pause in our manual tracker. Other than that, these commands are now fully functional.
2020-06-27 10:31:09 +02:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
resumefade(3000); // 3000 ms fadein
Fix resumemusic/musicfadein not working It seems like they were unfinished. This commit makes them properly work. When a track is stopped with stopmusic() or musicfadeout(), resumemusic() will resume from where the track stopped. musicfadein() does the same but does it with a gradual fade instead of suddenly playing it at full volume. I changed several interfaces around for this. First, setting currentsong to -1 when music is stopped is handled in the hook callback that gets called by SDL_mixer whenever the music stops. Otherwise, it'd be problematic if currentsong was set to -1 when the song starts fading out instead of when the song actually ends. Also, music.play() has a few optional arguments now, to reduce the copying-and-pasting of music code. Lastly, we have to roll our own tracker of music length by using SDL_GetPerformanceCounter(), because there's no way to get the music position if a song fades out. (We could implicitly keep the music position if we abruptly stopped the song using Mix_PauseMusic(), and resume it using Mix_ResumeMusic(), but ignoring the fact that those two functions are also used on the unfocus-pause (which, as it turns out, is basically a non-issue because the unfocus-pause can use some other functions), there's no equivalent for fading out, i.e. there's no "fade out and pause when it fully fades out" function in SDL_mixer.) And then we have to account for the unfocus-pause in our manual tracker. Other than that, these commands are now fully functional.
2020-06-27 10:31:09 +02:00
}
Add pause(), pauseef(), and resumeef() to musicclass musicclass already had a resume() function for music. These are just wrappers around the appropriate SDL_mixer functions, to avoid direct function calls to the mixer API. So if we ever need to do something with all callers of pausing and resuming in the future, or we switch to a different audio backend, the work is already done for us. Also it just looks cleaner to be calling our musicclass function instead of doing a direct API call to the mixer.
2021-04-02 21:07:19 +02:00
void musicclass::pause(void)
{
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
MusicTrack::Pause();
Add pause(), pauseef(), and resumeef() to musicclass musicclass already had a resume() function for music. These are just wrappers around the appropriate SDL_mixer functions, to avoid direct function calls to the mixer API. So if we ever need to do something with all callers of pausing and resuming in the future, or we switch to a different audio backend, the work is already done for us. Also it just looks cleaner to be calling our musicclass function instead of doing a direct API call to the mixer.
2021-04-02 21:07:19 +02:00
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void musicclass::haltdasmusik(void)
Fix regression with music fade transitions not working Unfortunately, 1de459d9b414180d5049cbf153266a8d6e00c227 caused a regression where musicclass::niceplay() didn't work, because fading out the music would cause haltdasmusik() to be called, which would reset the fade variables. To fix this, haltdasmusik() will now only reset the fade variables if it's not called from a fade, which is signaled with a function parameter.
2023-04-06 04:32:42 +02:00
{
haltdasmusik(false);
}
void musicclass::haltdasmusik(const bool from_fade)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
/* Just pauses music. This is intended. */
pause();
Implement haltedsong This fixes a bug where if a track was resumed, pausing it by unfocusing the window (if enabled, of course) would not resume it after refocusing the window. This happens because resuming the music doesn't change currentsong back from -1, and the window refocusing code checks that currentsong isn't -1 before resuming music. haltedsong is only used when resuming music. It is set back to -1 when resuming music or when playing a new track.
2023-06-09 00:38:26 +02:00
haltedsong = currentsong;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
currentsong = -1;
m_doFadeInVol = false;
m_doFadeOutVol = false;
Fix regression with music fade transitions not working Unfortunately, 1de459d9b414180d5049cbf153266a8d6e00c227 caused a regression where musicclass::niceplay() didn't work, because fading out the music would cause haltdasmusik() to be called, which would reset the fade variables. To fix this, haltdasmusik() will now only reset the fade variables if it's not called from a fade, which is signaled with a function parameter.
2023-04-06 04:32:42 +02:00
if (!from_fade)
{
nicefade = false;
nicechange = -1;
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void musicclass::silencedasmusik(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
musicVolume = 0;
Reset fade booleans when silencing music This fixes a bug where the music would keep playing when a collection prompt appeared if the music was still fading in at that time.
2021-09-11 02:02:24 +02:00
m_doFadeInVol = false;
m_doFadeOutVol = false;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Fix fade volume durations being incorrect The previous fade system used only one variable, the amount of volume to fade per frame. However, this variable was an integer, meaning any decimal portion would be truncated, and would lead to a longer fade duration than intended. The fade per volume is calculated by doing MIX_MAX_VOLUME / (fade_ms / game.get_timestep()). MIX_MAX_VOLUME is 128, and game.get_timestep() is usually 34, so a 3000 millisecond fade would be calculated as 128 / (3000 / 34). 3000 / 34 is 88.235..., but that gets truncated to 88, and then 128 / 88 becomes 1.454545..., which then gets truncated to 1. This essentially means 1 is added to or subtracted from the volume every frame, and given that the max volume is 128, this means that the fade lasts for 128 frames. Now, instead of the fade duration lasting 3 seconds, the fade now lasts for 128 frames, which is 128 * 34 / 1000 = 4.352 seconds long. This could be fixed using floats, but when you introduce floats, you now have 1.9999998 problems. For instance, I'm concerned about floating-point determinism issues. What I've done instead is switch the system to use four different variables instead: the start volume, the end volume, the total duration, and the duration completed so far (called the "step"). For every frame, the game interpolates which value should be used based on the step, the total duration, and the start and end volumes, and then adds the timestep to the step. This way, fades will be correctly timed, and we don't have potential determinism issues. Doing this also fixes inaccuracies with the game timestep changing during the fade, since the timestep is only used in the calculation once at the beginning in the previous system.
2021-04-28 01:37:16 +02:00
struct FadeState
Factor fade amount calculation to separate function This makes it so to reuse this code, we don't have to copy-paste it. Additionally, I added a check for the milliseconds being 0, to avoid a division by zero. Logically and mathematically, if the fade amount is 0 milliseconds, then that means the fade should happen instantly - however, dividing by zero is undefined (both in math and in C/C++), so this check needs to be added.
2021-04-02 21:02:01 +02:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
int start_volume;
int end_volume;
int duration_ms;
int step_ms;
Fix fade volume durations being incorrect The previous fade system used only one variable, the amount of volume to fade per frame. However, this variable was an integer, meaning any decimal portion would be truncated, and would lead to a longer fade duration than intended. The fade per volume is calculated by doing MIX_MAX_VOLUME / (fade_ms / game.get_timestep()). MIX_MAX_VOLUME is 128, and game.get_timestep() is usually 34, so a 3000 millisecond fade would be calculated as 128 / (3000 / 34). 3000 / 34 is 88.235..., but that gets truncated to 88, and then 128 / 88 becomes 1.454545..., which then gets truncated to 1. This essentially means 1 is added to or subtracted from the volume every frame, and given that the max volume is 128, this means that the fade lasts for 128 frames. Now, instead of the fade duration lasting 3 seconds, the fade now lasts for 128 frames, which is 128 * 34 / 1000 = 4.352 seconds long. This could be fixed using floats, but when you introduce floats, you now have 1.9999998 problems. For instance, I'm concerned about floating-point determinism issues. What I've done instead is switch the system to use four different variables instead: the start volume, the end volume, the total duration, and the duration completed so far (called the "step"). For every frame, the game interpolates which value should be used based on the step, the total duration, and the start and end volumes, and then adds the timestep to the step. This way, fades will be correctly timed, and we don't have potential determinism issues. Doing this also fixes inaccuracies with the game timestep changing during the fade, since the timestep is only used in the calculation once at the beginning in the previous system.
2021-04-28 01:37:16 +02:00
};
static struct FadeState fade;
enum FadeCode
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
Fade_continue,
Fade_finished
Fix fade volume durations being incorrect The previous fade system used only one variable, the amount of volume to fade per frame. However, this variable was an integer, meaning any decimal portion would be truncated, and would lead to a longer fade duration than intended. The fade per volume is calculated by doing MIX_MAX_VOLUME / (fade_ms / game.get_timestep()). MIX_MAX_VOLUME is 128, and game.get_timestep() is usually 34, so a 3000 millisecond fade would be calculated as 128 / (3000 / 34). 3000 / 34 is 88.235..., but that gets truncated to 88, and then 128 / 88 becomes 1.454545..., which then gets truncated to 1. This essentially means 1 is added to or subtracted from the volume every frame, and given that the max volume is 128, this means that the fade lasts for 128 frames. Now, instead of the fade duration lasting 3 seconds, the fade now lasts for 128 frames, which is 128 * 34 / 1000 = 4.352 seconds long. This could be fixed using floats, but when you introduce floats, you now have 1.9999998 problems. For instance, I'm concerned about floating-point determinism issues. What I've done instead is switch the system to use four different variables instead: the start volume, the end volume, the total duration, and the duration completed so far (called the "step"). For every frame, the game interpolates which value should be used based on the step, the total duration, and the start and end volumes, and then adds the timestep to the step. This way, fades will be correctly timed, and we don't have potential determinism issues. Doing this also fixes inaccuracies with the game timestep changing during the fade, since the timestep is only used in the calculation once at the beginning in the previous system.
2021-04-28 01:37:16 +02:00
};
static enum FadeCode processmusicfade(struct FadeState* state, int* volume)
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
int range;
int new_volume;
Fix fade volume durations being incorrect The previous fade system used only one variable, the amount of volume to fade per frame. However, this variable was an integer, meaning any decimal portion would be truncated, and would lead to a longer fade duration than intended. The fade per volume is calculated by doing MIX_MAX_VOLUME / (fade_ms / game.get_timestep()). MIX_MAX_VOLUME is 128, and game.get_timestep() is usually 34, so a 3000 millisecond fade would be calculated as 128 / (3000 / 34). 3000 / 34 is 88.235..., but that gets truncated to 88, and then 128 / 88 becomes 1.454545..., which then gets truncated to 1. This essentially means 1 is added to or subtracted from the volume every frame, and given that the max volume is 128, this means that the fade lasts for 128 frames. Now, instead of the fade duration lasting 3 seconds, the fade now lasts for 128 frames, which is 128 * 34 / 1000 = 4.352 seconds long. This could be fixed using floats, but when you introduce floats, you now have 1.9999998 problems. For instance, I'm concerned about floating-point determinism issues. What I've done instead is switch the system to use four different variables instead: the start volume, the end volume, the total duration, and the duration completed so far (called the "step"). For every frame, the game interpolates which value should be used based on the step, the total duration, and the start and end volumes, and then adds the timestep to the step. This way, fades will be correctly timed, and we don't have potential determinism issues. Doing this also fixes inaccuracies with the game timestep changing during the fade, since the timestep is only used in the calculation once at the beginning in the previous system.
2021-04-28 01:37:16 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (state->duration_ms == 0 /* Fast path. */
|| state->start_volume == state->end_volume /* Fast path. */
|| state->step_ms >= state->duration_ms /* We're finished. */)
{
*volume = state->end_volume;
state->step_ms = 0;
return Fade_finished;
}
Fix fade volume durations being incorrect The previous fade system used only one variable, the amount of volume to fade per frame. However, this variable was an integer, meaning any decimal portion would be truncated, and would lead to a longer fade duration than intended. The fade per volume is calculated by doing MIX_MAX_VOLUME / (fade_ms / game.get_timestep()). MIX_MAX_VOLUME is 128, and game.get_timestep() is usually 34, so a 3000 millisecond fade would be calculated as 128 / (3000 / 34). 3000 / 34 is 88.235..., but that gets truncated to 88, and then 128 / 88 becomes 1.454545..., which then gets truncated to 1. This essentially means 1 is added to or subtracted from the volume every frame, and given that the max volume is 128, this means that the fade lasts for 128 frames. Now, instead of the fade duration lasting 3 seconds, the fade now lasts for 128 frames, which is 128 * 34 / 1000 = 4.352 seconds long. This could be fixed using floats, but when you introduce floats, you now have 1.9999998 problems. For instance, I'm concerned about floating-point determinism issues. What I've done instead is switch the system to use four different variables instead: the start volume, the end volume, the total duration, and the duration completed so far (called the "step"). For every frame, the game interpolates which value should be used based on the step, the total duration, and the start and end volumes, and then adds the timestep to the step. This way, fades will be correctly timed, and we don't have potential determinism issues. Doing this also fixes inaccuracies with the game timestep changing during the fade, since the timestep is only used in the calculation once at the beginning in the previous system.
2021-04-28 01:37:16 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
range = state->end_volume - state->start_volume;
new_volume = range * state->step_ms / state->duration_ms;
new_volume += state->start_volume;
Fix fade volume durations being incorrect The previous fade system used only one variable, the amount of volume to fade per frame. However, this variable was an integer, meaning any decimal portion would be truncated, and would lead to a longer fade duration than intended. The fade per volume is calculated by doing MIX_MAX_VOLUME / (fade_ms / game.get_timestep()). MIX_MAX_VOLUME is 128, and game.get_timestep() is usually 34, so a 3000 millisecond fade would be calculated as 128 / (3000 / 34). 3000 / 34 is 88.235..., but that gets truncated to 88, and then 128 / 88 becomes 1.454545..., which then gets truncated to 1. This essentially means 1 is added to or subtracted from the volume every frame, and given that the max volume is 128, this means that the fade lasts for 128 frames. Now, instead of the fade duration lasting 3 seconds, the fade now lasts for 128 frames, which is 128 * 34 / 1000 = 4.352 seconds long. This could be fixed using floats, but when you introduce floats, you now have 1.9999998 problems. For instance, I'm concerned about floating-point determinism issues. What I've done instead is switch the system to use four different variables instead: the start volume, the end volume, the total duration, and the duration completed so far (called the "step"). For every frame, the game interpolates which value should be used based on the step, the total duration, and the start and end volumes, and then adds the timestep to the step. This way, fades will be correctly timed, and we don't have potential determinism issues. Doing this also fixes inaccuracies with the game timestep changing during the fade, since the timestep is only used in the calculation once at the beginning in the previous system.
2021-04-28 01:37:16 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
*volume = new_volume;
Fix fade volume durations being incorrect The previous fade system used only one variable, the amount of volume to fade per frame. However, this variable was an integer, meaning any decimal portion would be truncated, and would lead to a longer fade duration than intended. The fade per volume is calculated by doing MIX_MAX_VOLUME / (fade_ms / game.get_timestep()). MIX_MAX_VOLUME is 128, and game.get_timestep() is usually 34, so a 3000 millisecond fade would be calculated as 128 / (3000 / 34). 3000 / 34 is 88.235..., but that gets truncated to 88, and then 128 / 88 becomes 1.454545..., which then gets truncated to 1. This essentially means 1 is added to or subtracted from the volume every frame, and given that the max volume is 128, this means that the fade lasts for 128 frames. Now, instead of the fade duration lasting 3 seconds, the fade now lasts for 128 frames, which is 128 * 34 / 1000 = 4.352 seconds long. This could be fixed using floats, but when you introduce floats, you now have 1.9999998 problems. For instance, I'm concerned about floating-point determinism issues. What I've done instead is switch the system to use four different variables instead: the start volume, the end volume, the total duration, and the duration completed so far (called the "step"). For every frame, the game interpolates which value should be used based on the step, the total duration, and the start and end volumes, and then adds the timestep to the step. This way, fades will be correctly timed, and we don't have potential determinism issues. Doing this also fixes inaccuracies with the game timestep changing during the fade, since the timestep is only used in the calculation once at the beginning in the previous system.
2021-04-28 01:37:16 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
state->step_ms += game.get_timestep();
Fix fade volume durations being incorrect The previous fade system used only one variable, the amount of volume to fade per frame. However, this variable was an integer, meaning any decimal portion would be truncated, and would lead to a longer fade duration than intended. The fade per volume is calculated by doing MIX_MAX_VOLUME / (fade_ms / game.get_timestep()). MIX_MAX_VOLUME is 128, and game.get_timestep() is usually 34, so a 3000 millisecond fade would be calculated as 128 / (3000 / 34). 3000 / 34 is 88.235..., but that gets truncated to 88, and then 128 / 88 becomes 1.454545..., which then gets truncated to 1. This essentially means 1 is added to or subtracted from the volume every frame, and given that the max volume is 128, this means that the fade lasts for 128 frames. Now, instead of the fade duration lasting 3 seconds, the fade now lasts for 128 frames, which is 128 * 34 / 1000 = 4.352 seconds long. This could be fixed using floats, but when you introduce floats, you now have 1.9999998 problems. For instance, I'm concerned about floating-point determinism issues. What I've done instead is switch the system to use four different variables instead: the start volume, the end volume, the total duration, and the duration completed so far (called the "step"). For every frame, the game interpolates which value should be used based on the step, the total duration, and the start and end volumes, and then adds the timestep to the step. This way, fades will be correctly timed, and we don't have potential determinism issues. Doing this also fixes inaccuracies with the game timestep changing during the fade, since the timestep is only used in the calculation once at the beginning in the previous system.
2021-04-28 01:37:16 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
return Fade_continue;
Factor fade amount calculation to separate function This makes it so to reuse this code, we don't have to copy-paste it. Additionally, I added a check for the milliseconds being 0, to avoid a division by zero. Logically and mathematically, if the fade amount is 0 milliseconds, then that means the fade should happen instantly - however, dividing by zero is undefined (both in math and in C/C++), so this check needs to be added.
2021-04-02 21:02:01 +02:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
void musicclass::fadeMusicVolumeIn(int ms)
{
Music: Do not do fades if not playing This fixes a regression where entering playtesting while a track was fading out (by exiting out of playtesting with a track playing and then immediately entering back in with the level start music set) would result in no music. The cause is the game doing fades even though nothing is playing, which puts it in a confusing state.
2021-09-11 04:37:33 +02:00
if (halted())
{
return;
}
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
m_doFadeInVol = true;
m_doFadeOutVol = false;
Ensure all fade-ins start from zero This fixes a bug where fading music in but not going through the music.play() path wouldn't start the fade volume from zero. If this happened, then the previous volume would persist, and if the previous volume was the max volume, then that essentially canceled out the fade-in and prevented it from happening at all. But now all paths to fadeMusicVolumeIn() set the volume to zero first, instead of only the caller of music.play().
2021-04-12 19:38:44 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
/* Ensure it starts at 0 */
musicVolume = 0;
Ensure all fade-ins start from zero This fixes a bug where fading music in but not going through the music.play() path wouldn't start the fade volume from zero. If this happened, then the previous volume would persist, and if the previous volume was the max volume, then that essentially canceled out the fade-in and prevented it from happening at all. But now all paths to fadeMusicVolumeIn() set the volume to zero first, instead of only the caller of music.play().
2021-04-12 19:38:44 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
/* Fix 1-frame glitch */
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
MusicTrack::SetVolume(0);
Fix 1-frame glitch when fading in from zero The problem here is that even though we start playing the music when the volume is set to zero, mixer's state doesn't have volume zero, so whatever it plays next will be the very first quanta of the track but at the previous volume (in this case, the maximum volume). To fix this, just update mixer when we update the volume here - it's okay to not account for user volume because it ends up being zero anyway. Fixes #710.
2021-04-12 19:41:44 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
fade.step_ms = 0;
fade.duration_ms = ms;
fade.start_volume = 0;
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
fade.end_volume = VVV_MAX_VOLUME;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Re-fix resumemusic/musicfadein once again So it looks like facb079b3597b380f876537523cd351a0e637b62 (PR #316) had a few issues. The SDL performance counter doesn't really work that well. Testing reveals that unfocusing and focusing the game again results in the resumemusic() script command resuming the track at the wrong time. Even when not unfocusing the game at all, stopping a track and resuming it resumes it at the wrong time. (Only disabling the unfocus pause fixes this.) Furthermore, there's also the fact that the SDL performance counter keeps incrementing when the game is paused under GDB. So... yeah. Instead of dealing with the SDL performance counter, I'm just going to pause and resume the music directly (so the stopmusic() script command just pauses the music instead). As a result, we no longer can keep constantly calling Mix_PauseMusic() or Mix_ResumeMusic() when focused or unfocused, so I've moved those calls to happen directly when the relevant SDL events are received (the constant calls were originally in VCE, and whoever added them (I'm pretty sure it was Leo) was not the sharpest tool in the shed...). And we are going to switch over to using our own fade system instead of the SDL mixer fade system. In fact, we were already using our own fade system for fadeins after collecting a trinket or a custom level crewmate, but we were still using the mixer system for the rest. This is an inconsistency that I am glad to correct, so we're also doing our own fadeouts now. There is, however, an issue with the fade system where the length it goes for is inaccurate, because it's based on a volume-per-frame second calculation that gets truncated. But that's an issue to fix later - at least what I'm doing right now makes resumemusic() and musicfadein() work better than before.
2021-04-02 21:56:25 +02:00
void musicclass::fadeMusicVolumeOut(const int fadeout_ms)
{
Music: Do not do fades if not playing This fixes a regression where entering playtesting while a track was fading out (by exiting out of playtesting with a track playing and then immediately entering back in with the level start music set) would result in no music. The cause is the game doing fades even though nothing is playing, which puts it in a confusing state.
2021-09-11 04:37:33 +02:00
if (halted())
{
return;
}
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
m_doFadeInVol = false;
m_doFadeOutVol = true;
fade.step_ms = 0;
/* Duration is proportional to current volume. */
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
fade.duration_ms = fadeout_ms * musicVolume / VVV_MAX_VOLUME;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
fade.start_volume = musicVolume;
fade.end_volume = 0;
Re-fix resumemusic/musicfadein once again So it looks like facb079b3597b380f876537523cd351a0e637b62 (PR #316) had a few issues. The SDL performance counter doesn't really work that well. Testing reveals that unfocusing and focusing the game again results in the resumemusic() script command resuming the track at the wrong time. Even when not unfocusing the game at all, stopping a track and resuming it resumes it at the wrong time. (Only disabling the unfocus pause fixes this.) Furthermore, there's also the fact that the SDL performance counter keeps incrementing when the game is paused under GDB. So... yeah. Instead of dealing with the SDL performance counter, I'm just going to pause and resume the music directly (so the stopmusic() script command just pauses the music instead). As a result, we no longer can keep constantly calling Mix_PauseMusic() or Mix_ResumeMusic() when focused or unfocused, so I've moved those calls to happen directly when the relevant SDL events are received (the constant calls were originally in VCE, and whoever added them (I'm pretty sure it was Leo) was not the sharpest tool in the shed...). And we are going to switch over to using our own fade system instead of the SDL mixer fade system. In fact, we were already using our own fade system for fadeins after collecting a trinket or a custom level crewmate, but we were still using the mixer system for the rest. This is an inconsistency that I am glad to correct, so we're also doing our own fadeouts now. There is, however, an issue with the fade system where the length it goes for is inaccurate, because it's based on a volume-per-frame second calculation that gets truncated. But that's an issue to fix later - at least what I'm doing right now makes resumemusic() and musicfadein() work better than before.
2021-04-02 21:56:25 +02:00
}
Clean up don't-quick-fade signaling First, the variable has been inverted, because it's bad practice to have booleans with negative names. Secondly, instead of magically setting a signaling variable when calling fadeout(), fadeout() now has a parameter to set the quick_fade attribute, which is much cleaner than doing the magical assignment that could potentially look unrelated.
2020-11-06 09:51:04 +01:00
void musicclass::fadeout(const bool quick_fade_ /*= true*/)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
fadeMusicVolumeOut(quick_fade_ ? 500 : 2000);
quick_fade = quick_fade_;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void musicclass::processmusicfadein(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
enum FadeCode fade_code = processmusicfade(&fade, &musicVolume);
if (fade_code == Fade_finished)
{
m_doFadeInVol = false;
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Re-fix resumemusic/musicfadein once again So it looks like facb079b3597b380f876537523cd351a0e637b62 (PR #316) had a few issues. The SDL performance counter doesn't really work that well. Testing reveals that unfocusing and focusing the game again results in the resumemusic() script command resuming the track at the wrong time. Even when not unfocusing the game at all, stopping a track and resuming it resumes it at the wrong time. (Only disabling the unfocus pause fixes this.) Furthermore, there's also the fact that the SDL performance counter keeps incrementing when the game is paused under GDB. So... yeah. Instead of dealing with the SDL performance counter, I'm just going to pause and resume the music directly (so the stopmusic() script command just pauses the music instead). As a result, we no longer can keep constantly calling Mix_PauseMusic() or Mix_ResumeMusic() when focused or unfocused, so I've moved those calls to happen directly when the relevant SDL events are received (the constant calls were originally in VCE, and whoever added them (I'm pretty sure it was Leo) was not the sharpest tool in the shed...). And we are going to switch over to using our own fade system instead of the SDL mixer fade system. In fact, we were already using our own fade system for fadeins after collecting a trinket or a custom level crewmate, but we were still using the mixer system for the rest. This is an inconsistency that I am glad to correct, so we're also doing our own fadeouts now. There is, however, an issue with the fade system where the length it goes for is inaccurate, because it's based on a volume-per-frame second calculation that gets truncated. But that's an issue to fix later - at least what I'm doing right now makes resumemusic() and musicfadein() work better than before.
2021-04-02 21:56:25 +02:00
void musicclass::processmusicfadeout(void)
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
enum FadeCode fade_code = processmusicfade(&fade, &musicVolume);
if (fade_code == Fade_finished)
{
musicVolume = 0;
m_doFadeOutVol = false;
Fix regression with music fade transitions not working Unfortunately, 1de459d9b414180d5049cbf153266a8d6e00c227 caused a regression where musicclass::niceplay() didn't work, because fading out the music would cause haltdasmusik() to be called, which would reset the fade variables. To fix this, haltdasmusik() will now only reset the fade variables if it's not called from a fade, which is signaled with a function parameter.
2023-04-06 04:32:42 +02:00
haltdasmusik(true);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
Re-fix resumemusic/musicfadein once again So it looks like facb079b3597b380f876537523cd351a0e637b62 (PR #316) had a few issues. The SDL performance counter doesn't really work that well. Testing reveals that unfocusing and focusing the game again results in the resumemusic() script command resuming the track at the wrong time. Even when not unfocusing the game at all, stopping a track and resuming it resumes it at the wrong time. (Only disabling the unfocus pause fixes this.) Furthermore, there's also the fact that the SDL performance counter keeps incrementing when the game is paused under GDB. So... yeah. Instead of dealing with the SDL performance counter, I'm just going to pause and resume the music directly (so the stopmusic() script command just pauses the music instead). As a result, we no longer can keep constantly calling Mix_PauseMusic() or Mix_ResumeMusic() when focused or unfocused, so I've moved those calls to happen directly when the relevant SDL events are received (the constant calls were originally in VCE, and whoever added them (I'm pretty sure it was Leo) was not the sharpest tool in the shed...). And we are going to switch over to using our own fade system instead of the SDL mixer fade system. In fact, we were already using our own fade system for fadeins after collecting a trinket or a custom level crewmate, but we were still using the mixer system for the rest. This is an inconsistency that I am glad to correct, so we're also doing our own fadeouts now. There is, however, an issue with the fade system where the length it goes for is inaccurate, because it's based on a volume-per-frame second calculation that gets truncated. But that's an issue to fix later - at least what I'm doing right now makes resumemusic() and musicfadein() work better than before.
2021-04-02 21:56:25 +02:00
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void musicclass::processmusic(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if(!safeToProcessMusic)
{
return;
}
if(m_doFadeInVol)
{
processmusicfadein();
}
if (m_doFadeOutVol)
{
processmusicfadeout();
}
/* This needs to come after processing fades */
Move `Mix_PausedMusic()` call into wrapper function This wrapper function is for (a) future-proofing (b) proactive prevention of future copy-pasting (c) to clarify that we never actually halt music in the SDL_mixer sense, we only pause it, so to check if the music is halted we actually check if the music is paused instead. This is important because Mix_PlayingMusic() does not check if the music is paused and Mix_PausedMusic() does not check if the music is halted.
2021-09-11 04:35:29 +02:00
if (nicefade && halted())
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
play(nicechange);
nicechange = -1;
nicefade = false;
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
void musicclass::niceplay(int t)
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
/* important: do nothing if the correct song is playing! */
if ((!mmmmmm && currentsong != t)
|| (mmmmmm && usingmmmmmm && currentsong != t)
|| (mmmmmm && !usingmmmmmm && currentsong != t + num_mmmmmm_tracks))
{
if (currentsong != -1)
{
fadeout(false);
}
nicefade = true;
}
nicechange = t;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Replace main game music with music area map The main game used a set of copy-pasted code to set the music of each area. There WAS some redundancy built-in, but only three rooms in each direction from the entrance of a zone. Given this, it's completely possible for players to mismatch the music of the area and level. In fact, it's easy to do it even on accident, especially since 2.3 now lets you quicksave and quit during cutscenes. Just play a cutscene that has Pause music, then quicksave, quit, and reload. Also some other accidental ways that I've forgotten about. To fix this, I've done what mapclass has and made an areamap. Except for music. This map is the map of the track number of every single room, except for three special cases: -1 for do nothing and don't change music (usually because multiple different tracks can be played in this room), -2 for Tower music (needs to be track 2 or 9 depending on Flip Mode), and -3 for the start of Space Station 2 (track 1 in time trials, track 4 otherwise). I've thoroughly tested this areamap by playing through the game and entering every single room. Additionally I've also thoroughly tested all special cases (entering the Ship through the teleporter or main entrance, using the Ship's jukebox, the Tower in Flip Mode and regular mode, and the start of Space Station 2 in time trial and in regular mode). Closes #449.
2021-05-12 04:59:02 +02:00
static const int areamap[] = {
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
4, 3, 3, 3, 3, 3, 3, 3, 4,-2, 4, 4, 4,12,12,12,12,12,12,12,
4, 3, 3, 3, 3, 3, 3, 4, 4,-2, 4, 4, 4, 4,12,12,12,12,12,12,
4, 4, 4, 4, 3, 4, 4, 4, 4,-2, 4, 4, 4, 4,12,12,12,12,12,12,
4, 4, 4, 4, 3, 4, 4, 4, 4,-2, 4, 4, 1, 1, 1, 1,12,12,12,12,
4, 4, 3, 3, 3, 4, 4, 4, 4,-2,-2,-2, 1, 1, 1, 1, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4,-2, 1, 1, 1, 1, 1, 1,11,11,-1, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4,-2, 1, 1, 1, 1, 1, 1, 1,11,11,11,
4, 4, 4, 4, 4, 4, 4, 4, 4,-2, 1, 1, 1, 1, 1, 1, 1, 1, 1,11,
4, 4, 4, 4, 4, 4, 4, 4, 4,-2, 4, 4, 4, 1, 1, 1, 1, 1, 1, 3,
4, 4, 4, 4, 4, 4, 4, 4,-2,-2, 4, 4, 4, 1, 1, 1, 1, 1, 1, 4,
4, 4,-1,-1,-1, 4, 4, 4, 4,-2, 4, 4, 4, 1, 1, 1, 1, 1, 1, 4,
4, 4,-1,-1,-1, 4, 4, 4, 4,-2, 4, 1, 1, 1, 1, 1, 1, 1, 1, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4,-2, 4, 1, 1, 1, 1, 1, 1, 4, 1, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4,-2, 4, 1, 1, 1, 1, 1, 1, 4, 1, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4,-2, 4,-1,-3, 4, 4, 4, 4, 4, 1, 4,
4, 4, 4, 4, 4, 3, 3, 3, 4,-2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 3, 3, 3, 3, 3, 3, 4,-2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 3, 3, 3, 3, 3, 3, 3, 4,-2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
3, 3, 3, 3, 3, 4, 4, 3, 4,-2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
3, 3, 3, 3, 3, 4, 4, 3, 4,-2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4
Replace main game music with music area map The main game used a set of copy-pasted code to set the music of each area. There WAS some redundancy built-in, but only three rooms in each direction from the entrance of a zone. Given this, it's completely possible for players to mismatch the music of the area and level. In fact, it's easy to do it even on accident, especially since 2.3 now lets you quicksave and quit during cutscenes. Just play a cutscene that has Pause music, then quicksave, quit, and reload. Also some other accidental ways that I've forgotten about. To fix this, I've done what mapclass has and made an areamap. Except for music. This map is the map of the track number of every single room, except for three special cases: -1 for do nothing and don't change music (usually because multiple different tracks can be played in this room), -2 for Tower music (needs to be track 2 or 9 depending on Flip Mode), and -3 for the start of Space Station 2 (track 1 in time trials, track 4 otherwise). I've thoroughly tested this areamap by playing through the game and entering every single room. Additionally I've also thoroughly tested all special cases (entering the Ship through the teleporter or main entrance, using the Ship's jukebox, the Tower in Flip Mode and regular mode, and the start of Space Station 2 in time trial and in regular mode). Closes #449.
2021-05-12 04:59:02 +02:00
};
SDL_COMPILE_TIME_ASSERT(areamap, SDL_arraysize(areamap) == 20 * 20);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
void musicclass::changemusicarea(int x, int y)
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
int room;
int track;
if (script.running)
{
return;
}
room = musicroom(x, y);
if (!INBOUNDS_ARR(room, areamap))
{
SDL_assert(0 && "Music map index out-of-bounds!");
return;
}
track = areamap[room];
switch (track)
{
case -1:
/* Don't change music. */
return;
case -2:
/* Special case: Tower music, changes with Flip Mode. */
if (graphics.setflipmode)
{
track = 9; /* ecroF evitisoP */
}
else
{
track = 2; /* Positive Force */
}
break;
case -3:
/* Special case: start of Space Station 2. */
if (game.intimetrial)
{
track = 1; /* Pushing Onwards */
}
else
{
track = 4; /* Passion for Exploring */
}
break;
}
niceplay(track);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Remove unused argument from musicclass::playef() Apparently the 'offset' argument did something in the 1.x Flash versions, but now it does nothing.
2020-04-02 01:36:35 +02:00
void musicclass::playef(int t)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (!INBOUNDS_VEC(t, soundTracks))
{
return;
}
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
soundTracks[t].Play();
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Add pause(), pauseef(), and resumeef() to musicclass musicclass already had a resume() function for music. These are just wrappers around the appropriate SDL_mixer functions, to avoid direct function calls to the mixer API. So if we ever need to do something with all callers of pausing and resuming in the future, or we switch to a different audio backend, the work is already done for us. Also it just looks cleaner to be calling our musicclass function instead of doing a direct API call to the mixer.
2021-04-02 21:07:19 +02:00
void musicclass::pauseef(void)
{
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
SoundTrack::Pause();
Add pause(), pauseef(), and resumeef() to musicclass musicclass already had a resume() function for music. These are just wrappers around the appropriate SDL_mixer functions, to avoid direct function calls to the mixer API. So if we ever need to do something with all callers of pausing and resuming in the future, or we switch to a different audio backend, the work is already done for us. Also it just looks cleaner to be calling our musicclass function instead of doing a direct API call to the mixer.
2021-04-02 21:07:19 +02:00
}
void musicclass::resumeef(void)
{
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
SoundTrack::Resume();
Add pause(), pauseef(), and resumeef() to musicclass musicclass already had a resume() function for music. These are just wrappers around the appropriate SDL_mixer functions, to avoid direct function calls to the mixer API. So if we ever need to do something with all callers of pausing and resuming in the future, or we switch to a different audio backend, the work is already done for us. Also it just looks cleaner to be calling our musicclass function instead of doing a direct API call to the mixer.
2021-04-02 21:07:19 +02:00
}
Move `Mix_PausedMusic()` call into wrapper function This wrapper function is for (a) future-proofing (b) proactive prevention of future copy-pasting (c) to clarify that we never actually halt music in the SDL_mixer sense, we only pause it, so to check if the music is halted we actually check if the music is paused instead. This is important because Mix_PlayingMusic() does not check if the music is paused and Mix_PausedMusic() does not check if the music is halted.
2021-09-11 04:35:29 +02:00
bool musicclass::halted(void)
{
Fix music changes between areas
2022-04-10 21:50:15 +02:00
return MusicTrack::IsPaused();
Move `Mix_PausedMusic()` call into wrapper function This wrapper function is for (a) future-proofing (b) proactive prevention of future copy-pasting (c) to clarify that we never actually halt music in the SDL_mixer sense, we only pause it, so to check if the music is halted we actually check if the music is paused instead. This is important because Mix_PlayingMusic() does not check if the music is paused and Mix_PausedMusic() does not check if the music is halted.
2021-09-11 04:35:29 +02:00
}
Move the mute logic to musicclass. This moves the last of the SDL_mixer calls to Music.cpp.
2021-12-26 14:48:23 +01:00
void musicclass::updatemutestate(void)
{
if (game.muted)
{
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
MusicTrack::SetVolume(0);
SoundTrack::SetVolume(0);
Move the mute logic to musicclass. This moves the last of the SDL_mixer calls to Music.cpp.
2021-12-26 14:48:23 +01:00
}
else
{
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
SoundTrack::SetVolume(VVV_MAX_VOLUME * user_sound_volume / USER_VOLUME_MAX);
Move the mute logic to musicclass. This moves the last of the SDL_mixer calls to Music.cpp.
2021-12-26 14:48:23 +01:00
if (game.musicmuted)
{
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
MusicTrack::SetVolume(0);
Move the mute logic to musicclass. This moves the last of the SDL_mixer calls to Music.cpp.
2021-12-26 14:48:23 +01:00
}
else
{
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
MusicTrack::SetVolume(musicVolume * user_music_volume / USER_VOLUME_MAX);
Move the mute logic to musicclass. This moves the last of the SDL_mixer calls to Music.cpp.
2021-12-26 14:48:23 +01:00
}
}
}
Reference in a new issue Copy permalink