public unsafe void Calculate(Listener listener, Emitter emitter, CalculateFlags flags, DspSettings *result)
{
Debug.Assert((flags & CalculateFlags.Delay) == 0 || (result->DelayTimesPointer != IntPtr.Zero), "When CalculateFlags.Delay is specified, DelayTimesPointer must point to float[DstChannelCount]");
Debug.Assert((flags & CalculateFlags.Matrix) == 0 || (result->MatrixCoefficientsPointer != IntPtr.Zero), "When CalculateFlags.Matrix is specified, MatrixCoefficientsPointer must point to float[SrcChannelCount*DstChannelCount]");
Cone emitterCone;
Emitter.Native nativeEmitter = new Emitter.Native();
Cone listenerCone;
Listener.Native nativeListener = new Listener.Native();
{
if (emitter.Cone.HasValue)
{
emitterCone = emitter.Cone.Value;
nativeEmitter.ConePointer = new IntPtr(&emitterCone);
}
else
{
nativeEmitter.ConePointer = IntPtr.Zero;
}
nativeEmitter.OrientFront = emitter.OrientFront;
nativeEmitter.OrientTop = emitter.OrientTop;
nativeEmitter.Position = emitter.Position;
nativeEmitter.Velocity = emitter.Velocity;
nativeEmitter.InnerRadius = emitter.InnerRadius;
nativeEmitter.InnerRadiusAngle = emitter.InnerRadiusAngle;
nativeEmitter.ChannelCount = emitter.ChannelCount;
nativeEmitter.ChannelRadius = emitter.ChannelRadius;
nativeEmitter.ChannelAzimuthsPointer = emitter.ChannelAzimuths.ToPointer();
nativeEmitter.VolumeCurvePointer = emitter.VolumeCurve.ToPointer();
nativeEmitter.LFECurvePointer = emitter.LFECurve.ToPointer();
nativeEmitter.LPFDirectCurvePointer = emitter.LPFDirectCurve.ToPointer();
nativeEmitter.LPFReverbCurvePointer = emitter.LPFReverbCurve.ToPointer();
nativeEmitter.ReverbCurvePointer = emitter.ReverbCurve.ToPointer();
nativeEmitter.CurveDistanceScaler = emitter.CurveDistanceScaler;
nativeEmitter.DopplerScaler = emitter.DopplerScaler;
if (listener.Cone.HasValue)
{
listenerCone = listener.Cone.Value;
nativeListener.ConePointer = new IntPtr(&listenerCone);
}
else
{
nativeListener.ConePointer = IntPtr.Zero;
}
nativeListener.OrientFront = listener.OrientFront;
nativeListener.OrientTop = listener.OrientTop;
nativeListener.Position = listener.Position;
nativeListener.Velocity = listener.Velocity;
fixed(X3DAudioHandle *handle = &m_x3dAudioHandle)
{
X3DAudioCalculate_(handle, &nativeListener, &nativeEmitter, (int)flags, result);
}
}
}
/// <summary>
/// Calculates DSP settings for the specified listener and emitter.
/// </summary>
/// <param name="listener">The <see cref="Listener"/>.</param>
/// <param name="emitter">The <see cref="Emitter"/>.</param>
/// <param name="flags">The <see cref="CalculateFlags"/>.</param>
/// <param name="sourceChannelCount">The source channel count.</param>
/// <param name="destinationChannelCount">The destination channel count.</param>
/// <returns>An instance of <see cref="DspSettings"/> class.</returns>
public DspSettings Calculate(Listener listener, Emitter emitter, CalculateFlags flags, int sourceChannelCount, int destinationChannelCount)
{
var settings = new DspSettings(sourceChannelCount, destinationChannelCount);
Calculate(listener, emitter, flags, settings);
return(settings);
}
/// <summary>
/// Calculates DSP settings for the specified listener and emitter. See remarks.
/// </summary>
/// <param name="listener">The <see cref="Listener"/>.</param>
/// <param name="emitter">The <see cref="Emitter"/>.</param>
/// <param name="flags">The <see cref="CalculateFlags"/>.</param>
/// <param name="settings">The <see cref="DspSettings"/>.</param>
/// <remarks>The source and destination channel count must be set on <see cref="DspSettings" /> before calling this method.</remarks>
public void Calculate(Listener listener, Emitter emitter, CalculateFlags flags, DspSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
DspSettings.__Native settingsNative;
settingsNative.SrcChannelCount = settings.SourceChannelCount;
settingsNative.DstChannelCount = settings.DestinationChannelCount;
unsafe
{
fixed(void *pMatrix = settings.MatrixCoefficients)
{
fixed(void *pDelays = settings.DelayTimes)
{
settingsNative.MatrixCoefficientsPointer = (IntPtr)pMatrix;
settingsNative.DelayTimesPointer = (IntPtr)pDelays;
XAudio2Native.X3DAudioCalculate(ref _handle, listener, emitter, flags, new IntPtr(&settingsNative));
}
}
}
settings.__MarshalFrom(ref settingsNative);
}
public unsafe void Calculate(Listener listener, Emitter emitter, CalculateFlags flags, DspSettings* result)
{
Debug.Assert((flags & CalculateFlags.Delay) == 0 || (result->DelayTimesPointer != IntPtr.Zero), "When CalculateFlags.Delay is specified, DelayTimesPointer must point to float[DstChannelCount]");
Debug.Assert((flags & CalculateFlags.Matrix) == 0 || (result->MatrixCoefficientsPointer != IntPtr.Zero), "When CalculateFlags.Matrix is specified, MatrixCoefficientsPointer must point to float[SrcChannelCount*DstChannelCount]");
Cone emitterCone;
Emitter.Native nativeEmitter = new Emitter.Native();
Cone listenerCone;
Listener.Native nativeListener = new Listener.Native();
{
if (emitter.Cone.HasValue)
{
emitterCone = emitter.Cone.Value;
nativeEmitter.ConePointer = new IntPtr(&emitterCone);
}
else
{
nativeEmitter.ConePointer = IntPtr.Zero;
}
nativeEmitter.OrientFront = emitter.OrientFront;
nativeEmitter.OrientTop = emitter.OrientTop;
nativeEmitter.Position = emitter.Position;
nativeEmitter.Velocity = emitter.Velocity;
nativeEmitter.InnerRadius = emitter.InnerRadius;
nativeEmitter.InnerRadiusAngle = emitter.InnerRadiusAngle;
nativeEmitter.ChannelCount = emitter.ChannelCount;
nativeEmitter.ChannelRadius = emitter.ChannelRadius;
nativeEmitter.ChannelAzimuthsPointer = emitter.ChannelAzimuths.ToPointer();
nativeEmitter.VolumeCurvePointer = emitter.VolumeCurve.ToPointer();
nativeEmitter.LFECurvePointer = emitter.LFECurve.ToPointer();
nativeEmitter.LPFDirectCurvePointer = emitter.LPFDirectCurve.ToPointer();
nativeEmitter.LPFReverbCurvePointer = emitter.LPFReverbCurve.ToPointer();
nativeEmitter.ReverbCurvePointer = emitter.ReverbCurve.ToPointer();
nativeEmitter.CurveDistanceScaler = emitter.CurveDistanceScaler;
nativeEmitter.DopplerScaler = emitter.DopplerScaler;
if (listener.Cone.HasValue)
{
listenerCone = listener.Cone.Value;
nativeListener.ConePointer = new IntPtr(&listenerCone);
}
else
{
nativeListener.ConePointer = IntPtr.Zero;
}
nativeListener.OrientFront = listener.OrientFront;
nativeListener.OrientTop = listener.OrientTop;
nativeListener.Position = listener.Position;
nativeListener.Velocity = listener.Velocity;
fixed (X3DAudioHandle* handle = &m_x3dAudioHandle)
{
X3DAudioCalculate_(handle, &nativeListener, &nativeEmitter, (int)flags, result);
}
}
}
/// <summary>
/// Calculates dsp settings for the specified listener and emitter.
/// </summary>
/// <param name="listener">The listener.</param>
/// <param name="emitter">The emitter.</param>
/// <param name="flags">The flags.</param>
/// <param name="sourceChannelCount">The source channel count.</param>
/// <param name="destinationChannelCount">The destination channel count.</param>
/// <returns>Dsp settings</returns>
public DspSettings Calculate(Listener listener, Emitter emitter, CalculateFlags flags, int sourceChannelCount, int destinationChannelCount)
{
var settings = new DspSettings
{
SourceChannelCount = sourceChannelCount,
DestinationChannelCount = destinationChannelCount
};
X3DAudioCalculate(ref handle, listener, emitter, flags, settings);
return settings;
}
/// <summary>
/// Calculates DSP settings for the specified listener and emitter. See remarks.
/// </summary>
/// <param name="listener">The listener.</param>
/// <param name="emitter">The emitter.</param>
/// <param name="flags">The flags.</param>
/// <param name="settings">The settings.</param>
/// <remarks>The source and destination channel count must be set on <see cref="DspSettings" /> before calling this method.</remarks>
/// <msdn-id>ee419052</msdn-id>
/// <unmanaged>void X3DAudioCalculate([In] const X3DAUDIOHANDLE* Instance,[In] const X3DAUDIO_LISTENER* pListener,[In] const X3DAUDIO_EMITTER* pEmitter,[In] X3DAudioCalculateFlags Flags,[In] void* pDSPSettings)</unmanaged>
/// <unmanaged-short>X3DAudioCalculate</unmanaged-short>
public unsafe void Calculate(Listener listener, Emitter emitter, CalculateFlags flags, DspSettings settings)
{
if (settings == null) throw new ArgumentNullException("settings");
DspSettings.__Native settingsNative;
settingsNative.SrcChannelCount = settings.SourceChannelCount;
settingsNative.DstChannelCount = settings.DestinationChannelCount;
fixed (void* pMatrix = settings.MatrixCoefficients)
fixed (void* pDelays = settings.DelayTimes)
{
settingsNative.MatrixCoefficientsPointer = (IntPtr)pMatrix;
settingsNative.DelayTimesPointer = (IntPtr)pDelays;
calculateDelegate(ref handle, listener, emitter, flags, new IntPtr(&settingsNative));
}
settings.__MarshalFrom(ref settingsNative);
}
public float Apply3D(SourceVoice voice, Listener listener, Emitter emitter, int srcChannels, int dstChannels, CalculateFlags flags, float maxDistance, float frequencyRatio, bool silent)
{
unsafe
{
DspSettings settings;
int matrixCoefficientCount = srcChannels * dstChannels;
float* matrixCoefficients = stackalloc float[matrixCoefficientCount];
float* delay = stackalloc float[dstChannels];
settings.SrcChannelCount = srcChannels;
settings.DstChannelCount = dstChannels;
settings.MatrixCoefficientsPointer = new IntPtr(matrixCoefficients);
settings.DelayTimesPointer = new IntPtr(delay);
Calculate(listener, emitter, flags, &settings);
if (emitter.InnerRadius == 0f)
{
// approximated decay by distance
float decay;
if (silent)
decay = 0f;
else
decay = MathHelper.Clamp(1f - settings.EmitterToListenerDistance / maxDistance, 0f, 1f);
for (int i = 0; i < matrixCoefficientCount; i++)
{
matrixCoefficients[i] *= decay;
}
}
voice.SetOutputMatrix(null, settings.SrcChannelCount, settings.DstChannelCount, matrixCoefficients);
voice.SetFrequencyRatio(frequencyRatio * settings.DopplerFactor);
return settings.EmitterToListenerDistance;
}
}
public float Apply3D(SourceVoice voice, Listener listener, Emitter emitter, int srcChannels, int dstChannels, CalculateFlags flags, float maxDistance, float frequencyRatio, bool silent, bool use3DCalculation = true)
{
unsafe
{
DspSettings settings;
int matrixCoefficientCount = srcChannels * dstChannels;
float *matrixCoefficients = stackalloc float[matrixCoefficientCount];
float *delay = stackalloc float[dstChannels];
settings.SrcChannelCount = srcChannels;
settings.DstChannelCount = dstChannels;
settings.MatrixCoefficientsPointer = new IntPtr(matrixCoefficients);
settings.DelayTimesPointer = new IntPtr(delay);
if (use3DCalculation)
{
Calculate(listener, emitter, flags, &settings);
voice.SetFrequencyRatio(frequencyRatio * settings.DopplerFactor);
}
else
{ //realistic sounds
settings.EmitterToListenerDistance = Vector3.Distance(new Vector3(listener.Position.X, listener.Position.Y, listener.Position.Z), new Vector3(emitter.Position.X, emitter.Position.Y, emitter.Position.Z));
for (int i = 0; i < matrixCoefficientCount; i++)
{
matrixCoefficients[i] = 1f;
}
}
if (emitter.InnerRadius == 0f)
{
// approximated decay by distance
float decay;
if (silent)
{
decay = 0f;
}
else
{
decay = MathHelper.Clamp(1f - settings.EmitterToListenerDistance / maxDistance, 0f, 1f);
}
for (int i = 0; i < matrixCoefficientCount; i++)
{
matrixCoefficients[i] *= decay;
}
}
#if !XB1
voice.SetOutputMatrix(null, settings.SrcChannelCount, settings.DstChannelCount, matrixCoefficients);
#else // XB1
var matCoefs = new float[matrixCoefficientCount];
for (int i = 0; i < matrixCoefficientCount; i++)
{
matCoefs[i] = matrixCoefficients[i];
}
voice.SetOutputMatrix(null, settings.SrcChannelCount, settings.DstChannelCount, matCoefs);
#endif // XB1
return(settings.EmitterToListenerDistance);
}
}
/// <summary>
/// Calculates DSP settings for the specified listener and emitter. See remarks.
/// </summary>
/// <param name="listener">The listener.</param>
/// <param name="emitter">The emitter.</param>
/// <param name="flags">The flags.</param>
/// <param name="settings">The settings.</param>
/// <remarks>The source and destination channel count must be set on <see cref="DspSettings" /> before calling this method.</remarks>
/// <msdn-id>ee419052</msdn-id>
/// <unmanaged>void X3DAudioCalculate([In] const X3DAUDIOHANDLE* Instance,[In] const X3DAUDIO_LISTENER* pListener,[In] const X3DAUDIO_EMITTER* pEmitter,[In] X3DAudioCalculateFlags Flags,[In] void* pDSPSettings)</unmanaged>
/// <unmanaged-short>X3DAudioCalculate</unmanaged-short>
public unsafe void Calculate(Listener listener, Emitter emitter, CalculateFlags flags, DspSettings settings)
{
if (settings == null) throw new ArgumentNullException("settings");
DspSettings.__Native settingsNative;
settingsNative.SrcChannelCount = settings.SourceChannelCount;
settingsNative.DstChannelCount = settings.DestinationChannelCount;
fixed (void* pMatrix = settings.MatrixCoefficients)
fixed (void* pDelays = settings.DelayTimes)
{
settingsNative.MatrixCoefficientsPointer = (IntPtr)pMatrix;
settingsNative.DelayTimesPointer = (IntPtr)pDelays;
X3DAudioCalculate(ref handle, listener, emitter, flags, new IntPtr(&settingsNative));
}
settings.__MarshalFrom(ref settingsNative);
}
/// <summary>
/// Calculates DSP settings for the specified listener and emitter.
/// </summary>
/// <param name="listener">The listener.</param>
/// <param name="emitter">The emitter.</param>
/// <param name="flags">The flags.</param>
/// <param name="sourceChannelCount">The source channel count.</param>
/// <param name="destinationChannelCount">The destination channel count.</param>
/// <returns>DSP settings</returns>
/// <msdn-id>ee419052</msdn-id>
/// <unmanaged>void X3DAudioCalculate([In] const X3DAUDIOHANDLE* Instance,[In] const X3DAUDIO_LISTENER* pListener,[In] const X3DAUDIO_EMITTER* pEmitter,[In] X3DAudioCalculateFlags Flags,[In] void* pDSPSettings)</unmanaged>
/// <unmanaged-short>X3DAudioCalculate</unmanaged-short>
public DspSettings Calculate(Listener listener, Emitter emitter, CalculateFlags flags, int sourceChannelCount, int destinationChannelCount)
{
var settings = new DspSettings(sourceChannelCount, destinationChannelCount);
Calculate(listener, emitter, flags, settings);
return settings;
}
/// <summary>
/// Applies 3-D settings represented by the supplied settings object to the sound.
/// </summary>
/// <param name="settings">The DspSettings object that represents changes that should be made to this sound.</param>
/// <param name="sourceChannels">The source channel count.</param>
/// <param name="destinationChannels">The destination channel count.</param>
/// <param name="flags">The 3D flags to calculate. The default will calculate volume and doppler shift. This parameter is useful if it is not desirable for XAudio2 to calculate doppler on sounds that modify their own frequencies as an example; in this case, the flags should omit doppler.</param>
public void apply3D(DspSettings settings, int sourceChannels, int destinationChannels, CalculateFlags flags)
{
voice.SetOutputMatrix(sourceChannels, destinationChannels, settings.MatrixCoefficients);
if ((flags & CalculateFlags.Doppler) == CalculateFlags.Doppler)
{
voice.GetFrequencyRatio(out float freq);
voice.SetFrequencyRatio(settings.DopplerFactor * freq);
}
}
private void StartEngine()
{
if (m_audioEngine != null)
{
DisposeVoices();
m_audioEngine.CriticalError -= m_audioEngine_CriticalError;
m_audioEngine.Dispose();
}
// Init/reinit engine
m_audioEngine = new XAudio2(XAudio2Version.Version27);
// A way to disable SharpDX callbacks
//var meth = m_audioEngine.GetType().GetMethod("UnregisterForCallbacks_", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
//var callbacks = m_audioEngine.GetType().GetField("engineShadowPtr", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
//meth.Invoke((object)m_audioEngine, new object[] { callbacks.GetValue(m_audioEngine) });
m_audioEngine.CriticalError += m_audioEngine_CriticalError;
m_lastDeviceCount = m_audioEngine.DeviceCount;
m_deviceNumber = 0;
while (true) //find first non com device
{
try
{
m_deviceDetails = m_audioEngine.GetDeviceDetails(m_deviceNumber);
if (m_deviceDetails.Role == DeviceRole.DefaultCommunicationsDevice)
{
m_deviceNumber++;
if (m_deviceNumber == m_audioEngine.DeviceCount)
{
m_deviceNumber--;
break;
}
}
else
break;
}
catch(Exception e)
{
MyLog.Default.WriteLine(string.Format("Failed to get device details.\n\tdevice no.: {0}\n\tdevice count: {1}",m_deviceNumber, m_audioEngine.DeviceCount),LoggingOptions.AUDIO);
MyLog.Default.WriteLine(e.ToString());
m_deviceNumber = 0;
m_deviceDetails = m_audioEngine.GetDeviceDetails(m_deviceNumber);
break;
}
}
m_masterVoice = new MasteringVoice(m_audioEngine, XAudio2.DefaultChannels, XAudio2.DefaultSampleRate, m_deviceNumber);
if (m_useVolumeLimiter)
{
var limiter = new SharpDX.XAPO.Fx.MasteringLimiter(m_audioEngine);
var param = limiter.Parameter;
param.Loudness = 0;
limiter.Parameter = param;
//TODO: this throws exception in 3.0.1 version
var effectDescriptor = new EffectDescriptor(limiter);
m_masterVoice.SetEffectChain(effectDescriptor);
m_soundLimiterReady = true;
m_masterVoice.DisableEffect(0);
//m_masterVoice.EnableEffect(0);
//limiter.Dispose();
}
m_calculateFlags = CalculateFlags.Matrix | CalculateFlags.Doppler;
if ((m_deviceDetails.OutputFormat.ChannelMask & Speakers.LowFrequency) != 0)
{
m_calculateFlags |= CalculateFlags.RedirectToLfe;
}
var masterDetails = m_masterVoice.VoiceDetails;
m_gameAudioVoice = new SubmixVoice(m_audioEngine, masterDetails.InputChannelCount, masterDetails.InputSampleRate);
m_musicAudioVoice = new SubmixVoice(m_audioEngine, masterDetails.InputChannelCount, masterDetails.InputSampleRate);
m_hudAudioVoice = new SubmixVoice(m_audioEngine, masterDetails.InputChannelCount, masterDetails.InputSampleRate);
m_gameAudioVoiceDesc = new VoiceSendDescriptor[] { new VoiceSendDescriptor(m_gameAudioVoice) };
m_musicAudioVoiceDesc = new VoiceSendDescriptor[] { new VoiceSendDescriptor(m_musicAudioVoice) };
m_hudAudioVoiceDesc = new VoiceSendDescriptor[] { new VoiceSendDescriptor(m_hudAudioVoice) };
if (m_mute)
{ // keep sounds muted
m_gameAudioVoice.SetVolume(0);
m_musicAudioVoice.SetVolume(0);
}
m_reverb = new Reverb(m_audioEngine);
m_gameAudioVoice.SetEffectChain(new EffectDescriptor(m_reverb, masterDetails.InputChannelCount));
m_gameAudioVoice.DisableEffect(0);
}
public static void X3DAudioCalculate(ref X3DAudioHandle instance, Listener listener, Emitter emitter, CalculateFlags flags, IntPtr dSPSettings)
{
var nativeListener = new Listener.__Native();
listener.__MarshalTo(ref nativeListener);
var nativeEmitter = new Emitter.__Native();
emitter.__MarshalTo(ref nativeEmitter);
fixed(void *instance_ = &instance)
{
s_X3DAudioCalculate(instance_, &nativeListener, &nativeEmitter, (int)flags, (void *)dSPSettings);
}
emitter.__MarshalFree(ref nativeEmitter);
}
/// <summary>
/// Calculates DSP settings with respect to 3D parameters.
/// </summary>
/// <param name="listener">Represents the point of reception.</param>
/// <param name="emitter">Represents the sound source.</param>
/// <param name="flags">Bitwise combination of <see cref="CalculateFlags" /> specifying which 3D parameters to calculate.</param>
/// <param name="settings">
/// Instance of the <see cref="DspSettings" /> class that receives the calculation results.
/// </param>
public unsafe void X3DAudioCalculate(Listener listener, Emitter emitter, CalculateFlags flags,
DspSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (listener == null)
{
throw new ArgumentNullException("listener");
}
if (emitter == null)
{
throw new ArgumentNullException("emitter");
}
if ((int)flags == 0)
{
throw new ArgumentOutOfRangeException("flags");
}
if (emitter.ChannelCount > 1 && emitter.ChannelAzimuths == null)
{
throw new ArgumentException("No ChannelAzimuths set for the specified emitter. The ChannelAzimuths property must not be null if the ChannelCount of the emitter is bigger than 1.");
}
DspSettings.DspSettingsNative nativeSettings = settings.NativeInstance;
Listener.ListenerNative nativeListener = listener.NativeInstance;
Emitter.EmitterNative nativeEmitter = emitter.NativeInstance;
try
{
#region setup listener
//setup listener:
Cone listenerCone = listener.Cone.HasValue ? listener.Cone.Value : default(Cone);
IntPtr listenerConePtr = listener.Cone.HasValue ? (IntPtr)(&listenerCone) : IntPtr.Zero;
nativeListener.ConePtr = listenerConePtr;
#endregion
#region setup emitter
//setup emitter
IntPtr channelAzimuthsPtr = IntPtr.Zero;
if (emitter.ChannelAzimuths != null && emitter.ChannelAzimuths.Length > 0 && emitter.ChannelCount > 0)
{
const int sizeOfFloat = sizeof(float);
int channelAzimuthsSize = sizeOfFloat *
Math.Min(emitter.ChannelCount, emitter.ChannelAzimuths.Length);
channelAzimuthsPtr = Marshal.AllocHGlobal(channelAzimuthsSize);
ILUtils.WriteToMemory(channelAzimuthsPtr, emitter.ChannelAzimuths, 0,
channelAzimuthsSize / sizeOfFloat);
}
Cone emitterCone = emitter.Cone.HasValue ? emitter.Cone.Value : default(Cone);
IntPtr emitterConePtr = emitter.Cone.HasValue ? (IntPtr)(&emitterCone) : IntPtr.Zero;
nativeEmitter.ChannelAzimuthsPtr = channelAzimuthsPtr;
nativeEmitter.ConePtr = emitterConePtr;
nativeEmitter.LFECurvePtr = CurveNative.AllocMemoryAndBuildCurve(emitter.LowFrequencyEffectCurve);
nativeEmitter.LPFDirectCurvePtr = CurveNative.AllocMemoryAndBuildCurve(emitter.LowPassFilterDirectCurve);
nativeEmitter.LPFReverbCurvePtr = CurveNative.AllocMemoryAndBuildCurve(emitter.LowPassFilterReverbCurve);
nativeEmitter.ReverbCurvePtr = CurveNative.AllocMemoryAndBuildCurve(emitter.ReverbCurve);
nativeEmitter.VolumeCurvePtr = CurveNative.AllocMemoryAndBuildCurve(emitter.VolumeCurve);
#endregion
#region setup settings
//setup settings
fixed(void *pmc = settings.MatrixCoefficients, pdt = settings.DelayTimes)
{
nativeSettings.MatrixCoefficientsPtr = new IntPtr(pmc);
nativeSettings.DelayTimesPtr = new IntPtr(pdt);
#endregion
fixed(void *p = &_handle)
{
X3DAudioCalculate(new IntPtr(p), (IntPtr)(&nativeListener),
(IntPtr)(&nativeEmitter), flags,
new IntPtr(&nativeSettings));
}
settings.NativeInstance = nativeSettings;
}
}
finally
{
nativeEmitter.FreeMemory();
}
}
private void X3DAudioCalculate(IntPtr instance, IntPtr listener, IntPtr emitter, CalculateFlags flags,
IntPtr dspSettingsPtr)
{
_calculateDelegate(instance, listener, emitter, (int)flags, dspSettingsPtr);
}
/// <summary>
/// Calculates the 3D audio effect
/// </summary>
/// <param name="listener">Listener</param>
/// <param name="emitter">Emitter</param>
/// <param name="flags">Calculate flags</param>
/// <param name="dspSettings">DSP settings</param>
internal void Calculate3D(Listener listener, Emitter emitter, CalculateFlags flags, DspSettings dspSettings)
{
this.x3DInstance?.Calculate(listener, emitter, flags, dspSettings);
}
/// <summary>
/// Positions a sound in 3-D space
/// </summary>
/// <param name="sound">The ExtendedAudioBuffer to play.</param>
/// <param name="stop">If true, will stop the sound and return its position to 0 before playing it. Passing false will have the effect of resuming the sound from the last position it was stopped at.</param>
/// <param name="loop">Whether or not to loop the sound.</param>
/// <param name="x">The x coordinate of the source.</param>
/// <param name="y">The y coordinate of the source.</param>
/// <param name="z">The z coordinate of the source.</param>
/// <param name="vx">The x component of the velocity vector.</param>
/// <param name="vy">The y component of the velocity vector.</param>
/// <param name="vz">The z component of the velocity vector.</param>
/// <param name="flags">The 3D flags to calculate. The default will calculate volume and doppler shift. This parameter is useful if it is not desirable for XAudio2 to calculate doppler on sounds that modify their own frequencies as an example; in this case, the flags should omit doppler.</param>
public static void PlaySound3d(ExtendedAudioBuffer sound, bool stop, bool loop, float x, float y, float z, float vx = 0, float vy = 0, float vz = 0, CalculateFlags flags = CalculateFlags.Matrix | CalculateFlags.Doppler)
{
Emitter emitter = new Emitter {
ChannelCount = 1,
CurveDistanceScaler = 1.0f,
OrientFront = new Vector3(0, 0, 1),
OrientTop = new Vector3(0, 1, 0),
Position = new Vector3(x, y, z),
Velocity = new Vector3(vx, vy, vz)
};
sound.play(stop, loop);
DspSettings dspSettings = x3DAudio.Calculate(listener, emitter, flags, sound.getVoiceDetails().InputChannelCount, mainMasteringVoice.VoiceDetails.InputChannelCount);
sound.apply3D(dspSettings, sound.getVoiceDetails().InputChannelCount, mainMasteringVoice.VoiceDetails.InputChannelCount, flags);
}
public void Apply3D(SourceVoice voice, Listener listener, Emitter emitter, int srcChannels, int dstChannels, CalculateFlags flags, float maxDistance, float frequencyRatio)
{
unsafe
{
DspSettings settings;
int matrixCoefficientCount = srcChannels * dstChannels;
float *matrixCoefficients = stackalloc float[matrixCoefficientCount];
float *delay = stackalloc float[dstChannels];
settings.SrcChannelCount = srcChannels;
settings.DstChannelCount = dstChannels;
settings.MatrixCoefficientsPointer = new IntPtr(matrixCoefficients);
settings.DelayTimesPointer = new IntPtr(delay);
Calculate(listener, emitter, flags, &settings);
if (emitter.InnerRadius == 0f)
{
// approximated decay by distance
float decay = MathHelper.Clamp(1f - settings.EmitterToListenerDistance / maxDistance, 0f, 1f);
for (int i = 0; i < matrixCoefficientCount; i++)
{
matrixCoefficients[i] *= decay;
}
}
voice.SetOutputMatrix(null, settings.SrcChannelCount, settings.DstChannelCount, matrixCoefficients);
voice.SetFrequencyRatio(frequencyRatio * settings.DopplerFactor);
}
}
private void StartEngine()
{
if (m_audioEngine != null)
{
DisposeVoices();
m_audioEngine.Dispose();
}
// Init/reinit engine
m_audioEngine = new XAudio2();
// A way to disable SharpDX callbacks
//var meth = m_audioEngine.GetType().GetMethod("UnregisterForCallbacks_", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
//var callbacks = m_audioEngine.GetType().GetField("engineShadowPtr", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
//meth.Invoke((object)m_audioEngine, new object[] { callbacks.GetValue(m_audioEngine) });
m_audioEngine.CriticalError += m_audioEngine_CriticalError;
m_lastDeviceCount = m_audioEngine.DeviceCount;
m_deviceNumber = 0;
while (true) //find first non com device
{
try
{
m_deviceDetails = m_audioEngine.GetDeviceDetails(m_deviceNumber);
if (m_deviceDetails.Role == DeviceRole.DefaultCommunicationsDevice)
{
m_deviceNumber++;
if (m_deviceNumber == m_audioEngine.DeviceCount)
{
m_deviceNumber--;
break;
}
}
else
{
break;
}
}
catch (Exception e)
{
MyLog.Default.WriteLine(string.Format("Failed to get device details.\n\tdevice no.: {0}\n\tdevice count: {1}", m_deviceNumber, m_audioEngine.DeviceCount), LoggingOptions.AUDIO);
MyLog.Default.WriteLine(e.ToString());
m_deviceNumber = 0;
m_deviceDetails = m_audioEngine.GetDeviceDetails(m_deviceNumber);
break;
}
}
m_masterVoice = new MasteringVoice(m_audioEngine, deviceIndex: m_deviceNumber);
m_calculateFlags = CalculateFlags.Matrix | CalculateFlags.Doppler;
if ((m_deviceDetails.OutputFormat.ChannelMask & Speakers.LowFrequency) != 0)
{
m_calculateFlags |= CalculateFlags.RedirectToLfe;
}
var masterDetails = m_masterVoice.VoiceDetails;
m_gameAudioVoice = new SubmixVoice(m_audioEngine, masterDetails.InputChannelCount, masterDetails.InputSampleRate);
m_musicAudioVoice = new SubmixVoice(m_audioEngine, masterDetails.InputChannelCount, masterDetails.InputSampleRate);
m_hudAudioVoice = new SubmixVoice(m_audioEngine, masterDetails.InputChannelCount, masterDetails.InputSampleRate);
m_gameAudioVoiceDesc = new VoiceSendDescriptor[] { new VoiceSendDescriptor(m_gameAudioVoice) };
m_musicAudioVoiceDesc = new VoiceSendDescriptor[] { new VoiceSendDescriptor(m_musicAudioVoice) };
m_hudAudioVoiceDesc = new VoiceSendDescriptor[] { new VoiceSendDescriptor(m_hudAudioVoice) };
if (m_mute)
{ // keep sounds muted
m_gameAudioVoice.SetVolume(0);
m_musicAudioVoice.SetVolume(0);
}
}
/// <summary>
/// Calculate 3D Audio parameters.
/// </summary>
/// <param name="listener">The 3D audio listener definition.</param>
/// <param name="emitter">The 3D audio emitter definition.</param>
/// <param name="flags">The 3D audio calculate flags.</param>
/// <param name="dspSettings">The DSP settings.</param>
internal void Calculate3D(Listener listener, Emitter emitter, CalculateFlags flags, DspSettings dspSettings)
{
DisposeGuard();
x3DAudio.Calculate(listener, emitter, flags, dspSettings);
}
private void Apply3D(Vector3 listenerForward, Vector3 listenerUp, Vector3 listenerPosition, Vector3 listenerVelocity, Vector3 emitterForward, Vector3 emitterUp, Vector3 emitterPosition, Vector3 emitterVelocity)
{
if (!Effect.AudioManager.IsSpatialAudioEnabled)
{
throw new InvalidOperationException("Spatial audio must be enabled first.");
}
if (emitter == null)
{
emitter = new Emitter();
}
emitter.OrientFront = emitterForward;
emitter.OrientTop = emitterUp;
emitter.Position = emitterPosition;
emitter.Velocity = emitterVelocity;
emitter.DopplerScaler = SoundEffect.DopplerScale;
emitter.CurveDistanceScaler = SoundEffect.DistanceScale;
emitter.ChannelCount = Effect.Format.Channels;
//TODO: work out what ChannelAzimuths is supposed to be.
if (emitter.ChannelCount > 1)
{
emitter.ChannelAzimuths = new float[emitter.ChannelCount];
}
if (listener == null)
{
listener = new Listener();
}
listener.OrientFront = listenerForward;
listener.OrientTop = listenerUp;
listener.Position = listenerPosition;
listener.Velocity = listenerVelocity;
if (dspSettings == null)
{
dspSettings = new DspSettings(Effect.Format.Channels, Effect.AudioManager.MasteringVoice.VoiceDetails.InputChannelCount);
}
CalculateFlags flags = CalculateFlags.Matrix | CalculateFlags.Doppler | CalculateFlags.LpfDirect;
if ((Effect.AudioManager.Speakers & Speakers.LowFrequency) > 0)
{
// On devices with an LFE channel, allow the mono source data to be routed to the LFE destination channel.
flags |= CalculateFlags.RedirectToLfe;
}
if (Effect.AudioManager.IsReverbEffectEnabled)
{
flags |= CalculateFlags.Reverb | CalculateFlags.LpfReverb;
if (!isReverbSubmixEnabled)
{
VoiceSendFlags sendFlags = Effect.AudioManager.IsReverbFilterEnabled ? VoiceSendFlags.UseFilter : VoiceSendFlags.None;
VoiceSendDescriptor[] outputVoices = new VoiceSendDescriptor[]
{
new VoiceSendDescriptor {
OutputVoice = Effect.AudioManager.MasteringVoice, Flags = sendFlags
},
new VoiceSendDescriptor {
OutputVoice = Effect.AudioManager.ReverbVoice, Flags = sendFlags
}
};
voice.SetOutputVoices(outputVoices);
isReverbSubmixEnabled = true;
}
}
Effect.AudioManager.Calculate3D(listener, emitter, flags, dspSettings);
voice.SetFrequencyRatio(dspSettings.DopplerFactor);
voice.SetOutputMatrix(Effect.AudioManager.MasteringVoice, dspSettings.SourceChannelCount, dspSettings.DestinationChannelCount, dspSettings.MatrixCoefficients);
if (Effect.AudioManager.IsReverbEffectEnabled)
{
if (reverbLevels == null || reverbLevels.Length != Effect.Format.Channels)
{
reverbLevels = new float[Effect.Format.Channels];
}
for (int i = 0; i < reverbLevels.Length; i++)
{
reverbLevels[i] = dspSettings.ReverbLevel;
}
voice.SetOutputMatrix(Effect.AudioManager.ReverbVoice, Effect.Format.Channels, 1, reverbLevels);
}
if (Effect.AudioManager.IsReverbFilterEnabled)
{
FilterParameters filterDirect = new FilterParameters
{
Type = FilterType.LowPassFilter,
// see XAudio2CutoffFrequencyToRadians() in XAudio2.h for more information on the formula used here
Frequency = 2.0f * (float)Math.Sin(X3DAudio.PI / 6.0f * dspSettings.LpfDirectCoefficient),
OneOverQ = 1.0f
};
voice.SetOutputFilterParameters(Effect.AudioManager.MasteringVoice, filterDirect);
if (Effect.AudioManager.IsReverbEffectEnabled)
{
FilterParameters filterReverb = new FilterParameters
{
Type = FilterType.LowPassFilter,
// see XAudio2CutoffFrequencyToRadians() in XAudio2.h for more information on the formula used here
Frequency = 2.0f * (float)Math.Sin(X3DAudio.PI / 6.0f * dspSettings.LpfReverbCoefficient),
OneOverQ = 1.0f
};
voice.SetOutputFilterParameters(Effect.AudioManager.ReverbVoice, filterReverb);
}
}
}
public float Apply3D(SourceVoice voice, Listener listener, Emitter emitter, int srcChannels, int dstChannels, CalculateFlags flags, float maxDistance, float frequencyRatio, bool silent, bool use3DCalculation = true)
{
unsafe
{
DspSettings settings;
int matrixCoefficientCount = srcChannels * dstChannels;
float* matrixCoefficients = stackalloc float[matrixCoefficientCount];
float* delay = stackalloc float[dstChannels];
settings.SrcChannelCount = srcChannels;
settings.DstChannelCount = dstChannels;
settings.MatrixCoefficientsPointer = new IntPtr(matrixCoefficients);
settings.DelayTimesPointer = new IntPtr(delay);
if (use3DCalculation)
{
Calculate(listener, emitter, flags, &settings);
voice.SetFrequencyRatio(frequencyRatio * settings.DopplerFactor);
}
else
{ //realistic sounds
settings.EmitterToListenerDistance = Vector3.Distance(new Vector3(listener.Position.X, listener.Position.Y, listener.Position.Z), new Vector3(emitter.Position.X, emitter.Position.Y, emitter.Position.Z));
for(int i = 0; i < matrixCoefficientCount; i++)
matrixCoefficients[i] = 1f;
}
if (emitter.InnerRadius == 0f)
{
// approximated decay by distance
float decay;
if (silent)
decay = 0f;
else
decay = MathHelper.Clamp(1f - settings.EmitterToListenerDistance / maxDistance, 0f, 1f);
for (int i = 0; i < matrixCoefficientCount; i++)
{
matrixCoefficients[i] *= decay;
}
}
#if !XB1
voice.SetOutputMatrix(null, settings.SrcChannelCount, settings.DstChannelCount, matrixCoefficients);
#else // XB1
var matCoefs = new float[matrixCoefficientCount];
for (int i = 0; i < matrixCoefficientCount; i++)
matCoefs[i] = matrixCoefficients[i];
voice.SetOutputMatrix(null, settings.SrcChannelCount, settings.DstChannelCount, matCoefs);
#endif // XB1
return settings.EmitterToListenerDistance;
}
}
