fmod 0.9.1 → 0.9.2

data/lib/fmod/core/window_type.rb

@@ -1,11 +1,57 @@
 module FMOD
   module Core
+
+    ##
+    # List of windowing methods for the {Effects::FFT} unit. Used in spectrum
+    # analysis to reduce leakage / transient signals interfering with the
+    # analysis.
+    #
+    # This is a problem with analysis of continuous signals that only have a
+    # small portion of the signal sample (the FFT window size).
+    #
+    # Windowing the signal with a curve or triangle tapers the sides of the FFT
+    # window to help alleviate this problem.
+    #
+    # Cyclic signals such as a sine wave that repeat their cycle in a multiple
+    # of the window size do not need windowing. I.e. If the sine wave repeats
+    # every 1024, 512, 256 etc samples and the FMOD FFT window is 1024, then the
+    # signal would not need windowing.
+    #
+    # Not windowing is the same as :rectangle, which is the default.
+    #
+    # If the cycle of the signal (ie the sine wave) is not a multiple of the
+    # window size, it will cause frequency abnormalities, so a different
+    # windowing method is needed.
     module WindowType
+
+      ##
+      # Rectangle.
+      #   w[n] = 1.0
       RECT = 0
+
+      ##
+      # Triangle.
+      #   w[n] = TRI(2n/N)
       TRIANGLE = 1
+
+      ##
+      # Hamming.
+      #   w[n] = 0.54 - (0.46 * COS(n/N) )
       HAMMING = 2
+
+      ##
+      # Hanning.
+      #   w[n] = 0.5 * (1.0 - COS(n/N) )
       HANNING = 3
+
+      ##
+      # Blackman.
+      #   w[n] = 0.42 - (0.5 * COS(n/N) ) + (0.08 * COS(2.0 * n/N) )
       BLACKMAN = 4
+
+      ##
+      # Blackman-Harris.
+      #   w[n] = 0.35875 - (0.48829 * COS(1.0 * n/N)) + (0.14128 * COS(2.0 * n/N)) - (0.01168 * COS(3.0 * n/N))
       BLACKMAN_HARRIS = 5
     end
   end

data/lib/fmod/dsp.rb

@@ -1,17 +1,84 @@
 module FMOD
 
-  # @attr wet_dry_mix [WetDryMix] Allows the user to scale the affect of a DSP
-  #   effect, through control of the "wet" mix, which is the post-processed
-  #   signal and the "dry" which is the pre-processed signal.
-  #
-  #   The dry signal path is silent by default, because DSP effects transform
-  #   the input and pass the newly processed result to the output. It does not
-  #   add to the input.
+
+  ##
+  # Represents a digital signal processor. This allows for monitoring and
+  # applying effects to the sound in real-time.
   class Dsp < Handle
 
+    ##
+    # Describes mix levels that allow the user to scale the affect of a DSP
+    # effect, through control of the "wet" mix, which is the post-processed
+    # signal and the "dry" which is the pre-processed signal.
+    #
+    # @attr pre_wet [Float] A floating point value from 0.0 to 1.0, describing a
+    #   linear scale of the "wet" (pre-processed signal) mix of the effect.
+    #   Default is 1.0. Scale can be lower than 0.0 (negating) and higher than
+    #   1.0 (amplifying).
+    # @attr post_wet [Float] A floating point value from 0.0 to 1.0, describing
+    #   a linear scale of the "'wet' "(post-processed signal) mix of the effect.
+    #   Default is 1.0. Scale can be lower than 0.0 (negating) and higher than
+    #   1.0 (amplifying).
+    # @attr dry [Float] A floating point value from 0.0 to 1.0, describing a
+    #   linear scale of the "dry" (pre-processed signal) mix of the effect.
+    #   Default is 0.0. Scale can be lower than 0.0 and higher than 1.0
+    #   (amplifying).
+    WetDryMix = Struct.new(:pre_wet, :post_wet, :dry)
+
+    ##
+    #  Defines the signal format of a dsp unit so that the signal is processed
+    #  on the speakers specified, as well as the number of channels in the unit
+    #  that a read callback will process, and the output signal of the unit.
+    #
+    # Setting the number of channels on a unit will force a down or up mix to
+    # that channel count before processing the DSP read callback. This count is
+    # then sent to the outputs of the unit.
+    #
+    # The speaker mode is informational, when the mask describes what bits are
+    # active, and the channel count describes how many channels are in a buffer,
+    # speaker mode describes where the channels originated from. For example if
+    # the channel count is 2 then this could describe for the DSP if the
+    # original signal started from a stereo signal or a 5.1 signal.
+    #
+    # It could also describe the signal as all monaural, for example if the
+    # channel count was 16 and the speaker mode was {SpeakerMode::MONO}.
+    #
+    # @attr mask [Integer] A series of bits specified by {ChannelMask} to
+    #   determine which speakers are represented by the channels in the signal.
+    # @attr count [Integer] The number of channels to be processed on this unit
+    #   and sent to the outputs connected to it. Maximum of
+    #   {FMOD::MAX_CHANNEL_WIDTH}.
+    # @attr speaker_mode [Integer] The source speaker mode where the signal came
+    #   from.
+    #
+    # @see ChannelMask
+    # @see SpeakerMode
     ChannelFormat = Struct.new(:mask, :count, :speaker_mode)
 
