#include "snd_main.h"
#include "snd_ogg.h"
#include "snd_modplug.h"
+#include "csprogs.h"
#define SND_MIN_SPEED 8000
#define SND_MAX_WIDTH 2
#define SND_MIN_CHANNELS 1
#define SND_MAX_CHANNELS 8
-
#if SND_LISTENERS != 8
# error this data only supports up to 8 channel, update it!
#endif
-typedef struct listener_s
-{
- float yawangle;
- float dotscale;
- float dotbias;
- float ambientvolume;
-}
-listener_t;
-typedef struct speakerlayout_s
-{
- const char *name;
- unsigned int channels;
- listener_t listeners[SND_LISTENERS];
-}
-speakerlayout_t;
-static speakerlayout_t snd_speakerlayout;
+speakerlayout_t snd_speakerlayout;
// Our speaker layouts are based on ALSA. They differ from those
// Win32 and Mac OS X APIs use when there's more than 4 channels.
{
"surround71", 8,
{
- {45, 0.2, 0.2, 0.5}, // front left
- {315, 0.2, 0.2, 0.5}, // front right
- {135, 0.2, 0.2, 0.5}, // rear left
- {225, 0.2, 0.2, 0.5}, // rear right
- {0, 0.2, 0.2, 0.5}, // front center
- {0, 0, 0, 0}, // lfe (we don't have any good lfe sound sources and it would take some filtering work to generate them (and they'd probably still be wrong), so... no lfe)
- {90, 0.2, 0.2, 0.5}, // side left
- {180, 0.2, 0.2, 0.5}, // side right
+ {0, 45, 0.2, 0.2, 0.5}, // front left
+ {1, 315, 0.2, 0.2, 0.5}, // front right
+ {2, 135, 0.2, 0.2, 0.5}, // rear left
+ {3, 225, 0.2, 0.2, 0.5}, // rear right
+ {4, 0, 0.2, 0.2, 0.5}, // front center
+ {5, 0, 0, 0, 0}, // lfe (we don't have any good lfe sound sources and it would take some filtering work to generate them (and they'd probably still be wrong), so... no lfe)
+ {6, 90, 0.2, 0.2, 0.5}, // side left
+ {7, 180, 0.2, 0.2, 0.5}, // side right
}
},
{
"surround51", 6,
{
- {45, 0.2, 0.2, 0.5}, // front left
- {315, 0.2, 0.2, 0.5}, // front right
- {135, 0.2, 0.2, 0.5}, // rear left
- {225, 0.2, 0.2, 0.5}, // rear right
- {0, 0.2, 0.2, 0.5}, // front center
- {0, 0, 0, 0}, // lfe (we don't have any good lfe sound sources and it would take some filtering work to generate them (and they'd probably still be wrong), so... no lfe)
- {0, 0, 0, 0},
- {0, 0, 0, 0},
+ {0, 45, 0.2, 0.2, 0.5}, // front left
+ {1, 315, 0.2, 0.2, 0.5}, // front right
+ {2, 135, 0.2, 0.2, 0.5}, // rear left
+ {3, 225, 0.2, 0.2, 0.5}, // rear right
+ {4, 0, 0.2, 0.2, 0.5}, // front center
+ {5, 0, 0, 0, 0}, // lfe (we don't have any good lfe sound sources and it would take some filtering work to generate them (and they'd probably still be wrong), so... no lfe)
+ {0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0},
}
},
{
// channel of its own
"surround40", 4,
{
- {45, 0.3, 0.3, 0.8}, // front left
- {315, 0.3, 0.3, 0.8}, // front right
- {135, 0.3, 0.3, 0.8}, // rear left
- {225, 0.3, 0.3, 0.8}, // rear right
- {0, 0, 0, 0},
- {0, 0, 0, 0},
- {0, 0, 0, 0},
- {0, 0, 0, 0},
+ {0, 45, 0.3, 0.3, 0.8}, // front left
+ {1, 315, 0.3, 0.3, 0.8}, // front right
+ {2, 135, 0.3, 0.3, 0.8}, // rear left
+ {3, 225, 0.3, 0.3, 0.8}, // rear right
+ {0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0},
}
},
{
// channel of its own
"stereo", 2,
{
- {90, 0.5, 0.5, 1}, // side left
- {270, 0.5, 0.5, 1}, // side right
- {0, 0, 0, 0},
- {0, 0, 0, 0},
- {0, 0, 0, 0},
- {0, 0, 0, 0},
- {0, 0, 0, 0},
- {0, 0, 0, 0},
+ {0, 90, 0.5, 0.5, 1}, // side left
+ {1, 270, 0.5, 0.5, 1}, // side right
+ {0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0},
}
},
{
"mono", 1,
{
- {0, 0, 1, 1}, // center
- {0, 0, 0, 0},
- {0, 0, 0, 0},
- {0, 0, 0, 0},
- {0, 0, 0, 0},
- {0, 0, 0, 0},
- {0, 0, 0, 0},
- {0, 0, 0, 0},
+ {0, 0, 0, 1, 1}, // center
+ {0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0},
+ {0, 0, 0, 0, 0},
}
}
};
static int current_channellayout = SND_CHANNELLAYOUT_AUTO;
static int current_channellayout_used = SND_CHANNELLAYOUT_AUTO;
+static double spatialpower, spatialmin, spatialdiff, spatialoffset, spatialfactor;
+typedef enum { SPATIAL_NONE, SPATIAL_LOG, SPATIAL_POW, SPATIAL_THRESH } spatialmethod_t;
+spatialmethod_t spatialmethod;
+
// Cvars declared in sound.h (part of the sound API)
cvar_t bgmvolume = {CVAR_SAVE, "bgmvolume", "1", "volume of background music (such as CD music or replacement files such as sound/cdtracks/track002.ogg)"};
cvar_t volume = {CVAR_SAVE, "volume", "0.7", "volume of sound effects"};
cvar_t snd_initialized = { CVAR_READONLY, "snd_initialized", "0", "indicates the sound subsystem is active"};
cvar_t snd_staticvolume = {CVAR_SAVE, "snd_staticvolume", "1", "volume of ambient sound effects (such as swampy sounds at the start of e1m2)"};
-cvar_t snd_soundradius = {0, "snd_soundradius", "2000", "radius of weapon sounds and other standard sound effects (monster idle noises are half this radius and flickering light noises are one third of this radius)"};
+cvar_t snd_soundradius = {CVAR_SAVE, "snd_soundradius", "2000", "radius of weapon sounds and other standard sound effects (monster idle noises are half this radius and flickering light noises are one third of this radius)"};
+cvar_t snd_spatialization_min_radius = {CVAR_SAVE, "snd_spatialization_min_radius", "10000", "use minimum spatialization above to this radius"};
+cvar_t snd_spatialization_max_radius = {CVAR_SAVE, "snd_spatialization_max_radius", "100", "use maximum spatialization below this radius"};
+cvar_t snd_spatialization_min = {CVAR_SAVE, "snd_spatialization_min", "0.70", "minimum spatializazion of sounds"};
+cvar_t snd_spatialization_max = {CVAR_SAVE, "snd_spatialization_max", "0.95", "maximum spatialization of sounds"};
+cvar_t snd_spatialization_power = {CVAR_SAVE, "snd_spatialization_power", "0", "exponent of the spatialization falloff curve (0: logarithmic)"};
+cvar_t snd_spatialization_control = {CVAR_SAVE, "snd_spatialization_control", "0", "enable spatialization control (headphone friendly mode)"};
// Cvars declared in snd_main.h (shared with other snd_*.c files)
cvar_t _snd_mixahead = {CVAR_SAVE, "_snd_mixahead", "0.1", "how much sound to mix ahead of time"};
return snd_renderbuffer ? snd_renderbuffer->format.speed : 0;
}
+int S_GetSoundChannels(void)
+{
+ return snd_renderbuffer ? snd_renderbuffer->format.channels : 0;
+}
+
static qboolean S_ChooseCheaperFormat (snd_format_t* format, qboolean fixed_speed, qboolean fixed_width, qboolean fixed_channels)
{
Cvar_RegisterVariable(&snd_csqcchannel6volume);
Cvar_RegisterVariable(&snd_csqcchannel7volume);
+ Cvar_RegisterVariable(&snd_spatialization_min_radius);
+ Cvar_RegisterVariable(&snd_spatialization_max_radius);
+ Cvar_RegisterVariable(&snd_spatialization_min);
+ Cvar_RegisterVariable(&snd_spatialization_max);
+ Cvar_RegisterVariable(&snd_spatialization_power);
+ Cvar_RegisterVariable(&snd_spatialization_control);
+
Cvar_RegisterVariable(&snd_speed);
Cvar_RegisterVariable(&snd_width);
Cvar_RegisterVariable(&snd_channels);
void SND_Spatialize(channel_t *ch, qboolean isstatic)
{
int i;
+ double f;
vec_t dist, mastervol, intensity, vol;
vec3_t source_vec;
{
if (ch->entnum >= 32768)
{
- // TODO: sounds that follow CSQC entities?
+ //Con_Printf("-- entnum %i origin %f %f %f neworigin %f %f %f\n", ch->entnum, ch->origin[0], ch->origin[1], ch->origin[2], cl.entities[ch->entnum].state_current.origin[0], cl.entities[ch->entnum].state_current.origin[1], cl.entities[ch->entnum].state_current.origin[2]);
+
+ if (ch->entnum > 32768)
+ if (!CL_VM_GetEntitySoundOrigin(ch->entnum, ch->origin))
+ ch->entnum = 32768; // entity was removed, disown sound
}
else if (cl.entities[ch->entnum].state_current.active)
{
//Con_Printf("-- entnum %i origin %f %f %f neworigin %f %f %f\n", ch->entnum, ch->origin[0], ch->origin[1], ch->origin[2], cl.entities[ch->entnum].state_current.origin[0], cl.entities[ch->entnum].state_current.origin[1], cl.entities[ch->entnum].state_current.origin[2]);
- VectorCopy(cl.entities[ch->entnum].state_current.origin, ch->origin);
if (cl.entities[ch->entnum].state_current.modelindex && cl.model_precache[cl.entities[ch->entnum].state_current.modelindex] && cl.model_precache[cl.entities[ch->entnum].state_current.modelindex]->soundfromcenter)
- VectorMAMAM(1.0f, ch->origin, 0.5f, cl.model_precache[cl.entities[ch->entnum].state_current.modelindex]->normalmins, 0.5f, cl.model_precache[cl.entities[ch->entnum].state_current.modelindex]->normalmaxs, ch->origin);
+ VectorMAM(0.5f, cl.entities[ch->entnum].render.mins, 0.5f, cl.entities[ch->entnum].render.maxs, ch->origin);
+ else
+ Matrix4x4_OriginFromMatrix(&cl.entities[ch->entnum].render.matrix, ch->origin);
}
}
{
Matrix4x4_Transform(&listener_matrix[i], ch->origin, source_vec);
VectorNormalize(source_vec);
+
+ switch(spatialmethod)
+ {
+ case SPATIAL_LOG:
+ if(dist == 0)
+ f = spatialmin + spatialdiff * (spatialfactor < 0); // avoid log(0), but do the right thing
+ else
+ f = spatialmin + spatialdiff * bound(0, (log(dist) - spatialoffset) * spatialfactor, 1);
+ VectorScale(source_vec, f, source_vec);
+ break;
+ case SPATIAL_POW:
+ f = spatialmin + spatialdiff * bound(0, (pow(dist, spatialpower) - spatialoffset) * spatialfactor, 1);
+ VectorScale(source_vec, f, source_vec);
+ break;
+ case SPATIAL_THRESH:
+ f = spatialmin + spatialdiff * (dist < spatialoffset);
+ VectorScale(source_vec, f, source_vec);
+ break;
+ case SPATIAL_NONE:
+ default:
+ break;
+ }
+
vol = intensity * max(0, source_vec[0] * snd_speakerlayout.listeners[i].dotscale + snd_speakerlayout.listeners[i].dotbias);
ch->listener_volume[i] = (int)bound(0, vol, 255);
}
if (snd_renderbuffer == NULL || nosound.integer)
return;
+ {
+ double mindist_trans, maxdist_trans;
+
+ spatialmin = snd_spatialization_min.value;
+ spatialdiff = snd_spatialization_max.value - spatialmin;
+
+ if(snd_spatialization_control.value)
+ {
+ spatialpower = snd_spatialization_power.value;
+
+ if(spatialpower == 0)
+ {
+ spatialmethod = SPATIAL_LOG;
+ mindist_trans = log(max(1, snd_spatialization_min_radius.value));
+ maxdist_trans = log(max(1, snd_spatialization_max_radius.value));
+ }
+ else
+ {
+ spatialmethod = SPATIAL_POW;
+ mindist_trans = pow(snd_spatialization_min_radius.value, spatialpower);
+ maxdist_trans = pow(snd_spatialization_max_radius.value, spatialpower);
+ }
+
+ if(mindist_trans - maxdist_trans == 0)
+ {
+ spatialmethod = SPATIAL_THRESH;
+ mindist_trans = snd_spatialization_min_radius.value;
+ }
+ else
+ {
+ spatialoffset = mindist_trans;
+ spatialfactor = 1 / (maxdist_trans - mindist_trans);
+ }
+ }
+ else
+ spatialmethod = SPATIAL_NONE;
+
+ }
+
// If snd_swapstereo or snd_channellayout has changed, recompute the channel layout
if (current_swapstereo != boolxor(snd_swapstereo.integer, v_flipped.integer) ||
current_channellayout != snd_channellayout.integer)
projects / xonotic / darkplaces.git / blobdiff