Need a little help with spatialization

[caturria]

Hi,
Before I get down to business I just wanted to thank you for all your hard work on this wonderful library.
I'm using it to implement accessibility features for the blind (myself included) in the PC port of Ocarina of Time.
I'm trying to use the spatialization APIs to place out sound sources, but I'm running into some difficulty. I'm not the most mathematically inclined person, so I'm assuming there's a fault between the keyboard and chair as opposed to a real issue. Either way, I'm not having much success here. I think some additional documentation and/or examples would be really helpful.
My question is threefold:

1. could you possibly explain the concept of cone-based attenuation like I'm five (and blind). My assumption (probably incorrect) is that since you can never be facing more than 180 degrees away from something, that the "outer angle" should be 180 minus the inner angle?
2. I'm trying to get a sound to pan around my head as I spin in-place around it. I can't get the sound to budge unless I actually move either the listener or the sound source.
3. I have no idea what constitutes reasonable values when it comes to inner and outer angles or roll-off. I have max distance set to 500 units (this is generally a reasonable distance for OoT), but no matter what I set the values to I get one of two results: Massive attenuation even if the sound and listener are just one unit away from each other, or none at all no matter how far apart they are.
   Here's some test code: could you please advise me as to what I'm doing wrong and/or not understanding?
   #include
   #define MINIAUDIO_IMPLEMENTATION
   #define _USE_MATH_DEFINES
   #include "miniaudio.h"
   #include

float listPosX = 642;
int listPosY = 48;
float listPosZ = -327;
float listDirX = 0.0;
float listDirY = 0;
float listDirZ = 0.0;
float soundPosX = listPosX;
float soundPosY = listPosY;
float soundPosZ = listPosZ;
float soundDirX = listDirX;
float soundDirY = listDirY;
float soundDirZ = listDirZ;

int main()
{
listDirY = ma_degrees_to_radians_f(0);
soundDirY = ma_degrees_to_radians_f(45);//A 45 degree turn away from the listener?
listPosZ += 5.5;//In OoT terms this is about one of Link's footsteps in the forward direction. This should just be a small amount of attenuation.

ma_engine_config config = ma_engine_config_init();
config.channels = 2;
config.listenerCount = 1;
config.sampleRate = 44100;
ma_engine engine;
if (ma_engine_init(&config, &engine) != MA_SUCCESS)
	return 0;
ma_engine_start(&engine);
ma_result r;
ma_sound sound;
ma_sound_init_from_file(&engine, "c:\\users\\caturria\\oot samples\\accessibility\\audio\\38fa.wav", 0, NULL, NULL, &sound);
ma_engine_listener_set_position(&engine, 0, listPosX, listPosY, listPosZ);
ma_engine_listener_set_direction(&engine, 0, listDirX, listDirY, listDirZ);

ma_engine_listener_set_cone(&engine, 0, ma_degrees_to_radians_f(15), ma_degrees_to_radians_f(360), 0.0);//No idea what constitutes meaningful values for these.
ma_sound_set_position(&sound, soundPosX, soundPosY, soundPosZ);
ma_sound_set_direction(&sound, soundDirX, soundDirY, soundDirZ);

ma_sound_set_max_distance(&sound, 500);

ma_sound_start(&sound);
std::cout << "Sound should be playing. It should sound like the player is facing 45 degrees to its right." << std::endl;

getchar();

}
The result this achieves is that the sound plays dead center and with no attenuation, as if it were played without spatialization at all.
What am I missing?

Kind regards,

Jordan.

[mackron]

