https://github.com/martenfur/fmodforfoxes
Cross-platform C# FMOD wrapper.
https://github.com/martenfur/fmodforfoxes
audio fmod monogame monogame-framework
Last synced: 5 months ago
JSON representation
Cross-platform C# FMOD wrapper.
- Host: GitHub
- URL: https://github.com/martenfur/fmodforfoxes
- Owner: Martenfur
- License: mit
- Created: 2019-04-20T20:47:04.000Z (over 6 years ago)
- Default Branch: develop
- Last Pushed: 2024-11-21T23:46:20.000Z (11 months ago)
- Last Synced: 2025-05-16T17:08:56.454Z (5 months ago)
- Topics: audio, fmod, monogame, monogame-framework
- Language: C#
- Size: 97.9 MB
- Stars: 123
- Watchers: 5
- Forks: 17
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE.md
Awesome Lists containing this project
README
[](https://www.nuget.org/packages/FmodForFoxes)
### Current FMOD version target: 2.02.25
[**Join our Discord**](https://discord.gg/EtJexdZs77)
The time has come. You're finally witnessing a high-level cross-platform C# library, which makes Monogame and FMOD best friends.
In case you've come here and the only thing you've understood so far was the doge meme, [FMOD](https://fmod.com) is a powerful cross-platform audio engine, which is pretty much the only hope to have any decent audio in Monogame.
The catch is - FMOD is written in C++, and unless you're using Unity, you're only getting a bare-bones C# wrapper. No tutorials, no setup guides. Only you and DllImport.
That's why this library exists. It does the tough part for you and provides a basic high-level interface.
Also note that even though the primary target of this library is Monogame, you can easily adapt it for any other C#-based project.
## Setup
The initial setup is a little fiddly. Here's the thing - the FMOD license prohibits me from distributing their libraries in my Nuget package - so you have to download them yourself.
But fear not, I've put together a detailed guide. With pictures.
### Preparations
Visit the [FMOD Download page](https://www.fmod.com/download) (accessing it requires registration), find the FMOD Studio API downloads and get APIs for Windows, Linux and Android (in case you want all three). If you're going to set up all three, of course.
**NOTE: Current version of the library was tested on FMOD v2.02.19. I really recommend getting it. Later versions will probably also work, but I have no guarantee.**
Windows API requires installation, Linux and Android don't. You can drop them near the Windows API just to have everything in one place.
### Common logic
In your crossplatform project, install 2. Install [FmodForFoxes](https://www.nuget.org/packages/FmodForFoxes/) NuGet package. It contains the API.
### Windows & Linux
1. Open your DesktopGL or WindowsDX Monogame project.
2. Install the NuGet package [FmodForFoxes.Desktop](https://www.nuget.org/packages/FmodForFoxes.Desktop/). Alternatively, you can plug this repo as a submodule and reference projects directly.
3. Navigate to your FMOD Windows API installation. From there navigate to `\api\core\lib`. You will see two directories: `x64` and `x86`. Each one will contain this:
Out of all the files you'll need only `fmod.dll` and `fmodL.dll` from either `x86` or `x64` directories (`x64` highly recommended). The files engine with `L` mean that the library supports logging. They are used for debugging andf shoudl not be included into the final release. Copy `fmod.dll` and `fmodL.dll` to the root of your DesktopGL or WindowsDX project. Do the same for `\api\studio\lib` libs and you should end up with it looking like this:
Make sure dll files will be copied to the output directory:
4. Navigate to your FMOD Linux API installation. From there navigate to `\api\core\lib`. This time you will see four directories:
You'll need only `x64` or `x86`.
Each directory contains this:
You will need all `libfmod` files from here. Copy fmod files from `x86` or `x64` directory the root of your project, same as on Windows. Do the same for `\api\studio\lib` libs and you'll end up with this:
*NOTE: DesktopGL project works on both Linux and Windows, so you need to add the dll files there too.*
Again, make sure all the files you've just added will be copied to the output directory:
And that's it - you've gotten yourself cross-platform desktop FMOD!
### Android
1. Open your Monogame Android project.
2. Install NuGet package [FmodForFoxes.Android](https://www.nuget.org/packages/FmodForFoxes.Android/). Alternatively, you can plug repo as a submodule and reference projects directly.
3. Create `libs` directory in the root of your project.
4. Navigate to your FMOD Android API installation. From there navigate to `\api\core\lib`. You will see this:
5. Each folder contains `libfmod.so` and `libfmodL.so`.
Copy everything except `.jar` file over to your `libs` directory. Don't lose this jar, tho. We'll need it later. Do the same for `\api\studio\lib` libs and you should end up with this:
1. Select each `.so` file you've just copied, open their Properties and set their Build Action to `AndroidNativeLibrary`.
7. Create an **NET6 Android Bindings Project**.
Remember that jar from earlier? Now you need to copy it into the Jars directory and make sure its Build Action is set to `AndroidLibrary`.
Now reference Bindings project to your main Android project - and you're golden.
### Studio setup
FMOD Studio setup process is exactly the same, but you'll need to look into `studio` instead of `core` directories.
**It's also extremely important that ALL your binaries are the exact same version.
FMOD doesn't like version mixup. Foxes don't like version mixup. Nobody does.**
If you still have questions, take a look at the [Samples project](/Samples) that has everything set up for all platforms.
## Playing some tunes!
So, after you've set everything up, it's time to bop some pops, as kids say these days.
1. Find a sound file and import it into the Content Pipeline.
2. Select the sound file and set its Build Action to Copy.
3. Include the `FmodForFoxes` namespace and paste the following code into your
Initialize() method:
```cs
FmodManager.Init(_nativeLibrary, FMODMode.CoreAndStudio, "Content");
var sound = CoreSystem.LoadStreamedSound("test.mp3");
var channel = sound.Play();
channel.Looping = true;
```
`_nativeLibrary` is an instance of `INativeFmodLibrary` that you have to create separately in your platform-specific projects. [Samples project](/Samples) already has this set up.
And lastly, do note that `FmodManager` has to be properly updated and unloaded. Your main gameloop class has to have this added:
```cs
///
/// UnloadContent will be called once per game and is the place to unload
/// game-specific content.
///
protected override void UnloadContent()
{
FmodManager.Unload();
}
///
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
///
/// Provides a snapshot of timing values.
protected override void Update(GameTime gameTime)
{
FmodManager.Update();
base.Update(gameTime);
}
```
4. Compile and hope that you (and me) did everything right.
You can also check out the included [Samples project](/Samples).
## But what about other platforms?
I'd like to make console versions of the library - but currently I have no ability
to do so, and probably won't have for a long time. As for UWP and Apple platforms,
I just don't care about them enough.
If you want to be a hero and expand the library with any of those platforms yourself -
contact me and we'll figure something out.
## License and legal stuffs
This library is licensed under MIT, so you can use it and its code in any
shenanigans you want. Free games, commercial games, anything - no payment or
royalties required. Just leave a credit. ; - )
But the show's main star is a bit different. FMOD has its own [license](https://fmod.com/licensing#faq),
which is much less permissive than mine.
Demo [music](https://www.youtube.com/watch?v=zZ81qi90E-Y) is provided by Agrofox and FMOD team.
Also big thanque to [StinkBrigade](https://github.com/StinkBrigade) who helped a ton in adding FMOD Studio support.
*don't forget to pet your foxes*