fmod 0.9.0

data/lib/fmod/effects/sfx_reverb.rb

@@ -0,0 +1,87 @@
+
+module FMOD
+  module Effects
+
+    ##
+    # This unit implements SFX reverb.
+    #
+    # This is a high quality I3DL2 based reverb.
+    #
+    # On top of the I3DL2 property set, "Dry Level" is also included to allow
+    # the dry mix to be changed.
+    #
+    # @attr decay_time [Float] Reverberation decay time at low-frequencies in
+    #   milliseconds.
+    #   * *Minimum:* 100.0
+    #   * *Maximum:* 20000.0
+    #   * *Default:* 1500
+    # @attr early_delay [Float] Delay time of first reflection in milliseconds.
+    #   * *Minimum:* 0.0
+    #   * *Maximum:* 300.0
+    #   * *Default:* 20.0
+    # @attr late_delay [Float] Late reverberation delay time relative to first
+    #   reflection in milliseconds.
+    #   * *Minimum:* 0.0
+    #   * *Maximum:* 100.0
+    #   * *Default:* 40.0
+    # @attr hf_reference [Float] Reference frequency for high-frequency decay in
+    #   Hz.
+    #   * *Minimum:* 20.0
+    #   * *Maximum:* 20000.0
+    #   * *Default:* 5000.0
+    # @attr hf_decay_ratio [Float] High-frequency decay time relative to decay
+    #   time in percent.
+    #   * *Minimum:* 10.0
+    #   * *Maximum:* 100.0
+    #   * *Default:* 50.0
+    # @attr diffusion [Float] Reverberation diffusion (echo density) in percent.
+    #   * *Minimum:* 0.0
+    #   * *Maximum:* 100.0
+    #   * *Default:* 100.0
+    # @attr density [Float] Reverberation density (modal density) in percent.
+    #   * *Minimum:* 0.0
+    #   * *Maximum:* 100.0
+    #   * *Default:* 100.0
+    # @attr low_shelf_frequency [Float] Transition frequency of low-shelf filter
+    #   in Hz.
+    #   * *Minimum:* 20.0
+    #   * *Maximum:* 1000.0
+    #   * *Default:* 250.0
+    # @attr low_shelf_gain [Float] Gain of low-shelf filter in dB.
+    #   * *Minimum:* -36.0
+    #   * *Maximum:* 12.0
+    #   * *Default:* 0.0
+    # @attr high_cut [Float] Cutoff frequency of low-pass filter in Hz.
+    #   * *Minimum:* 20.0
+    #   * *Maximum:* 20000.0
+    #   * *Default:* 20000.0
+    # @attr early_late_mix [Float] Blend ratio of late reverb to early
+    #   reflections in percent.
+    #   * *Minimum:* 0.0
+    #   * *Maximum:* 100.0
+    #   * *Default:* 50.0
+    # @attr wet_level [Float] Reverb signal level in dB.
+    #   * *Minimum:* -80.0
+    #   * *Maximum:* 20.0
+    #   * *Default:* -6.0
+    # @attr dry_level [Float] Dry signal level in dB.
+    #   * *Minimum:* -80.0
+    #   * *Maximum:* 20.0
+    #   * *Default:* 0.0
+    class SfxReverb < Dsp
+      float_param(0, :decay_time, min: 100.0, max: 20000.0)
+      float_param(0, :early_delay, min: 0.0, max: 300.0)
+      float_param(0, :late_delay, min: 0.0, max: 100.0)
+      float_param(0, :hf_reference, min: 20.0, max: 20000.0)
+      float_param(0, :hf_decay_ratio, min: 10.0, max: 100.0)
+      float_param(0, :diffusion, min: 0.0, max: 100.0)
+      float_param(0, :density, min: 0.0, max: 100.0)
+      float_param(0, :low_shelf_frequency, min: 20.0, max: 1000.0)
+      float_param(0, :low_shelf_gain, min: -36.0, max: 12.0)
+      float_param(0, :high_cut, min: 20.0, max: 20000.0)
+      float_param(0, :early_late_mix, min: 0.0, max: 100.0)
+      float_param(0, :wet_level, min: -80.0, max: 20.0)
+      float_param(0, :dry_level, min: -80.0, max: 20.0)
+    end
+  end
+end

data/lib/fmod/effects/three_eq.rb