So the cone attenuation is just a very basic mechanism for attenuating sounds based on whether or not a sound is being heard from behind or in front. It is not a replacement for something like HRTF. Most of the time a cone won't actually be needed, and while you're just getting things working at a basic level I would highly suggest that you just ignore it for the time being. But for completeness sake, there are two scenarios off the top of my head where you'd might want to consider setting the cone: the first is on the listener so that sounds behind the listener sound slightly quieter than those in front (again, this is very simple - it's nothing like HRTF); and the second is on a sound that might represent something like a horn where it will sound louder when it's pointed in your direction but quieter if it's pointed away from you. The cone is not the tool you want to be using for the directional perception of a sound, and I think that might be what's causing your confusion here.

The default angle is 360 degrees for both the inner and outer cone which means there is no cone attenuation happening at all by default. When the sound is being heard from inside the inner cone, the sound will not have any cone attenuation applied. When the sound is being heard from the outer cone it will have the attenuation that you specified with ma_engine_listener_set_cone() or ma_sound_set_cone(). Anything that falls in between the inner cone and outer cone will be interpolated between 1 and the outer cone attenuation from set_cone().

For your second point, the cone will not help you at all when it comes to the perception of a sound's direction. The relative position between the sound source and the listener is the only thing that controls the directional perception of a sound.