+    ##
+    # Contains information about the current DSP unit, including name, version,
+    # default channels and width and height of configuration dialog box if it
+    # exists.
+    #
+    # @attr name [String] The name of the unit.
+    # @attr version [String] The version number of the DSP unit.
+    # @attr channels [Integer] The number of channels the unit was initialized
+    #   with. 0 means the plugin will process whatever number of channels is
+    #   currently in the network. >0 would be mostly used if the unit is a unit
+    #   that only generates sound, or is not flexible enough to take any number
+    #   of input channels.
+    # @attr width [Integer] The width of an optional configuration dialog box
+    #   that can be displayed with {Dsp.show_dialog}. 0 means the dialog is not
+    #   present.
+    # @attr height [Integer] The height of an optional configuration dialog box
+    #   that can be displayed with {Dsp.show_dialog}. 0 means the dialog is not
+    #   present.
     DspInfo = Struct.new(:name, :version, :channels, :width, :height) do
+
+      # @!method config?
+      # @return [Boolean] a flag indicating if DSP unit has an optional
+      #   configuration dialog that can be displayed.
+      # @note None of the built-in DSP units contain a dialog.
       def config?
         width > 0 && height > 0
       end
@@ -65,6 +132,20 @@ module FMOD
       raise TypeError, "#{type} is not a Integer or Class."
     end
 
+    ##
+    # Plays a sound object on a particular channel and {ChannelGroup}.
+    #
+    # When a sound is played, it will use the sound's default frequency and
+    # priority.
+    #
+    # @param group [ChannelGroup] The {ChannelGroup} become a member of. This is
+    #   more efficient than using {Channel.group}, as it does it during the
+    #   channel setup, rather than connecting to the master channel group, then
+    #   later disconnecting and connecting to the new {ChannelGroup} when
+    #   specified. Specify +nil+ to ignore (use master {ChannelGroup}).
+    #
+    # @return [Channel] the newly playing channel.
+    # @see System.play_dsp
     def play(group = nil)
       parent.play_dsp(self, group, false)
     end
@@ -185,6 +266,17 @@ module FMOD
       "#{version[0, 4].to_i}.#{version[4, 4].to_i}"
     end
 
+    # @attribute wet_dry_mix
+    # Allows the user to scale the affect of a DSP effect, through control of
+    # the "wet" mix, which is the post-processed signal and the "dry" which is
+    # the pre-processed signal.
+    #
+    # The dry signal path is silent by default, because DSP effects transform
+    # the input and pass the newly processed result to the output. It does not
+    # add to the input.
+    #
+    # @return [WetDryMix] the current mix.
+    # @see WetDryMix
     def wet_dry_mix
       args = ["\0" * SIZEOF_FLOAT, "\0" * SIZEOF_FLOAT, "\0" * SIZEOF_FLOAT]
       FMOD.invoke(:DSP_GetWetDryMix, self, *args)
@@ -226,14 +318,10 @@ module FMOD
       self
     end
 
