diff --git a/Shared.targets b/Shared.targets index 69d9a2e..6949646 100644 --- a/Shared.targets +++ b/Shared.targets @@ -1,8 +1,8 @@ - 4.6.1 - 4.6.1 + 4.7.0 + 4.7.0 \ No newline at end of file diff --git a/Src/IPL.Generated.cs b/Src/IPL.Generated.cs index a850ba3..6374d2d 100644 --- a/Src/IPL.Generated.cs +++ b/Src/IPL.Generated.cs @@ -577,6 +577,23 @@ public enum AirAbsorptionModelType : int Callback, } + /// + /// The types of deviation model that can be used. + /// + public enum DeviationModelType : int + { + /// + /// The default deviation model. This is a physics-based model, based on the Uniform Theory of Diffraction, + /// with various additional assumptions. + /// + Default, + + /// + /// An arbitrary deviation model, defined by a callback function. + /// + Callback, + } + /// /// The different algorithms for simulating occlusion. /// @@ -2284,6 +2301,187 @@ public unsafe partial struct PathEffectParams /// @c IPLPathEffectSettings and @c binaural is set to @c IPL_TRUE. /// public IPL.CoordinateSpace3 Listener; + + /// + /// If @c IPL_TRUE, the values in @c eqCoeffs will be normalized before being used, i.e., each value in + /// @c eqCoeffs will be divided by the largest value in @c eqCoeffs. This can help counteract overly-aggressive + /// filtering due to a physics-based deviation model. If @c IPL_FALSE, the values in @c eqCoeffs will be + /// used as-is. + /// + [MarshalAs(UnmanagedType.U1)] + public bool NormalizeEQ; + } + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public readonly partial struct EnergyField : IEquatable + { + private readonly IntPtr _handle; + + public EnergyField(IntPtr handle) => _handle = handle; + + public IntPtr Handle => _handle; + + public bool Equals(EnergyField other) => _handle.Equals(other._handle); + + public override bool Equals(object obj) => obj is EnergyField other && Equals(other); + + public override int GetHashCode() => _handle.GetHashCode(); + + public override string ToString() => "0x" + (IntPtr.Size == 8 ? _handle.ToString("X16") : _handle.ToString("X8")); + + public static bool operator ==(EnergyField left, EnergyField right) => left.Equals(right); + + public static bool operator !=(EnergyField left, EnergyField right) => !left.Equals(right); + } + + /// + /// Settings used to create an energy field. + /// + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public partial struct EnergyFieldSettings + { + /// + /// Total duration (in seconds) of the energy field. This determines the number of bins in each channel and band. + /// + public float Duration; + + /// + /// The Ambisonic order. This determines the number of channels. + /// + public int Order; + } + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public readonly partial struct ImpulseResponse : IEquatable + { + private readonly IntPtr _handle; + + public ImpulseResponse(IntPtr handle) => _handle = handle; + + public IntPtr Handle => _handle; + + public bool Equals(ImpulseResponse other) => _handle.Equals(other._handle); + + public override bool Equals(object obj) => obj is ImpulseResponse other && Equals(other); + + public override int GetHashCode() => _handle.GetHashCode(); + + public override string ToString() => "0x" + (IntPtr.Size == 8 ? _handle.ToString("X16") : _handle.ToString("X8")); + + public static bool operator ==(ImpulseResponse left, ImpulseResponse right) => left.Equals(right); + + public static bool operator !=(ImpulseResponse left, ImpulseResponse right) => !left.Equals(right); + } + + /// + /// Settings used to create an impulse response. + /// + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public partial struct ImpulseResponseSettings + { + /// + /// Total duration (in seconds) of the impulse response. This determines the number of samples in each channel. + /// + public float Duration; + + /// + /// The Ambisonic order. This determines the number of channels. + /// + public int Order; + + /// + /// The sampling rate. This, together with the duration, determines the number of samples in each channel. + /// + public int SamplingRate; + } + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public readonly partial struct Reconstructor : IEquatable + { + private readonly IntPtr _handle; + + public Reconstructor(IntPtr handle) => _handle = handle; + + public IntPtr Handle => _handle; + + public bool Equals(Reconstructor other) => _handle.Equals(other._handle); + + public override bool Equals(object obj) => obj is Reconstructor other && Equals(other); + + public override int GetHashCode() => _handle.GetHashCode(); + + public override string ToString() => "0x" + (IntPtr.Size == 8 ? _handle.ToString("X16") : _handle.ToString("X8")); + + public static bool operator ==(Reconstructor left, Reconstructor right) => left.Equals(right); + + public static bool operator !=(Reconstructor left, Reconstructor right) => !left.Equals(right); + } + + /// + /// Settings used to create a reconstructor. + /// + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public partial struct ReconstructorSettings + { + /// + /// The largest possible duration (in seconds) of any impulse response that will be reconstructed using this + /// reconstructor. + /// + public float MaxDuration; + + /// + /// The largest possible Ambisonic order of any impulse response that will be reconstructed using this + /// reconstructor. + /// + public int MaxOrder; + + /// + /// The sampling rate of impulse responses reconstructed using this reconstructor. + /// + public int SamplingRate; + } + + /// + /// The inputs for a single reconstruction operation. + /// + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public partial struct ReconstructorInputs + { + /// + /// The energy field from which to reconstruct an impulse response. + /// + public IPL.EnergyField EnergyField; + } + + /// + /// Inputs common to all reconstruction operations specified in a single call to @c iplReconstructorReconstruct. + /// + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public partial struct ReconstructorSharedInputs + { + /// + /// Duration of impulse responses to reconstruct. Must be less than or equal to @c maxDuration specified in + /// @c IPLReconstructorSettings. + /// + public float Duration; + + /// + /// Ambisonic order of impulse responses to reconstruct. Must be less than or equal to @c maxOrder specified in + /// @c IPLReconstructorSettings. + /// + public int Order; + } + + /// + /// The outputs for a single reconstruction operation. + /// + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public partial struct ReconstructorOutputs + { + /// + /// The impulse response object into which the reconstructed impulse repsonse should be stored. + /// + public IPL.ImpulseResponse ImpulseResponse; } [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] @@ -2726,6 +2924,34 @@ public partial struct Directivity [UnmanagedFunctionPointer(CallingConvention.Cdecl)] public delegate float DirectivityCallback(IPL.Vector3 direction, IntPtr userData); + /// + /// A deviation model that can be used for modeling frequency-dependent attenuation of sound as it + /// bends along the path from the source to the listener. + /// + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public partial struct DeviationModel + { + /// + /// The type of deviation model to use. + /// + public IPL.DeviationModelType Type; + + /// + /// When @c type is @c IPL_DEVIATIONTYPE_CALLBACK, this function will be called whenever Steam Audio + /// needs to evaluate deviation-based attenuation. + /// + public IPL.DeviationCallback Callback; + + /// + /// Pointer to arbitrary data that will be provided to the @c callback function whenever it is called. + /// May be @c NULL. + /// + public IntPtr UserData; + } + + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public delegate float DeviationCallback(float angle, int band, IntPtr userData); + /// /// Settings used to create a simulator. /// @@ -2990,6 +3216,11 @@ public unsafe partial struct SimulationInputs /// increased CPU usage. /// public int NumTransmissionRays; + + /// + /// The deviation model to use for this source. Only used when simulating pathing. + /// + public IntPtr DeviationModel; } /// @@ -4534,6 +4765,320 @@ public partial struct SimulationOutputs [DllImport(Library, EntryPoint = "iplPathEffectGetTail", CallingConvention = CallingConvention.Cdecl)] public static extern IPL.AudioEffectState PathEffectGetTail(IPL.PathEffect effect, ref IPL.AudioBuffer @out); + /// + /// Creates an energy field. + /// + /// The context used to initialize Steam Audio. + /// The settings to use when creating the energy field. + /// [out] The created energy field. + /// Status code indicating whether or not the operation succeeded. + [DllImport(Library, EntryPoint = "iplEnergyFieldCreate", CallingConvention = CallingConvention.Cdecl)] + public static extern IPL.Error EnergyFieldCreate(IPL.Context context, in IPL.EnergyFieldSettings settings, out IPL.EnergyField energyField); + + /// + /// Retains an additional reference to an energy field. + /// + /// The energy field to retain a reference to. + /// The additional reference to the energy field. + [DllImport(Library, EntryPoint = "iplEnergyFieldRetain", CallingConvention = CallingConvention.Cdecl)] + public static extern IPL.EnergyField EnergyFieldRetain(IPL.EnergyField energyField); + + /// + /// Releases a reference to an energy field. + /// + /// The energy field to release a reference to. + [DllImport(Library, EntryPoint = "iplEnergyFieldRelease", CallingConvention = CallingConvention.Cdecl)] + public static extern void EnergyFieldRelease(ref IPL.EnergyField energyField); + + /// + /// Returns the number of channels in the energy field. + /// + /// The energy field. + /// The number of channels in the energy field. + [DllImport(Library, EntryPoint = "iplEnergyFieldGetNumChannels", CallingConvention = CallingConvention.Cdecl)] + public static extern int EnergyFieldGetNumChannels(IPL.EnergyField energyField); + + /// + /// Returns the number of bins in the energy field. + /// + /// The energy field. + /// The number of bins in the energy field. + [DllImport(Library, EntryPoint = "iplEnergyFieldGetNumBins", CallingConvention = CallingConvention.Cdecl)] + public static extern int EnergyFieldGetNumBins(IPL.EnergyField energyField); + + /// + /// Returns a pointer to the data stored in the energy field. + /// + /// The energy field. + /// Pointer to #channels * #bands * #bins IPLfloat32 values stored in the energy field, in row-major order. + [DllImport(Library, EntryPoint = "iplEnergyFieldGetData", CallingConvention = CallingConvention.Cdecl)] + public static extern ref float EnergyFieldGetData(IPL.EnergyField energyField); + + /// + /// Returns a pointer to the data stored in the energy field for the given channel. + /// + /// The energy field. + /// Index of the channel. + /// Pointer to #bands * #bins IPLfloat32 values stored in the energy field for the given channel, in + /// row-major order. + [DllImport(Library, EntryPoint = "iplEnergyFieldGetChannel", CallingConvention = CallingConvention.Cdecl)] + public static extern ref float EnergyFieldGetChannel(IPL.EnergyField energyField, int channelIndex); + + /// + /// Returns a pointer to the data stored in the energy field for the given channel and band. + /// + /// The energy field. + /// Index of the channel. + /// Index of the band. + /// Pointer to #bins IPLfloat32 values stored in the energy field for the given channel and band, in row-major + /// order. + [DllImport(Library, EntryPoint = "iplEnergyFieldGetBand", CallingConvention = CallingConvention.Cdecl)] + public static extern ref float EnergyFieldGetBand(IPL.EnergyField energyField, int channelIndex, int bandIndex); + + /// + /// Resets all values stored in an energy field to zero. + /// + /// The energy field. + [DllImport(Library, EntryPoint = "iplEnergyFieldReset", CallingConvention = CallingConvention.Cdecl)] + public static extern void EnergyFieldReset(IPL.EnergyField energyField); + + /// + /// Copies data from one energy field into another. + /// + /// The source energy field. + /// The destination energy field. + /// + /// If the source and destination energy fields have different numbers of channels, only the smaller of the two + /// numbers of channels will be copied.If the source and destination energy fields have different numbers of bins, only the smaller of the two numbers of + /// bins will be copied. + /// + [DllImport(Library, EntryPoint = "iplEnergyFieldCopy", CallingConvention = CallingConvention.Cdecl)] + public static extern void EnergyFieldCopy(IPL.EnergyField src, IPL.EnergyField dst); + + /// + /// Swaps the data contained in one energy field with the data contained in another energy field. + /// + /// The first energy field. + /// The second energy field. + /// + /// The two energy fields may contain different numbers of channels or bins. + /// + [DllImport(Library, EntryPoint = "iplEnergyFieldSwap", CallingConvention = CallingConvention.Cdecl)] + public static extern void EnergyFieldSwap(IPL.EnergyField a, IPL.EnergyField b); + + /// + /// Adds the values stored in two energy fields, and stores the result in a third energy field. + /// + /// The first input energy field. + /// The second input energy field. + /// The output energy field. + /// + /// If the energy fields have different numbers of channels, only the smallest of the three numbers of channels will + /// be added.If the energy fields have different numbers of bins, only the smallest of the three numbers of bins will + /// be added.This function can be used for in-place addition, i.e. @c out may be equal to @c in1 or @c in2. + /// + [DllImport(Library, EntryPoint = "iplEnergyFieldAdd", CallingConvention = CallingConvention.Cdecl)] + public static extern void EnergyFieldAdd(IPL.EnergyField in1, IPL.EnergyField in2, IPL.EnergyField @out); + + /// + /// Scales the values stored in an energy field by a scalar, and stores the result in a second energy field. + /// + /// The input energy field. + /// The scalar value. + /// The output energy field. + /// + /// If the energy fields have different numbers of channels, only the smallest of the two numbers of channels will + /// be scaled.If the energy fields have different numbers of bins, only the smallest of the two numbers of bins will + /// be scaled.This function can be used for in-place scaling, i.e. @c out may be equal to @c in. + /// + [DllImport(Library, EntryPoint = "iplEnergyFieldScale", CallingConvention = CallingConvention.Cdecl)] + public static extern void EnergyFieldScale(IPL.EnergyField @in, float scalar, IPL.EnergyField @out); + + /// + /// Scales the values stored in an energy field by a scalar, and adds the result to a second energy field. + /// + /// The input energy field. + /// The scalar value. + /// The output energy field. + /// + /// If the energy fields have different numbers of channels, only the smallest of the two numbers of channels will + /// be added.If the energy fields have different numbers of bins, only the smallest of the two numbers of bins will + /// be added.This function can be used for in-place operation, i.e. @c out may be equal to @c in. + /// + [DllImport(Library, EntryPoint = "iplEnergyFieldScaleAccum", CallingConvention = CallingConvention.Cdecl)] + public static extern void EnergyFieldScaleAccum(IPL.EnergyField @in, float scalar, IPL.EnergyField @out); + + /// + /// Creates an impulse response. + /// + /// The context used to initialize Steam Audio. + /// The settings to use when creating the impulse response. + /// [out] The created impulse response. + /// Status code indicating whether or not the operation succeeded. + [DllImport(Library, EntryPoint = "iplImpulseResponseCreate", CallingConvention = CallingConvention.Cdecl)] + public static extern IPL.Error ImpulseResponseCreate(IPL.Context context, in IPL.ImpulseResponseSettings settings, out IPL.ImpulseResponse impulseResponse); + + /// + /// Retains an additional reference to an impulse response. + /// + /// The impulse response to retain a reference to. + /// The additional reference to the impulse response. + [DllImport(Library, EntryPoint = "iplImpulseResponseRetain", CallingConvention = CallingConvention.Cdecl)] + public static extern IPL.ImpulseResponse ImpulseResponseRetain(IPL.ImpulseResponse impulseResponse); + + /// + /// Releases a reference to an impulse response. + /// + /// The impulse response to release a reference to. + [DllImport(Library, EntryPoint = "iplImpulseResponseRelease", CallingConvention = CallingConvention.Cdecl)] + public static extern void ImpulseResponseRelease(ref IPL.ImpulseResponse impulseResponse); + + /// + /// Returns the number of channels in the impulse response. + /// + /// The impulse response. + /// The number of channels in the impulse response. + [DllImport(Library, EntryPoint = "iplImpulseResponseGetNumChannels", CallingConvention = CallingConvention.Cdecl)] + public static extern int ImpulseResponseGetNumChannels(IPL.ImpulseResponse impulseResponse); + + /// + /// Returns the number of samples in the impulse response. + /// + /// The impulse response. + /// The number of samples in the impulse response. + [DllImport(Library, EntryPoint = "iplImpulseResponseGetNumSamples", CallingConvention = CallingConvention.Cdecl)] + public static extern int ImpulseResponseGetNumSamples(IPL.ImpulseResponse impulseResponse); + + /// + /// Returns a pointer to the data stored in the impulse response. + /// + /// The impulse response. + /// Pointer to #channels * #samples IPLfloat32 values stored in the impulse response, in row-major order. + [DllImport(Library, EntryPoint = "iplImpulseResponseGetData", CallingConvention = CallingConvention.Cdecl)] + public static extern ref float ImpulseResponseGetData(IPL.ImpulseResponse impulseResponse); + + /// + /// Returns a pointer to the data stored in the impulse response for the given channel. + /// + /// The impulse response. + /// Index of the channel. + /// Pointer to #samples IPLfloat32 values stored in the impulse response for the given channel, in + /// row-major order. + [DllImport(Library, EntryPoint = "iplImpulseResponseGetChannel", CallingConvention = CallingConvention.Cdecl)] + public static extern ref float ImpulseResponseGetChannel(IPL.ImpulseResponse impulseResponse, int channelIndex); + + /// + /// Resets all values stored in an impulse response to zero. + /// + /// The impulse response. + [DllImport(Library, EntryPoint = "iplImpulseResponseReset", CallingConvention = CallingConvention.Cdecl)] + public static extern void ImpulseResponseReset(IPL.ImpulseResponse impulseResponse); + + /// + /// Copies data from one impulse response into another. + /// + /// The source impulse response. + /// The destination impulse response. + /// + /// If the source and destination impulse responses have different numbers of channels, only the smaller of the two + /// numbers of channels will be copied.If the source and destination impulse responses have different numbers of samples, only the smaller of the two numbers of + /// samples will be copied. + /// + [DllImport(Library, EntryPoint = "iplImpulseResponseCopy", CallingConvention = CallingConvention.Cdecl)] + public static extern void ImpulseResponseCopy(IPL.ImpulseResponse src, IPL.ImpulseResponse dst); + + /// + /// Swaps the data contained in one impulse response with the data contained in another impulse response. + /// + /// The first impulse response. + /// The second impulse response. + /// + /// The two impulse responses may contain different numbers of channels or samples. + /// + [DllImport(Library, EntryPoint = "iplImpulseResponseSwap", CallingConvention = CallingConvention.Cdecl)] + public static extern void ImpulseResponseSwap(IPL.ImpulseResponse ir1, IPL.ImpulseResponse ir2); + + /// + /// Adds the values stored in two impulse responses, and stores the result in a third impulse response. + /// + /// The first input impulse response. + /// The second input impulse response. + /// The output impulse response. + /// + /// If the impulse responses have different numbers of channels, only the smallest of the three numbers of channels will + /// be added.If the impulse responses have different numbers of samples, only the smallest of the three numbers of samples will + /// be added.This function can be used for in-place addition, i.e. @c out may be equal to @c in1 or @c in2. + /// + [DllImport(Library, EntryPoint = "iplImpulseResponseAdd", CallingConvention = CallingConvention.Cdecl)] + public static extern void ImpulseResponseAdd(IPL.ImpulseResponse in1, IPL.ImpulseResponse in2, IPL.ImpulseResponse @out); + + /// + /// Scales the values stored in an impulse response by a scalar, and stores the result in a second impulse response. + /// + /// The input impulse response. + /// The scalar value. + /// The output impulse response. + /// + /// If the impulse responses have different numbers of channels, only the smallest of the two numbers of channels will + /// be scaled.If the impulse responses have different numbers of samples, only the smallest of the two numbers of samples will + /// be scaled.This function can be used for in-place scaling, i.e. @c out may be equal to @c in. + /// + [DllImport(Library, EntryPoint = "iplImpulseResponseScale", CallingConvention = CallingConvention.Cdecl)] + public static extern void ImpulseResponseScale(IPL.ImpulseResponse @in, float scalar, IPL.ImpulseResponse @out); + + /// + /// Scales the values stored in an impulse response by a scalar, and adds the result to a second impulse response. + /// + /// The input impulse response. + /// The scalar value. + /// The output impulse response. + /// + /// If the impulse responses have different numbers of channels, only the smallest of the two numbers of channels will + /// be added.If the impulse responses have different numbers of samples, only the smallest of the two numbers of samples will + /// be added.This function can be used for in-place operation, i.e. @c out may be equal to @c in. + /// + [DllImport(Library, EntryPoint = "iplImpulseResponseScaleAccum", CallingConvention = CallingConvention.Cdecl)] + public static extern void ImpulseResponseScaleAccum(IPL.ImpulseResponse @in, float scalar, IPL.ImpulseResponse @out); + + /// + /// Creates a reconstructor. + /// + /// The context used to initialize Steam Audio. + /// The settings to use when creating the reconstructor. + /// [out] The created reconstructor. + /// Status code indicating whether or not the operation succeeded. + [DllImport(Library, EntryPoint = "iplReconstructorCreate", CallingConvention = CallingConvention.Cdecl)] + public static extern IPL.Error ReconstructorCreate(IPL.Context context, in IPL.ReconstructorSettings settings, out IPL.Reconstructor reconstructor); + + /// + /// Retains an additional reference to a reconstructor. + /// + /// The reconstructor to retain a reference to. + /// The additional reference to the reconstructor. + [DllImport(Library, EntryPoint = "iplReconstructorRetain", CallingConvention = CallingConvention.Cdecl)] + public static extern IPL.Reconstructor ReconstructorRetain(IPL.Reconstructor reconstructor); + + /// + /// Releases a reference to a reconstructor. + /// + /// The reconstructor to release a reference to. + [DllImport(Library, EntryPoint = "iplReconstructorRelease", CallingConvention = CallingConvention.Cdecl)] + public static extern void ReconstructorRelease(ref IPL.Reconstructor reconstructor); + + /// + /// Reconstructs one or more impulse responses as a single batch of work. + /// + /// The reconstructor to use. + /// The number of impulse responses to reconstruct. + /// Pointer to @c numInputs input structures, each describing a single energy field from which + /// to reconstruct a corresponding impulse response. + /// Pointer to a single shared input structure, describing common inputs used across all + /// impulse response reconstruction operations in this call. + /// Pointer to @c numInputs output structures, each describing a single impulse response object + /// into which to write the corresponding reconstructed impulse response. + [DllImport(Library, EntryPoint = "iplReconstructorReconstruct", CallingConvention = CallingConvention.Cdecl)] + public static extern void ReconstructorReconstruct(IPL.Reconstructor reconstructor, int numInputs, in IPL.ReconstructorInputs inputs, in IPL.ReconstructorSharedInputs sharedInputs, in IPL.ReconstructorOutputs outputs); + /// /// Creates an empty probe array. /// @@ -4673,6 +5218,27 @@ public partial struct SimulationOutputs [DllImport(Library, EntryPoint = "iplProbeBatchGetDataSize", CallingConvention = CallingConvention.Cdecl)] public static extern ulong ProbeBatchGetDataSize(IPL.ProbeBatch probeBatch, in IPL.BakedDataIdentifier identifier); + /// + /// Retrieves a single energy field in a specific baked data layer of a specific probe in a probe batch. + /// + /// The probe batch. + /// The identifier of the baked data layer. + /// The index of the probe. + /// The energy field into which to copy the baked energy field. + [DllImport(Library, EntryPoint = "iplProbeBatchGetEnergyField", CallingConvention = CallingConvention.Cdecl)] + public static extern void ProbeBatchGetEnergyField(IPL.ProbeBatch probeBatch, in IPL.BakedDataIdentifier identifier, int probeIndex, IPL.EnergyField energyField); + + /// + /// Retrieves a single array of parametric reverb times in a specific baked data layer of a specific probe in a probe batch. + /// + /// The probe batch. + /// The identifier of the baked data layer. + /// The index of the probe. + /// Pointer to an array containing at least 3 IPLfloat32 values, into which the baked reverb times + /// will be copied. + [DllImport(Library, EntryPoint = "iplProbeBatchGetReverb", CallingConvention = CallingConvention.Cdecl)] + public static extern void ProbeBatchGetReverb(IPL.ProbeBatch probeBatch, in IPL.BakedDataIdentifier identifier, int probeIndex, in float reverbTimes); + /// /// Bakes a single layer of reflections data in a probe batch. /// @@ -4865,16 +5431,22 @@ public partial struct SimulationOutputs /// /// Adds a source to the set of sources processed by a simulator in subsequent simulations. /// - /// The source to add. /// The simulator being used. + /// The source to add. + /// + /// Call @c iplSimulatorCommit after calling this function for the changes to take effect. + /// [DllImport(Library, EntryPoint = "iplSourceAdd", CallingConvention = CallingConvention.Cdecl)] public static extern void SourceAdd(IPL.Source source, IPL.Simulator simulator); /// /// Removes a source from the set of sources processed by a simulator in subsequent simulations. /// - /// The source to remove. /// The simulator being used. + /// The source to remove. + /// + /// Call @c iplSimulatorCommit after calling this function for the changes to take effect. + /// [DllImport(Library, EntryPoint = "iplSourceRemove", CallingConvention = CallingConvention.Cdecl)] public static extern void SourceRemove(IPL.Source source, IPL.Simulator simulator); @@ -4935,9 +5507,9 @@ public partial struct SimulationOutputs public const uint VersionMajor = 4; - public const uint VersionMinor = 6; + public const uint VersionMinor = 7; - public const uint VersionPatch = 1; + public const uint VersionPatch = 0; public const uint Version = (((uint)(VersionMajor)<<16)|((uint)(VersionMinor)<<8)|((uint)(VersionPatch))); }