For your third point, this is a finicky one because it's all about the attenuation model being used and the scale of your coordinate system. It's something you'll need to fiddle with a bit. I can tell you that with default settings, 500 units is gigantic. Sounds at that distance will be totally imperceptible. The function you'll want to use is ma_sound_set_rolloff(). The rolloff defaults to 1. Higher values will make the volume of the sound fall off quicker as the listener moves away from it, whereas a smaller value will make them fall off slower. Since your value of 5.5 seems to represent something like half a meter (I'm guessing 1 meter equals 10 units in OoT?) you would want to lower your rolloff. Maybe try setting it to 0.1 or even 0.01 as a starting point and see how that goes. You'll just need to experiment until you find what what works.

Alternatively, you can set the attenuation model to linear which will give you a simpler model. This will allow you to assign a radius to a sound, but comes at the expense of a less physically accurate attenuation. This may still work well enough for your game though. In this case, when the listener is at the edge of the sound's radius, the volume will be exactly 0. When the listener is at the dead centre of the sound (or the value you set with ma_sound_set_min_distance()), the volume will be exactly 1. Anything in between will be linearly interpolated which is not physically accurate, but like I said before, might be good enough for your purposes. The radius of a sound is set with ma_sound_set_max_distance().

With your code, make sure your coordinate system matches with miniaudio. The Y axis is up and down, and the Z axis is in and out. Negative Z is into the screen. Also, the sound direction will have little impact on anything here. As a starting point while you get things working, just focus on the position of the sound and ignore it's direction. If the position of the sound and the listener at on top of each other you will not get any directional perception. As soon as you move the sound to the left or right of the listener you'll start to perceive the direction. If you position the sound like the code below you should hear something come predominately from the left speaker and a little on the right:

float soundPosX = listPosX - 1;
float soundPosY = listPosY;
float soundPosZ = listPosZ + 1;

Also, it looks like you're trying to rotate around the Y axis by setting the Y direction to 45 degrees. That's incorrect - the direction is specified as a direction vector, not an axis rotation. So a 45 degree rotation around the Y axis would actually be something like this:

listDirX = 0.7071f;
listDirY = 0;
listDirZ = -0.7071f;

Hopefully that helps get you started.

[caturria]

Hi,

Thank you very much; I'm starting to get the hang of this.
Am I understanding correctly that min and max distances are only relevant to the linear model? When I set them while using the inverse model, the sound doesn't completely go away even if I move it away to a distance several times the limit. I'm also setting min gain to 0 and max gain to 1.0.

[caturria]

Here is a code example that demonstrates what I'm talking about. I even have rolloff set to exponential. Rolloff is 1.0, min and max gain are 0.0 and 1.0 respectively. Max distance is 500, but the listener is 6000 units away from the sound; the attenuation flatlines at some point and it doesn't matter how much further you move away, it never gets any quieter.

#include
#define MINIAUDIO_IMPLEMENTATION
#define _USE_MATH_DEFINES
#include "miniaudio.h"
#include

float listPosX = 642;
float listPosY = 48;
float listPosZ = -327;
float listDirX = 0.0;
float listDirY = 0;
float listDirZ = 0.0;
float soundPosX = listPosX;
float soundPosY = listPosY;
float soundPosZ = listPosZ;
float soundDirX = listDirX;
float soundDirY = listDirY;
float soundDirZ = listDirZ;

int main()
{
listDirX = ma_degrees_to_radians_f(45);
listDirZ = ma_degrees_to_radians_f(-45);
listPosZ += (6000 * 0.75);
listPosX += (6000 * 0.25);

ma_engine_config config = ma_engine_config_init();
config.channels = 2;
config.listenerCount = 1;
config.sampleRate = 44100;
ma_engine engine;
if (ma_engine_init(&config, &engine) != MA_SUCCESS)
	return 0;
ma_engine_start(&engine);
ma_result r;
ma_sound sound;
ma_sound_init_from_file(&engine, "c:\\users\\caturria\\oot samples\\accessibility\\audio\\38fa.wav", 0, NULL, NULL, &sound);
ma_engine_listener_set_position(&engine, 0, listPosX, listPosY, listPosZ);
ma_engine_listener_set_direction(&engine, 0, listDirX, listDirY, listDirZ);
ma_sound_set_position(&sound, soundPosX, soundPosY, soundPosZ);
ma_sound_set_direction(&sound, soundDirX, soundDirY, soundDirZ);
ma_sound_set_min_gain(&sound, 0.0);
ma_sound_set_max_gain(&sound, 1.0);
ma_sound_set_rolloff(&sound, 1.0);
ma_sound_set_min_distance(&sound, 1);

ma_sound_set_max_distance(&sound, 500);
ma_sound_set_attenuation_model(&sound, ma_attenuation_model_exponential);
ma_sound_start(&sound);
std::cout << "Sound should be playing. It should sound like the player is facing 45 degrees to its right." << std::endl;

getchar();

}

[caturria]

Sorry for the triple post. I wanted to correct something else I had stated. The value 5.5 is not actually the distance covered by Link's footstep. It is actually Link's linear velocity. The game runs at 20 frames per second, and Link travels approximately this distance every frame. So he moves roughly 110 units per second.

[mackron]

min and max distances are always uses by all attenuation models. When calculating the attenuation, it takes the distance between the listener and the sound, and then clamps that distance between min_distance and max_distance before doing the calculations. The flatlining you mentioned sounds consistent with the distance getting clamped, and based on your description sounds exactly like I'd expect. The maximum distance is set to 500, but the distance between the sound and the player is 6000. That means your distance of 6000 will be clamped to 500 when doing the attenuation. I would ignore max distance for now - I don't think it will help you with what you're trying to achieve, at least with non-linear attenuation (for linear attenuation you'll need to use it to define your sound radius).

Also keep in mind that the inverse and exponential models will never result in a sound being absolute silence, but it'll get quiet enough that it'll become imperceptible. I tested just now, and at 100 units away with default settings, the sound will just barely be audible - you need to really focus to be able to hear it.

I did some testing now, and here's some suggestions for you to as a starting point:

• Leave your attenuation model as "inverse" which is the default. Don't use "exponential" - I find that one a bit harder to work with.
• Set your rolloff to something around 0.025. I tested this now, and at a distance of 500 the sound is very perceptible, and at a distance of 6000 it's barely audible at all (you really need to focus to hear it). Then from there, fiddle with the rolloff until you've got something that works for you. Remember, this is a per-sound setting, so you can use different values for different sounds depending on the requirements of that particular sound.
• Leave the min and max distances as their defaults. Don't change them unless you're using the linear attenuation model, in which case set the max distance to the radius of your sound.
• Leave min and max gain as their defaults as well.

That should give you a workable starting point.