-
-
-
-
-
-
-
-
+    # @!attribute channel_format
+    # @return [ChannelFormat] The signal format of a DSP unit so that the signal
+    #   is processed on the speakers specified.
+    # @see ChannelFormat
     def channel_format
       args = ["\0" * SIZEOF_INT, "\0" * SIZEOF_INT, "\0" * SIZEOF_INT]
       FMOD.invoke(:DSP_GetChannelFormat, self, *args)
@@ -247,16 +335,10 @@ module FMOD
       format
     end
 
-    def param_info(index)
-      return nil unless FMOD.valid_range?(index, 0, parameter_count, false)
-      FMOD.invoke(:DSP_GetParameterInfo, self, index, info = int_ptr)
-      ParameterInfo.new(info.unpack1('J'))
-    end
-
-    def to_s
-      "#{name} v.#{version}"
-    end
-
+    ##
+    # @return [DspInfo] the information about the current DSP unit, including
+    # name, version, default channels and width and height of configuration
+    # dialog box if it exists.
     def info
       name, vs = "\0" * 32, "\0" * SIZEOF_INT
       args = ["\0" * SIZEOF_INT, "\0" * SIZEOF_INT, "\0" * SIZEOF_INT]
@@ -267,67 +349,152 @@ module FMOD
       DspInfo.new(name.delete("\0"), version, *args)
     end
 
+    ##
+    # Calls the DSP unit's reset function, which will clear internal buffers and
+    # reset the unit back to an initial state.
+    #
+    # Calling this function is useful if the DSP unit relies on a history to
+    # process itself (ie an echo filter).
+    #
+    # If you disconnected the unit and reconnected it to a different part of the
+    # network with a different sound, you would want to call this to reset the
+    # units state (ie clear and reset the echo filter) so that you dont get left
+    # over artifacts from the place it used to be connected.
+    #
+    # @return [void]
     def reset
       FMOD.invoke(:DSP_Reset, self)
     end
 
+    ##
+    # @!attribute [r] parent
+    # @return [System] the parent {System} object that was used to create this
+    #   object.
     def parent
       FMOD.invoke(:DSP_GetSystemObject, self, system = int_ptr)
       System.new(system)
     end
 
+    ##
+    # Display or hide a DSP unit configuration dialog box inside the target
+    # window.
+    #
+    # @param hwnd [Pointer] Target HWND in windows to display configuration
+    #   dialog.
+    # @param show [Boolean] +true+ to display the window within the parent
+    #   window, otherwise +false+ to remove it.
+    #
+    # @return [void]
     def show_dialog(hwnd, show = true)
       FMOD.invoke(:DSP_ShowConfigDialog, self, hwnd, show.to_i)
     end
 
+    ##
+    # Retrieve information about a specified parameter within the DSP unit.
+    #
+    # @param index [Integer] Parameter index for this unit.
+    #
+    # @return [ParameterInfo, nil] the information about the specified parameter
+    #   or +nil+ if the index was out of range.
+    def param_info(index)
+      return nil unless FMOD.valid_range?(index, 0, parameter_count, false)
+      FMOD.invoke(:DSP_GetParameterInfo, self, index, info = int_ptr)
+      ParameterInfo.new(info.unpack1('J'))
+    end
+
+    ##
+    # Helper function to disconnect either all inputs or all outputs of a DSP
+    # unit.
+    #
+    # @param inputs [Boolean] +true+ to disconnect all inputs to this DSP unit,
+    #   otherwise +false+ to leave input connections alone.
+    # @param outputs [Boolean] +true+ to disconnect all outputs to this DSP
+    #   unit, otherwise +false+ to leave output connections alone.
+    #
+    # @return [void]
     def disconnect(inputs, outputs)
       FMOD.invoke(:DSP_DisconnectAll, self, inputs.to_i, outputs.to_i)
     end
 
+    ##
+    # Disconnect the DSP unit from the specified input.
+    #
+    # @param dsp [Dsp] The input unit that this unit is to be disconnected from.
+    # @param connection [DspConnection] If there is more than one connection
+    #   between 2 dDSP units, this can be used to define which of the
+    #   connections should be disconnected.
+    #
+    # @note If you have a handle to the connection pointer that binds these 2
+    #   DSP units, then it will become invalid. The connection is then sent back
+    #   to a freelist to be re-used again by a later addInput command.
+    #
+    # @return [void]
     def disconnect_from(dsp, connection = nil)
       FMOD.type?(dsp, Dsp) unless dsp.nil?
       FMOD.type?(connection, DspConnection) unless connection.nil?
       FMOD.invoke(:DSP_DisconnectFrom, self, dsp, connection)
     end
 