@@ -0,0 +1,41 @@
+module FMOD
+  module Effects
+
+    ##
+    # This unit is a three-band equalizer.
+    #
+    # @attr low_gain [Float] Low frequency gain in dB. .
+    #   * *Minimum:* -80.0
+    #   * *Maximum:* 10.0
+    #   * *Default:* 0.0
+    # @attr mid_gain [Float] Mid frequency gain in dB.
+    #   * *Minimum:* -80.0
+    #   * *Maximum:* 10.0
+    #   * *Default:* 0.0
+    # @attr high_gain [Float] High frequency gain in dB.
+    #   * *Minimum:* -80.0
+    #   * *Maximum:* 10.0
+    #   * *Default:* 0.0
+    # @attr low_crossover [Float] Low-to-mid crossover frequency in Hz.
+    #   * *Minimum:* 10.0
+    #   * *Maximum:* 22000.0
+    #   * *Default:* 4000.0
+    # @attr high_crossover [Float] Mid-to-high crossover frequency in Hz.
+    #   * *Minimum:* 10.0
+    #   * *Maximum:* 22000.0
+    #   * *Default:* 4000.0
+    # @attr crossover_slope [Integer] Crossover slope.
+    #   * *0:* 12dB/Octave
+    #   * *1:* 24dB/Octave
+    #   * *2:* 48dB/Octave
+    #   * *Default:* 1 (24dB/Octave)
+    class ThreeEq < Dsp
+      float_param(0, :low_gain, min: -80.0, max: 10.0)
+      float_param(1, :mid_gain, min: -80.0, max: 10.0)
+      float_param(2, :high_gain, min: -80.0, max: 10.0)
+      float_param(3, :low_crossover, min: 10.0, max: 22000.0)
+      float_param(4, :high_crossover, min: 10.0, max: 22000.0)
+      integer_param(5, :crossover_slope, min: 0, max: 2)
+    end
+  end
+end

data/lib/fmod/effects/transceiver.rb

@@ -0,0 +1,57 @@
+
+module FMOD
+  module Effects
+
+    ##
+    # This unit "sends" and "receives" from a selection of up to 32 different
+    # slots. It is like a send/return but it uses global slots rather than
+    # returns as the destination. It also has other features. Multiple
+    # transceivers can receive from a single channel, or multiple transceivers
+    # can send to a single channel, or a combination of both.
+    #
+    # The transceiver only transmits and receives to a global array of 32
+    # channels. The transceiver can be set to receiver mode (like a {Return})
+    # and can receive the signal at a variable {#gain}. The transceiver can also
+    # be set to transmit to a channel (like a {Send}) and can transmit the
+    # signal with a variable {#gain}.
+    #
+    # The {#speaker_mode} is only applicable to the transmission format, not the
+    # receive format. This means this parameter is ignored in "receive mode".
+    # This allows receivers to receive at the speaker mode of the user's choice.
+    # Receiving from a mono channel, is cheaper than receiving from a surround
+    # channel for example. The 3 speaker modes {SpeakerMode::MONO},
+    # {SpeakerMode::STEREO}, {SpeakerMode::SURROUND} are stored as separate
+    # buffers in memory for a transmitter channel. To save memory, use 1 common
+    # speaker mode for a transmitter.
+    #
+    # The transceiver is double buffered to avoid de-syncing of transmitters and
+    # receivers. This means there will be a 1 block delay on a receiver,
+    # compared to the data sent from a transmitter.
+    #
+    # Multiple transmitters sending to the same channel will be mixed together.
+    #
+    # @attr transmit [Boolean] The behavior of the unit.
+    #   * *false:* Transceiver is a "receiver" (like a {Return}) and accepts
+    #     data from a channel.
+    #   * *true:* Transceiver is a "transmitter" (like a {Send}).
+    #   * *Default:* +false+
+    # @attr gain [Float] Gain to receive or transmit at in dB.
+    #   * *Minimum:* -80.0
+    #   * *Maximum:* 10.0
+    #   * *Default:* 0.0
+    # @attr channel [Integer] Integer to select current global slot, shared by
+    #   all Transceivers, that can be transmitted to or received from.
+    #   * *Minimum:* 0
+    #   * *Maximum:* 31
+    #   * *Default:* 0
+    # @attr speaker_mode [Integer] Speaker mode (transmitter mode only).
+    #   * *Default:* {SpeakerMode::DEFAULT}
+    #   @see SpeakerMode
+    class Transceiver < Dsp
+      bool_param(0, :transmit)
+      float_param(1, :gain, min: -80.0, max: 10.0)
+      integer_param(2, :channel, min: 0, max: 31)
+      integer_param(3, :speaker_mode, min: 0, max: 9)
+    end
+  end
+end