-    def output_format(*args)
-      if args.size == 3 && args.all? { |arg| arg.is_a?(Integer) }
-        mask, count, mode = args
-      elsif args.size == 1 && FMOD.type?(args[0], ChannelFormat)
-        mask, count, mode = args[0].values
-      else
-        mask, count, mode = channel_format.values
-      end
-      args = ["\0" * SIZEOF_INT, "\0" * SIZEOF_INT, "\0" * SIZEOF_INT]
-      FMOD.invoke(:DSP_GetOutputChannelFormat, mask, count, mode, *args)
-      args.map! { |arg| arg.unpack1('L') }
-      ChannelFormat.new(*args)
-    end
-
+    ##
+    # Retrieves a DSP unit which is acting as an input to this unit.
+    #
+    # @param index [Integer] Index of the input unit to retrieve.
+    #
+    # @return [Dsp] the input unit.
     def input(index)
       input = int_ptr
       FMOD.invoke(:DSP_GetInput, self, index, input, nil)
       Dsp.from_handle(input)
     end
 
+    ##
+    # Retrieves a DSP unit which is acting as an output to this unit.
+    #
+    # @param index [Integer] Index of the output unit to retrieve.
+    #
+    # @return [Dsp] the output unit.
     def output(index)
       output = int_ptr
       FMOD.invoke(:DSP_GetOutput, self, index, output, nil)
       Dsp.from_handle(output)
     end
 
+    ##
+    # Retrieves the connection which to a DSP acting as an input to this unit.
+    #
+    # @param index [Integer] Index of the input unit to retrieve the connection.
+    #
+    # @return [DspConnection] the input unit connection.
     def input_connection(index)
       connection = int_ptr
       FMOD.invoke(:DSP_GetInput, self, index, nil, connection)
       DspConnection.new(connection)
     end
 
+    ##
+    # Retrieves the connection which to a DSP acting as an output to this unit.
+    #
+    # @param index [Integer] Index of the output unit to retrieve the connection.
+    #
+    # @return [DspConnection] the output unit connection.
     def output_connection(index)
       connection = int_ptr
       FMOD.invoke(:DSP_GetOutput, self, index, nil, connection)
       DspConnection.new(connection)
     end
 
+    ##
+    # Adds the specified DSP unit as an input of the DSP object.
+    #
+    # @param dsp [Dsp] The DSP unit to add as an input of the current unit.
+    # @param type [Integer] The type of connection between the 2 units. The
+    #   following are valid values.
+    #   * {DspConnection::STANDARD}
+    #   * {DspConnection::SIDECHAIN}
+    #   * {DspConnection::SEND}
+    #   * {DspConnection::SEND_SIDECHAIN}
+    #
+    # @return [DspConnection] the connection between the 2 units.
     def add_input(dsp, type)
       FMOD.type?(dsp, Dsp)
       connection = int_ptr
@@ -335,33 +502,81 @@ module FMOD
       DspConnection.new(connection)
     end
 
+    ##
+    # Call the DSP process function to retrieve the output signal format for a
+    # DSP based on input values.
+    #
+    # A DSP unit may be an up mixer or down mixer for example. In this case if
+    # you specified 6 in for a down-mixer, it may provide you with 2 out for
+    # example.
+    #
+    # Generally the input values will be reproduced for the output values, but
+    # some DSP units will want to alter the output format.
+    #
+    # @overload output_format(format)
+    #   @param format [ChannelFormat] Structure describing the incoming channel
+    #     format.
+    # @overload output_format(mask, count, speaker_mode)
+    #   @param mask [Integer] Channel bit-mask representing the speakers enabled
+    #     for the incoming signal.
+    #   @param count [Integer] Number of channels for the incoming signal.
+    #   @param speaker_mode [Integer] Speaker mode for the incoming signal.
+    #
+    # @return [ChannelFormat] the output signal format.
+    def output_format(*args)
+      if args.size == 3 && args.all? { |arg| arg.is_a?(Integer) }
+        mask, count, mode = args
+      elsif args.size == 1 && FMOD.type?(args[0], ChannelFormat)
+        mask, count, mode = args[0].values
+      else
+        mask, count, mode = channel_format.values
+      end
+      args = ["\0" * SIZEOF_INT, "\0" * SIZEOF_INT, "\0" * SIZEOF_INT]
+      FMOD.invoke(:DSP_GetOutputChannelFormat, mask, count, mode, *args)
+      args.map! { |arg| arg.unpack1('L') }
+      ChannelFormat.new(*args)
+    end
+
+    ##
+    # @return [Boolean] a flag indicating if input metering for the DSP it is
+    #   enabled or not.
     def input_metering?
       enabled = "\0" * SIZEOF_INT
       FMOD.invoke(:DSP_GetMeteringEnabled, self, enabled, nil)
       enabled.unpack1('l') != 0
     end
 