data/lib/fmod/effects/tremolo.rb

@@ -0,0 +1,67 @@
+
+module FMOD
+  module Effects
+
+    ##
+    # This unit produces a tremolo / chopper effect on the sound.
+    #
+    # The tremolo effect varies the amplitude of a sound. Depending on the
+    # settings, this unit can produce a tremolo, chopper or auto-pan effect.
+    #
+    # The shape of the LFO (low freq. oscillator) can morphed between sine,
+    # triangle and sawtooth waves using the {#shape} and {#skew} parameters.
+    #
+    # {#duty} and {#square} are useful for a chopper-type effect where the first
+    # controls the on-time duration and second controls the flatness of the
+    # envelope.
+    #
+    # {#spread} varies the LFO phase between channels to get an auto-pan effect.
+    # This works best with a sine shape LFO.
+    #
+    # The LFO can be synchronized using the {#phase} parameter which sets its
+    # instantaneous phase.
+    #
+    # @attr frequency [Float] LFO frequency in Hz.
+    #   * *Minimum:* 0.1
+    #   * *Maximum:* 20.0
+    #   * *Default:* 5.0
+    # @attr depth [Float] Tremolo depth.
+    #   * *Minimum:* 0.0
+    #   * *Maximum:* 1.0
+    #   * *Default:* 1.0
+    # @attr shape [Float] LFO shape morph between triangle and sine.
+    #   * *Minimum:* 0.0
+    #   * *Maximum:* 1.0
+    #   * *Default:* 0.0
+    # @attr skew [Float] Time-skewing of LFO cycle.
+    #   * *Minimum:* -1.0
+    #   * *Maximum:* 1.0
+    #   * *Default:* 0.0
+    # @attr duty [Float] LFO on-time. 0 to 1.
+    #   * *Minimum:* 0.0
+    #   * *Maximum:* 1.0
+    #   * *Default:* 0.5
+    # @attr square [Float] Flatness of the LFO shape.
+    #   * *Minimum:* 0.0
+    #   * *Maximum:* 1.0
+    #   * *Default:* 0.0
+    # @attr phase [Float] Instantaneous LFO phase.
+    #   * *Minimum:* 0.0
+    #   * *Maximum:* 1.0
+    #   * *Default:* 0.0
+    # @attr spread [Float] Rotation / auto-pan effect.
+    #   * *Minimum:* -1.0
+    #   * *Maximum:* 1.0
+    #   * *Default:* 0.0
+    class Tremolo < Dsp
+      float_param(0, :frequency, min: 0.1, max: 20.0)
+      float_param(1, :depth, min: 0.0, max: 1.0)
+      float_param(2, :shape, min: 0.0, max: 1.0)
+      float_param(3, :skew, min: -1.0, max: 1.0)
+      float_param(4, :duty, min: 0.0, max: 1.0)
+      float_param(5, :square, min: 0.0, max: 1.0)
+      float_param(6, :phase, min: 0.0, max: 1.0)
+      float_param(7, :spread, min: -1.0, max: 1.0)
+    end
+  end
+end

data/lib/fmod/effects/vst_plugin.rb

@@ -0,0 +1,12 @@
+
+module FMOD
+  module Effects
+
+    ##
+    # This unit allows the use of Steinberg VST plugins.
+    #
+    # @note Must sub-class to provide functionality.
+    class VstPlugin < Dsp
+    end
+  end
+end

data/lib/fmod/effects/winamp_plugin.rb

@@ -0,0 +1,12 @@
+
+module FMOD
+  module Effects
+
+    ##
+    # This unit allows the use of Nullsoft Winamp plugins
+    #
+    # @note Must sub-class to provide functionality.
+    class WinampPlugin < Dsp
+    end
+  end
+end

data/lib/fmod/error.rb

@@ -0,0 +1,108 @@
+module FMOD
+  class Error < StandardError
+
+    include FMOD::Core
+
+    ##
+    # @overload initialize(code)
+    #   @param code [Integer]
+    # @overload initialize(message)
+    #   @param message [String]
+    def initialize(code)
+      message = code.is_a?(Integer) ? self.class.error_string(code) : code
+      super(message)
+    end
+
+    ##
+    # Retrieves a generic message for the specified result code.
+    # @param code [Integer] An FMOD generated error code.
+    # @return [String] A generic error message.
+    # @see Result
+    def self.error_string(code)
+      case code
+      when Result::BAD_COMMAND then "Tried to call a function on a data type that does not allow this type of functionality (ie calling Sound::lock on a streaming sound)."
+      when Result::CHANNEL_ALLOC then "Error trying to allocate a channel."
+      when Result::CHANNEL_STOLEN then "The specified channel has been reused to play another sound."
+      when Result::DMA then "DMA Failure. See debug output for more information."
+      when Result::DSP_CONNECTION then "DSP connection error. Connection possibly caused a cyclic dependency or connected dsps with incompatible buffer counts."
+      when Result::DSP_DONT_PROCESS then "DSP return code from a DSP process query callback. Tells mixer not to call the process callback and therefore not consume CPU. Use this to optimize the DSP graph. "
+      when Result::DSP_FORMAT then "DSP Format error. A DSP unit may have attempted to connect to this network with the wrong format, or a matrix may have been set with the wrong size if the target unit has a specified channel map."
+      when Result::DSP_IN_USE then "DSP is already in the mixer's DSP network. It must be removed before being reinserted or released."
+      when Result::DSP_NOT_FOUND then "DSP connection error. Couldn't find the DSP unit specified."
+      when Result::DSP_RESERVED then "DSP operation error. Cannot perform operation on this DSP as it is reserved by the system."
+      when Result::DSP_SILENCE then "DSP return code from a DSP process query callback. Tells mixer silence would be produced from read, so go idle and not consume CPU. Use this to optimize the DSP graph."
+      when Result::DSP_TYPE then "DSP operation cannot be performed on a DSP of this type. "
+      when Result::FILE_BAD then "Error loading file."
+      when Result::FILE_COULD__SEEK then "Couldn't perform seek operation. This is a limitation of the medium (ie netstreams) or the file format."
+      when Result::FILE_DISK_EJECTED then "Media was ejected while reading."
+      when Result::FILE_EOF then "End of file unexpectedly reached while trying to read essential data (truncated?)."
+      when Result::FILE_END_OF_DATA then "End of current chunk reached while trying to read data. "
+      when Result::FILE_NOT_FOUND then "File not found."
+      when Result::FORMAT then "Unsupported file or audio format."
+      when Result::HEADER_MISMATCH then "There is a version mismatch between the FMOD header and either the FMOD Studio library or the FMOD Low Level library."
+      when Result::HTTP then " HTTP error occurred. This is a catch-all for HTTP errors not listed elsewhere."
+      when Result::HTTP_ACCESS then "The specified resource requires authentication or is forbidden."
+      when Result::HTTP_PROXY_AUTH then "Proxy authentication is required to access the specified resource. "
+      when Result::HTTP_SERVER_ERROR then "A HTTP server error occurred."
+      when Result::HTTP_TIMEOUT then "The HTTP request timed out. "
+      when Result::INITIALIZATION then "FMOD was not initialized correctly to support this function. "
+      when Result::INITIALIZED then "Cannot call this command after System::new."
+      when Result::INTERNAL then "An error occurred that wasn't supposed to. Contact support."
+      when Result::INVALID_FLOAT then "Value passed in was a NaN, Inf or denormalized float."
+      when Result::INVALID_HANDLE then "An invalid object handle was used."
+      when Result::INVALID_PARAM then "An invalid parameter was passed to this function."
+      when Result::INVALID_POSITION then "An invalid seek position was passed to this function."
+      when Result::INVALID_SPEAKER then "An invalid speaker was passed to this function based on the current speaker mode. "
+      when Result::INVALID_SYNC_POINT then "The syncpoint did not come from this sound handle."
+      when Result::INVALID_THREAD then "Tried to call a function on a thread that is not supported."
+      when Result::INVALID_VECTOR then "The vectors passed in are not unit length, or perpendicular."
+      when Result::MAX_AUDIBLE then "Reached maximum audible playback count for this sound's soundgroup."
+      when Result::MEMORY then "Not enough memory or resources."
+      when Result::MEMORY_CANT_POINT then "Can't use OPEN_MEMORY_POINT on non-PCM source data, or non mp3/xma/adpcm data if CREATE_COMPRESSED_SAMPLE was used."
+      when Result::NEEDS_3D then "Tried to call a command on a 2d sound when the command was meant for 3d sound."
+      when Result::NEEDS_HARDWARE then "Tried to use a feature that requires hardware support."
+      when Result::NET_CONNECT then "Couldn't connect to the specified host."
+      when Result::NET_SOCKET_ERROR then "A socket error occurred. This is a catch-all for socket-related errors not listed elsewhere."
+      when Result::NET_URL then "The specified URL couldn't be resolved."
+      when Result::NET_WOULD_BLOCK then "Operation on a non-blocking socket could not complete immediately. "
+      when Result::NOT_READY then "Operation could not be performed because specified sound/DSP connection is not ready."
+      when Result::OUTPUT_ALLOCATED then "Error initializing output device, but more specifically, the output device is already in use and cannot be reused."
+      when Result::OUTPUT_CREATE_BUFFER then "Error creating hardware sound buffer."
+      when Result::OUTPUT_DRIVER_CALL then "A call to a standard soundcard driver failed, which could possibly mean a bug in the driver or resources were missing or exhausted."
+      when Result::OUTPUT_FORMAT then "Soundcard does not support the specified format."
+      when Result::OUTPUT_INIT then "Error initializing output device."
+      when Result::OUTPUT_NO_DRIVERS then "The output device has no drivers installed. If pre-init, OUTPUT_NO_SOUND is selected as the output mode. If post-init, the function just fails."
+      when Result::PLUGIN then "An unspecified error has been returned from a plugin."
+      when Result::PLUGIN_MISSING then "A requested output, dsp unit type or codec was not available."
+      when Result::PLUGIN_RESOURCE then "A resource that the plugin requires cannot be found. (ie the DLS file for MIDI playback)"
+      when Result::PLUGIN_VERSION then "A plugin was built with an unsupported SDK version."
+      when Result::RECORD then "An error occurred trying to initialize the recording device."
+      when Result::REVERB_CHANNEL_GROUP then "Reverb properties cannot be set on this channel because a parent channelgroup owns the reverb connection."
+      when Result::REVERB_INSTANCE then "Specified instance in ReverbProperties couldn't be set. Most likely because it is an invalid instance number or the reverb doesn't exist"
+      when Result::SUBSOUNDS then "The error occurred because the sound referenced contains subsounds when it shouldn't have, or it doesn't contain subsounds when it should have. The operation may also not be able to be performed on a parent sound."
+      when Result::SUBSOUND_ALLOCATED then "This subsound is already being used by another sound, you cannot have more than one parent to a sound. Null out the other parent's entry first."
+      when Result::SUBSOUND_CANT_MOVE then "Shared subsounds cannot be replaced or moved from their parent stream, such as when the parent stream is an FSB file."
+      when Result::TAG_NOT_FOUND then "The specified tag could not be found or there are no tags."
+      when Result::TOO_MANY_CHANNELS then "The sound created exceeds the allowable input channel count. This can be increased using the 'maxinputchannels' parameter in System::setSoftwareFormat."
+      when Result::TRUNCATED then "The retrieved string is too long to fit in the supplied buffer and has been truncated."
+      when Result::UNIMPLEMENTED then "Something in FMOD hasn't been implemented when it should be! contact support!"
+      when Result::UNINITIALIZED then "This command failed because System::new or System::set_driver was not called."
+      when Result::UNSUPPORTED then "A command issued was not supported by this object. Possibly a plugin without certain callbacks specified"
+      when Result::VERSION then "The version number of this file format is not supported."
+      when Result::EVENT_ALREADY_LOADED then "The specified bank has already been loaded."
+      when Result::EVENT_LIVE_UPDATE_BUSY then "The live update connection failed due to the game already being connected."
+      when Result::EVENT_LIVE_UPDATE_MISMATCH then "The live update connection failed due to the game data being out of sync with the tool."
+      when Result::EVENT_LIVE_UPDATE_TIMEOUT then "The live update connection timed out."
+      when Result::EVENT_NOT_FOUND then "The requested event, bus or vca could not be found."
+      when Result::STUDIO_UNINITIALIZED then "The Studio::System object is not yet initialized."
+      when Result::STUDIO_NOT_LOADED then "The specified resource is not loaded, so it can't be unloaded."
+      when Result::INVALID_STRING then "An invalid string was passed to this function."
+      when Result::ALREADY_LOCKED then "The specified resource is already locked."
+      when Result::NOT_LOCKED then "The specified resource is not locked, so it can't be unlocked."
+      when Result::RECORD_DISCONNECTED then "The specified recording driver has been disconnected."
+      when Result::TOO_MANY_SAMPLES then "The length provided exceeds the allowable limit."
+      else "Unknown error. Code: #{code}"
+      end
+    end
+  end
+end