+    ##
+    # @return [Boolean] a flag indicating if output metering for the DSP it is
+    #   enabled or not.
     def output_metering?
       enabled = "\0" * SIZEOF_INT
       FMOD.invoke(:DSP_GetMeteringEnabled, self, nil, enabled)
       enabled.unpack1('l') != 0
     end
 
+    ##
+    # Enable metering for a DSP unit.
+    #
+    # @param input [Boolean] Enable metering for the input signal
+    #   (pre-processing). Specify +true+ to turn on input level metering,
+    #   +false+ to turn it off.
+    # @param output [Boolean] Enable metering for the output signal
+    #   (post-processing). Specify +true+ to turn on output level metering,
+    #   +false+ to turn it off.
+    #
+    # @return [void]
     def enable_metering(input, output)
       FMOD.invoke(:DSP_SetMeteringEnabled, self, input ? 1 :0, output.to_i)
     end
 
-    def [](index)
-      return nil unless FMOD.valid_range?(index, 0, parameter_count, false)
-      case param_info(index).type
-      when ParameterType::FLOAT then get_float(index)
-      when ParameterType::INT then get_integer(index)
-      when ParameterType::BOOL then get_integer(index)
-      when ParameterType::DATA then get_data(index)
-      else raise RangeError, 'Unknown data type.'
-      end
-    end
-
+    ##
+    # Retrieves the unit's float parameter by index.
+    #
+    # @param index [Integer] Parameter index for this unit.
+    #
+    # @return [Float, nil] the parameter specified, or +nil+ if index is out
+    #   of range.
     def get_float(index)
       return nil unless FMOD.valid_range?(index, 0, parameter_count, false)
       buffer = "\0" * SIZEOF_FLOAT
@@ -369,6 +584,13 @@ module FMOD
       buffer.unpack1('f')
     end
 
+    ##
+    # Retrieves the unit's integer parameter by index.
+    #
+    # @param index [Integer] Parameter index for this unit.
+    #
+    # @return [Integer, nil] the parameter specified, or +nil+ if index is out
+    #   of range.
     def get_integer(index)
       return nil unless FMOD.valid_range?(index, 0, parameter_count, false)
       buffer = "\0" * SIZEOF_INT
@@ -376,6 +598,13 @@ module FMOD
       buffer.unpack1('l')
     end
 
+    ##
+    # Retrieves the unit's boolean parameter by index.
+    #
+    # @param index [Integer] Parameter index for this unit.
+    #
+    # @return [Boolean, nil] the parameter specified, or +nil+ if index is out
+    #   of range.
     def get_bool(index)
       return nil unless FMOD.valid_range?(index, 0, parameter_count, false)
       buffer = "\0" * SIZEOF_INT
@@ -383,6 +612,13 @@ module FMOD
       buffer.unpack1('l') != 0
     end
 
+    ##
+    # Retrieves the unit's data parameter by index.
+    #
+    # @param index [Integer] Parameter index for this unit.
+    #
+    # @return [Pointer, nil] the parameter specified, or +nil+ if index is out
+    #   of range.
     def get_data(index)
       return nil unless FMOD.valid_range?(index, 0, parameter_count, false)
       pointer = int_ptr
@@ -391,35 +627,52 @@ module FMOD
       Pointer.new(pointer.unpack('J'), size.unpack1('l'))
     end
 