data/lib/fmod/geometry.rb

@@ -0,0 +1,380 @@
+
+module FMOD
+  class Geometry < Handle
+
+    include Enumerable
+
+    ##
+    # @!attribute active
+    # Value indicating if object will be processed in the geometry engine.
+    #
+    # @return [Boolean]
+    bool_reader(:active, :Geometry_GetActive)
+    bool_writer(:active=, :Geometry_SetActive)
+
+    ##
+    # @!attribute polygon_count
+    # Retrieves the number of polygons stored within this {Geometry} object.
+    #
+    # @return [Integer]
+    integer_reader(:polygon_count, :Geometry_GetNumPolygons)
+
+    alias size polygon_count
+
+    ##
+    # @!attribute position
+    # The position of the object in world space, which is the same space FMOD
+    # sounds and listeners reside in.
+    #
+    # @return [Vector]
+
+    def position
+      FMOD.invoke(:Geometry_GetPosition, self, vector = Vector.zero)
+      vector
+    end
+
+    def position=(vector)
+      FMOD.type?(vector, Vector)
+      FMOD.invoke(:Geometry_SetPosition, self, vector)
+    end
+
+    ##
+    # @!attribute scale
+    # The relative scale vector of the geometry object. An object can be
+    # scaled/warped in all 3 dimensions separately using the vector without
+    # having to modify polygon data.
+    # * *Default:* {Vector.one}
+    #
+    # @return [Vector]
+
+    def scale
+      FMOD.invoke(:Geometry_GetScale, self, vector = Vector.zero)
+      vector
+    end
+
+    def scale=(vector)
+      FMOD.type?(vector, Vector)
+      FMOD.invoke(:Geometry_SetScale, self, vector)
+    end
+
+    ##
+    # @!attribute rotation
+    # The current orientation of the geometry object.
+    #
+    # @return [Rotation]
+    # @see rotate
+
+    def rotation
+      forward, up = Vector.zero, Vector.zero
+      FMOD.invoke(:Geometry_GetRotation, self, forward, up)
+      Rotation.new(forward, up)
+    end
+
+    def rotation=(rotation)
+      FMOD.type?(rotation, Rotation)
+      rotate(*rotation.values)
+    end
+
+    ##
+    # Sets the orientation of the geometry object.
+    # @param forward [Vector] The forwards orientation of the geometry object.
+    #   This vector must be of unit length and perpendicular to the upward
+    #   vector. You can specify +nil+ to not update the forwards orientation of
+    #   the geometry object.
+    # @param upward [Vector] The upwards orientation of the geometry object.
+    #   This vector must be of unit length and perpendicular to the forward
+    #   vector. You can specify +nil+ to not update the upwards orientation of
+    #   the geometry object.
+    def rotate(forward, upward)
+      FMOD.type?(forward, Vector) unless forward.nil?
+      FMOD.type?(upward, Vector) unless upward.nil?
+      FMOD.invoke(:Geometry_SetRotation, self, forward, upward)
+    end
+
+    ##
+    # Retrieves the maximum number of polygons allocatable for this object.
+    #
+    # This is not the number of polygons currently present.
+    #
+    # @return [Integer]
+    def max_polygons
+      max = "\0" * SIZEOF_INT
+      FMOD.invoke(:Geometry_GetMaxPolygons, self, max, nil)
+      max.unpack1('l')
+    end
+
+    # Retrieves the maximum number of vertices allocatable for this object.
+    #
+    # This is not the number of vertices currently present.
+    #
+    # @return [Integer]
+    def max_vertices
+      max = "\0" * SIZEOF_INT
+      FMOD.invoke(:Geometry_GetMaxPolygons, self, nil, max)
+      max.unpack1('l')
+    end
+
+    ##
+    # Retrieves the {Polygon} at the specified index.
+    # @param index [Integer] The index of the Polygon to retrieve.
+    # @return [Polygon]
+    def [](index)
+      return nil unless index.between?(0, polygon_count)
+      Polygon.send(:new, self, index)
+    end
+
+    ##
+    # Adds a polygon to an geometry object.
+    #
+    # @note A minimum of 3 vertices is required to create a {Polygon}.
+    #
+    # @param vertices [Array<Vector>] array of vertices located in object space.
+    # @param direct [Float] Occlusion value which affects volume or audible
+    #   frequencies.
+    #   * *Minimum:* 0.0 The polygon does not occlude volume or audible
+    #     frequencies (sound will be fully audible)
+    #   * *Maximum:* 1.0 The polygon fully occludes (sound will be silent)
+    # @param reverb [Float] Occlusion value from 0.0 to 1.0 which affects the
+    #   reverb mix.
+    #   * *Minimum:* 0.0 The polygon does not occlude reverb (reverb reflections
+    #     still travel through this polygon)
+    #   * *Maximum:* 1.0 The polygon fully occludes reverb (reverb reflections
+    #     will be silent through this polygon).
+    # @param double_sided [Boolean] Description of polygon if it is double sided
+    #   or single sided.
+    #   * *true:* Polygon is double sided
+    #   * *false:* Polygon is single sided, and the winding of the polygon
+    #     (which determines the polygon's normal) determines which side of the
+    #     polygon will cause occlusion.
+    def add_polygon(vertices, direct = 0.0, reverb = 0.0, double_sided = false)
+      size = vertices.size
+      unless size >= 3
+        message = "3 or more vertices required for polygon: #{size} specified"
+        raise ArgumentError, message
+      end
+      vectors = vertices.map(&:to_str).join
+      direct = direct.clamp(0.0, 1.0)
+      reverb = reverb.clamp(0.0, 1.0)
+      FMOD.invoke(:Geometry_AddPolygon, self, direct, reverb,
+                  double_sided.to_i, size, vectors, index = "\0" * SIZEOF_INT)
+      Polygon.send(:new, self, index.unpack1('l'))
+    end
+
+    ##
+    # Serializes the {Geometry} object into a binary block.
+    #
+    # @overload save(filename)
+    #   @param filename [String] A filename where object will be saved to.
+    #   @return [Boolean] +true+ if object was successfully flushed to disk,
+    #     otherwise +false+.
+    # @overload save
+    #   Serializes the {Geometry} object and returns the data as a binary
+    #   string.
+    #   @return [String]
+    # @see System.load_geometry
+    def save(filename = nil)
+      FMOD.invoke(:Geometry_Save, self, nil, size = "\0" * SIZEOF_INT)
+      data = "\0" * size.unpack1('l')
+      FMOD.invoke(:Geometry_Save, self, data, size)
+      unless filename.nil?
+        File.open(filename, 'wb') { |file| file.write(data) } rescue return false
+        return true
+      end
+      data
+    end
+
+    ##
+    # Enumerates the polygons contained within the {Geometry}.
+    #
+    # @overload each
+    #   When called with block, yields each {Polygon} within the object before
+    #   returning self.
+    #   @yield [polygon] Yields a polygon to the block.
+    #   @yieldparam polygon [Polygon] The current enumerated polygon.
+    #   @return [self]
+    # @overload each
+    #   When no block specified, returns an Enumerator for the {Geometry}.
+    #   @return [Enumerator]
+    def each
+      return to_enum(:each) unless block_given?
+      (0...polygon_count).each { |i| yield self[i] }
+      self
+    end
+
+    ##
+    # Retrieves an array of {Polygon} objects within this {Geometry}.
+    # @return [Array<Polygon>]
+    def polygons
+      (0...polygon_count).map { |i| self[i] }
+    end
+
+    ##
+    # Describes the orientation of a geometry object.
+    # @attr forward [Vector] The forwards orientation of the geometry object.
+    #   This vector must be of unit length and perpendicular to the {#up}
+    #   vector. You can specify +nil+ to not update the forwards orientation of
+    #   the geometry object.
+    # @attr up [Vector] The upwards orientation of the geometry object. This
+    #   vector must be of unit length and perpendicular to the {#forward}
+    #   vector. You can specify +nil+ to not update the upwards orientation of
+    #   the geometry object.
+    Rotation = Struct.new(:forward, :up)
+
+    ##
+    # @abstract
+    # Wrapper class for a polygon within a {Geometry} object.
+    class Polygon
+
+      include Enumerable
+
+      private_class_method :new
+
+      ##
+      # The parent geometry object.
+      # @return [Geometry]
+      attr_reader :geometry
+
+      ##
+      # The index of the {Polygon} within its parent {Geometry} object.
+      # @return [Integer]
+      attr_reader :index
+
+      ##
+      # Creates a new instance of a Polygon object.
+      # @note Polygon objects should not be created by the user, only through
+      #   {Geometry.add_polygon}, as they are an abstract wrapper only, not
+      #   backed by an actual object.
+      # @param geometry [Geometry] The parent geometry object.
+      # @param index [Integer] The index of the polygon within the geometry.
+      # @api private
+      def initialize(geometry, index)
+        @geometry, @index = geometry, index
+      end
+
+      ##
+      # @!attribute direct_occlusion
+      # The occlusion value from 0.0 to 1.0 which affects volume or audible
+      # frequencies.
+      # * *Minimum:* 0.0 The polygon does not occlude volume or audible
+      #   frequencies (sound will be fully audible)
+      # * *Maximum:* 1.0 The polygon fully occludes (sound will be silent)
+      #
+      # @return [Float]
+
+      def direct_occlusion
+        occlusion = "\0" * Fiddle::SIZEOF_FLOAT
+        FMOD.invoke(:Geometry_GetPolygonAttributes, @geometry, @index,
+                    occlusion, nil, nil)
+        occlusion.unpack1('f')
+      end
+
+      def direct_occlusion=(occlusion)
+        FMOD.invoke(:Geometry_SetPolygonAttributes, @geometry, @index,
+                    occlusion.clamp(0.0, 1.0), reverb_occlusion, double_sided.to_i)
+      end
+
+      ##
+      # @!attribute reverb_occlusion
+      # The occlusion value from 0.0 to 1.0 which affects the reverb mix.
+      # * *Minimum:* 0.0 The polygon does not occlude reverb (reverb
+      #   reflections still travel through this polygon)
+      # * *Maximum:* 1.0 The polygon fully occludes reverb (reverb
+      #   reflections will be silent through this polygon)
+      #
+      # @return [Float]
+
+      def reverb_occlusion
+        occlusion = "\0" * Fiddle::SIZEOF_FLOAT
+        FMOD.invoke(:Geometry_GetPolygonAttributes, @geometry, @index,
+                    nil, occlusion, nil)
+        occlusion.unpack1('f')
+      end
+
+      def reverb_occlusion=(occlusion)
+        FMOD.invoke(:Geometry_SetPolygonAttributes, @geometry, @index,
+                    direct_occlusion, occlusion.clamp(0.0, 1.0), double_sided.to_i)
+      end
+
+      ##
+      # @!attribute double_sided
+      # The description of polygon if it is double sided or single sided.
+      # * *true:* The polygon is double sided
+      # * *false:* The polygon is single sided, and the winding of the polygon
+      #   (which determines the polygon's normal) determines which side of the
+      #   polygon will cause occlusion.
+      #
+      # @return [Boolean]
+
+      def double_sided
+        double = "\0" * Fiddle::SIZEOF_INT
+        FMOD.invoke(:Geometry_GetPolygonAttributes, @geometry, @index,
+                    nil, nil, double)
+        double.unpack1('l') != 0
+      end
+
+      def double_sided=(double_sided)
+        FMOD.invoke(:Geometry_SetPolygonAttributes, @geometry, @index,
+                    direct_occlusion, reverb_occlusion, double_sided.to_i)
+      end
+
+      ##
+      # Retrieves the number of vertices within the polygon.
+      # @return [Integer]
+      def vertex_count
+        count = "\0" * Fiddle::SIZEOF_INT
+        FMOD.invoke(:Geometry_GetPolygonNumVertices, @geometry, @index, count)
+        count.unpack1('l')
+      end
+
+      alias size vertex_count
+
+      ##
+      # Retrieves the vertex of the polygon at the specified index.
+      # @param index [Integer] The index of the vertex to retrieve.
+      # @return [Vector]
+      def [](index)
+        return nil unless index.between?(0, vertex_count - 1)
+        vertex = Vector.zero
+        FMOD.invoke(:Geometry_GetPolygonVertex, @geometry, @index, index, vertex)
+        vertex
+      end
+
+      ##
+      # Sets the vertex of the polygon at the specified index.
+      # @param index [Integer] The index of the vertex to set.
+      # @param vertex [Vector] The vertex to set.
+      # @return [Vector] The vertex.
+      def []=(index, vertex)
+        unless index.between?(0, vertex_count - 1)
+          message = "Index #{index} outside of bounds: 0...#{vertex.count}"
+          raise IndexError, message
+        end
+        FMOD.type?(vertex, Vector)
+        FMOD.invoke(:Geometry_SetPolygonVertex, @geometry, @index, index, vertex)
+      end
+
+      ##
+      # @overload each
+      #   When called with a block, yields each vertex in turn before returning
+      #   self.
+      #   @yield [vertex] Yields a vertex to the block.
+      #   @yieldparam vertex [Vector] The enumerated vertex.
+      #   @return [self]
+      # @overload each
+      #   Returns an Enumerator for the polygon.
+      #   @return [Enumerator]
+      def each
+        return to_enum(:each) unless block_given?
+        (0...vertex_count).each { |i| yield self[i] }
+        self
+      end
+
+      ##
+      # Retrieves an array of the vertices within the polygon.
+      # @return [Array<Vector>]
+      def vertices
+        (0...vertex_count).map { |i| self[i] }
+      end
+    end
+  end
+end