-    def []=(index, value)
-      return unless FMOD.valid_range?(index, 0, parameter_count, false)
-      case value
-      when Float then set_float(index, value)
-      when Integer then set_integer(index, value)
-      when TrueClass, FalseClass, NilClass then set_bool(index, value)
-      when String, Pointer then set_data(index, value)
-      else raise TypeError, "#{value} is not a valid DSP parameter type."
-      end
-    end
-
+    ##
+    # Sets the unit's float parameter by index.
+    #
+    # @param index [Integer] Parameter index for this unit.
+    # @param value [Float] The value to set.
+    #
+    # @return [self]
     def set_float(index, value)
       return unless FMOD.valid_range?(index, 0, parameter_count, false)
       FMOD.invoke(:DSP_SetParameterFloat, self, index, value)
       self
     end
 
+    ##
+    # Sets the unit's integer parameter by index.
+    #
+    # @param index [Integer] Parameter index for this unit.
+    # @param value [Integer] The value to set.
+    #
+    # @return [self]
     def set_integer(index, value)
       return unless FMOD.valid_range?(index, 0, parameter_count, false)
       FMOD.invoke(:DSP_SetParameterInt, self, index, value)
       self
     end
 
+    ##
+    # Sets the unit's boolean parameter by index.
+    #
+    # @param index [Integer] Parameter index for this unit.
+    # @param value [Boolean] The value to set.
+    #
+    # @return [self]
     def set_bool(index, value)
       return unless FMOD.valid_range?(index, 0, parameter_count, false)
       FMOD.invoke(:DSP_SetParameterBool, self, index, value.to_i)
       self
     end
 
+    ##
+    # Sets the unit's data parameter by index.
+    #
+    # @param index [Integer] Parameter index for this unit.
+    # @param value [Pointer, String] The value to set.
+    #
+    # @return [self]
     def set_data(index, value)
       return unless FMOD.valid_range?(index, 0, parameter_count, false)
       unless FMOD.type?(value, String, false)
@@ -430,11 +683,73 @@ module FMOD
       self
     end
 
+    ##
+    # Get parameter by index.
+    #
+    # @param index [Integer] Parameter index for this unit.
+    #
+    # @return [Object] the value of the parameter at the specified index.
+    def [](index)
+      return nil unless FMOD.valid_range?(index, 0, parameter_count, false)
+      case param_info(index).type
+      when ParameterType::FLOAT then get_float(index)
+      when ParameterType::INT then get_integer(index)
+      when ParameterType::BOOL then get_integer(index)
+      when ParameterType::DATA then get_data(index)
+      else raise RangeError, 'Unknown data type.'
+      end
+    end
 
-    class << self
+    ##
+    # Sets parameter by index.
+    #
+    # @param index [Integer] Parameter index for this unit.
+    # @param value [Float, Integer, Boolean, Pointer, String] The value to set.
+    #
+    # @note The value must be of the correct type for the specified parameter,
+    #   no implicit conversions will be performed, i.e. passing an integer to a
+    #   float parameter will fail, as it is not the correct type. It is up to
+    #   the user to perform any conversions ahead before passing to this method.
+    #
+    # @return [Object] the value of the parameter at the specified index.
+    def []=(index, value)
+      return unless FMOD.valid_range?(index, 0, parameter_count, false)
+      case value
+      when Float then set_float(index, value)
+      when Integer then set_integer(index, value)
+      when TrueClass, FalseClass, NilClass then set_bool(index, value)
+      when String, Pointer then set_data(index, value)
+      else raise TypeError, "#{value} is not a valid DSP parameter type."
+      end
+    end
 
-      private
+    ##
+    # @return [String] the string representation of the DSP unit.
+    def to_s
+      "#{name} v.#{version}"
+    end
+
+    class << self
 
+      ##
+      # Dynamically creates a method for getting and/or setting a named float
+      # parameter of a DSP unit.
+      #
+      # @param index [Integer] The parameter index.
+      # @param name [Symbol] The name of the attribute to define.
+      # @param options [Hash] The options hash.
+      #
+      # @option options [Boolean] :readonly (false) Flag indicating if a setter
+      #   function will be defined or not.
+      # @option options [Boolean] :write_only (false) Flag indicating if a
+      #   getter will be defined or not.
+      # @option options [Float] :min (nil) If defined will clamp any given value
+      #   to the specified minimum value.
+      # @option options [Float] :max (nil) If defined will clamp any given value
+      #   to the specified maximum value.
+      #
+      # @return [void]
+      # @api private
       def float_param(index, name, **options)
         define_method(name) { get_float(index) } unless options[:write_only]
         unless options[:readonly]
@@ -446,6 +761,25 @@ module FMOD
         end
       end
 
+      ##
+      # Dynamically creates a method for getting and/or setting a named integer
+      # parameter of a DSP unit.
+      #
+      # @param index [Integer] The parameter index.
+      # @param name [Symbol] The name of the attribute to define.
+      # @param options [Hash] The options hash.
+      #
+      # @option options [Boolean] :readonly (false) Flag indicating if a setter
+      #   function will be defined or not.
+      # @option options [Boolean] :write_only (false) Flag indicating if a
+      #   getter will be defined or not.
+      # @option options [Integer] :min (nil) If defined will clamp any given
+      #   value to the specified minimum value.
+      # @option options [Integer] :max (nil) If defined will clamp any given
+      #   value to the specified maximum value.
+      #
+      # @return [void]
+      # @api private
       def integer_param(index, name, **options)
         define_method(name) { get_integer(index) } unless options[:write_only]
         unless options[:readonly]
@@ -457,6 +791,21 @@ module FMOD
         end
       end
 
+      ##
+      # Dynamically creates a method for getting and/or setting a named boolean
+      # parameter of a DSP unit.
+      #
+      # @param index [Integer] The parameter index.
+      # @param name [Symbol] The name of the attribute to define.
+      # @param options [Hash] The options hash.
+      #
+      # @option options [Boolean] :readonly (false) Flag indicating if a setter
+      #   function will be defined or not.
+      # @option options [Boolean] :write_only (false) Flag indicating if a
+      #   getter will be defined or not.
+      #
+      # @return [void]
+      # @api private
       def bool_param(index, name, **options)
         define_method(name) { get_bool(index) } unless options[:write_only]
         unless options[:readonly]
@@ -464,6 +813,21 @@ module FMOD
         end
       end
 
+      ##
+      # Dynamically creates a method for getting and/or setting a named data
+      # parameter of a DSP unit.
+      #
+      # @param index [Integer] The parameter index.
+      # @param name [Symbol] The name of the attribute to define.
+      # @param options [Hash] The options hash.
+      #
+      # @option options [Boolean] :readonly (false) Flag indicating if a setter
+      #   function will be defined or not.
+      # @option options [Boolean] :write_only (false) Flag indicating if a
+      #   getter will be defined or not.
+      #
+      # @return [void]
+      # @api private
       def data_param(index, name, **options)
         define_method(name) { get_data(index) } unless options[:write_only]
         unless options[:readonly]
@@ -471,40 +835,5 @@ module FMOD
         end
       end
     end
-    # def self.float_param(index, name, **options)
-    #   define_method(name) { get_float(index) } unless options[:write_only]
-    #   unless options[:readonly]
-    #     define_method("#{name}=") do |value|
-    #       value = options[:min] if options[:min] && value < options[:min]
-    #       value = options[:max] if options[:max] && value > options[:max]
-    #       set_float(index, value)
-    #     end
-    #   end
-    # end
-    #
-    # def self.integer_param(index, name, **options)
-    #   define_method(name) { get_integer(index) } unless options[:write_only]
-    #   unless options[:readonly]
-    #     define_method("#{name}=") do |value|
-    #       value = options[:min] if options[:min] && value < options[:min]
-    #       value = options[:max] if options[:max] && value > options[:max]
-    #       set_float(index, value)
-    #     end
-    #   end
-    # end
-    #
-    # def self.bool_param(index, name, **options)
-    #   define_method(name) { get_bool(index) } unless options[:write_only]
-    #   unless options[:readonly]
-    #     define_method("#{name}=") { |value| set_bool(index, value) }
-    #   end
-    # end
-    #
-    # def self.data_param(index, name, **options)
-    #   define_method(name) { get_data(index) } unless options[:write_only]
-    #   unless options[:readonly]
-    #     define_method("#{name}=") { |value| set_data(index, value) }
-    #   end
-    # end
   end
 end