สริปต์เสียง FMOD Ex เป็นสริปต์ที่สามารถ Support เสียงได้มากกว่าเคย (ปกติเราใช้ MP3 MIDI OGG WMA WAV) โดยการเพิ่มชนิดไฟล์ AAC, IT, XM, MOD, S3M ไว้ และยังสามารถ
นอกจากนี้มันยังมีฟังก์ชันอื่นๆ อีกมาก เช่น ตรวจหา Volume, ตำแหน่งที่เล่นปัจจุบัน (ยังเซตค่าที่ RMXP เดิมได้อยู่และยังใช้กับ BGS, ME, SE ได้อยู่)
Code:
#==============================================================================
# ** FMOD Ex Audio
#------------------------------------------------------------------------------
# Script by : Hiretsukan (Kevin Gadd)
# janus@luminance.org
# Modified by: : RPG/Cowlol (Firas Assad)
# ArePeeGee (AIM name)
# Last Update : September 23rd, 2008
# Version : 1.5
#------------------------------------------------------------------------------
# A rewrite of the built-in Audio module to extend its functionality
# using the FMOD Ex library (http://www.fmod.org/). In particular,
# it supports several new formats and has the ability to get current
# playing position and seek to a new one, and to set loop points.
# Extensions to Game_System and Scene_Battle makes the memorize BGM/BGS
# event command remember position as well, and map music to resume
# playing from the position it stopped at before a battle, instead
# of starting all over like default RMXP behavior.
#------------------------------------------------------------------------------
# Usage:
#
# You need to copy the file fmodex.dll to your game folder (folder where
# your Game.exe and project file are). I've provided the DLL with the
# demo, and you can also get the latest version from FMOD's official
# website (http://www.fmod.org/index.php/download).
#
# There are three scripts that could be used, the real script is only
# the first one, but the other scripts are provided for convenience:
#
# FModEx
# This includes the core functionality and the Audio module
# rewrite. It's the main script and should be placed on
# top of all scripts using it. Most people would just add a
# new section above the Game_System or Game_Temp section at
# the very top of the script editor and paste script there.
# Game_System
# This script rewrites parts of the Game_System class to
# allow memorize_bgm to support remembering position,
# and to allow the play methods to take an extra parameter
# specifying position to start playing from.
# Add it anywhere under the Game_System script section.
# If you don't need any of these features you don't need this
# script.
# Other Classes
# This is really an optional script that modifies the default
# battle system to memorize map BGM and position instead of
# starting over after the battle. Add it anywhere under
# the Scene_Battle classes.
#
# Aside from integration with RMXP's default scripts, you can use
# this script the same way you used the old Audio class You could also
# access the FMod module for more options at a lower level, such as
# setting loop points (FMod.bgm_set_loop_points(first, second) in
# milliseconds) and getting current BGS position (FMod.bgs_position) to
# name a few.
#------------------------------------------------------------------------------
# Compatibility:
#
# This script has different levels of compatibility depending on what
# scripts you use:
#
# FModEx
# This script overwrites the Audio module, but since
# few if any other scripts would do that, it's pretty
# much compatible with the majority of other scripts
# without modifications.
# Game_System
# The following methods of Game_System are redefined:
# bgm_play, bgm_restore, bgs_play, bgs_restore
# Any other script that redefines these methods may
# not work well with this one. Most scripts wouldn't
# do that, except ones dealing with audio as well.
# I've marked the areas in the script where I made
# changes to help you resolve any conflicts
# The following methods of Game_System are aliased:
# bgm_memorize, bgs_memorize
# Other scripts that redefine these methods should
# be placed above the Game_System script.
# Other Classes
# The following methods of Scene_Battle are redefined:
# judge, start_phase5, update_phase5
# Any other script that redefines these methods may
# not work well with this one. Custom battle system
# scripts may do that, so you might consider not
# including the Other Classes section and just
# manually add position memorizing functionality.
# I've marked the areas in the script where I made
# changes to help you resolve any conflicts
# The following methods of Game_Temp/Scene_Map are aliased:
# Game_Temp#initialize, Scene_Map #call_battle
# Other scripts that redefine these methods should
# be placed above the Other Classes script.
#
# So in other words, FModEx is the most compatible, followed by
# Game_System, and finally the last and optional Other Classes.
# If you use a custom battle system you probably shouldn't include
# Other Classes anyway. This isn't an SDK script and I never tested
# it with the SDK. It'll probably work, but refer to SDK documentation
# for more information.
#------------------------------------------------------------------------------
# Version Info:
# - Version 1.5:
# - Made the Volume and Pitch paramters to Audio ME/SE playing
# methods optional. (Thanks panchokoster!)
# - Script now uses FMOD's software mixer instead of hardware
# acceleration. This solves issues with certain sound cards.
# - A message is now displayed when a file isn't found, instead
# of just throwing the error number.
# - Added an independent thread to handle updating Audio module,
# instead of calling it in $game_system#update. This should
# ensure that it's called in all scenes. (Thanks Zeriab!)
# - Updated fading calculations to depend on seconds instead
# of game frames.
# - Version 1.4:
# - Fixed a bug where file isn't found if RTP path doesn't end
# with a backslash (thanks Atoa!).
# - Added BGM fading in after a ME is done playing to mimic
# original Audio class behavior, the volume increment when
# fading is specified by constant Audio::BGM_FADE_IN_INCREMENT.
# - Several minor bug fixes and minor behavior changes relating
# to fading out and stopping sounds.
# - Version 1.3:
# - Fixed a bug with ME fading out.
# - Added methods to get BGM and BGS length.
# - Providing -1 as loop end point to set_loop_points methods
# makes the sound file's end the loop end point.
# - Changed implementation of set_loop_points a bit.
# - Position of BGM/BGS to be played after fading is now
# remembered instead of starting all over.
# - Version 1.2:
# - Fully documented the script, and fixed some bugs.
# - Completely rewrote Audio module, allowing FMOD to handle
# BGMs, BGSs, MEs, and SEs except of just BGMs.
# - Fixed RTP reading to use registry instead of special files..
# - Version 1.1:
# - Added position tracking and adjusting.
# - Added loop point support.
# - Implemented BGM fading.
# - Version 1.0:
# - Hiretsukan (Kevin Gadd)'s initial release.
#------------------------------------------------------------------------------
# Known bugs:
#
# - MIDI abrupt start when seeking or restoring from position
# - Found a bug or have some ideas for the next version? Please tell me!
#------------------------------------------------------------------------------
# Terms of Use:
#
# Use of this script is subject to the permissive BSD-like license below.
# That basically means you could use it in any way you like as long
# as you keep the following copyright and license unchanged and available,
# and don't use name of copyright holder to promote products based on
# this software. Note, however, that this license only applies to the
# script, and not to the FMOD library. For more information about FMOD
# licenses consult FMOD website: http://www.fmod.org/index.php/sales
# It's free for non-commercial use, and they provide several types
# of licenses for different types of developers.
#
# Copyright (c) 2005, Kevin Gadd
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * The name of the contributors may not be used to endorse or promote
# products derived from this software without specific prior written
# permission.
#
# THIS SOFTWARE IS PROVIDED BY Kevin Gadd ''AS IS'' AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL Kevin Gadd BE LIABLE FOR ANY
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#==============================================================================
#==============================================================================
# ** FModEx
#------------------------------------------------------------------------------
# FMOD Ex binding by Kevin Gadd (janus@luminance.org)
#==============================================================================
module FModEx
#--------------------------------------------------------------------------
# * Constants
#--------------------------------------------------------------------------
# FMOD_INITFLAGS flags
FMOD_INIT_NORMAL = 0
# FMOD_RESULT flags
FMOD_OK = 0
FMOD_ERR_CHANNEL_STOLEN = 11
FMOD_ERR_FILE_NOT_FOUND = 23
FMOD_ERR_INVALID_HANDLE = 36
# FMOD_MODE flags
FMOD_DEFAULT = 0
FMOD_LOOP_OFF = 1
FMOD_LOOP_NORMAL = 2
FMOD_LOOP_BIDI = 4
FMOD_LOOP_BITMASK = 7
FMOD_2D = 8
FMOD_3D = 16
FMOD_HARDWARE = 32
FMOD_SOFTWARE = 64
FMOD_CREATESTREAM = 128
FMOD_CREATESAMPLE = 256
FMOD_OPENUSER = 512
FMOD_OPENMEMORY = 1024
FMOD_OPENRAW = 2048
FMOD_OPENONLY = 4096
FMOD_ACCURATETIME = 8192
FMOD_MPEGSEARCH = 16384
FMOD_NONBLOCKING = 32768
FMOD_UNIQUE = 65536
# The default mode that the script uses
FMOD_DEFAULT_SOFTWARWE = FMOD_LOOP_OFF | FMOD_2D | FMOD_SOFTWARE
# FMOD_CHANNELINDEX flags
FMOD_CHANNEL_FREE = -1
FMOD_CHANNEL_REUSE = -2
# FMOD_TIMEUNIT_flags
FMOD_TIMEUNIT_MS = 1
FMOD_TIMEUNIT_PCM = 2
# The default time unit the script uses
FMOD_DEFAULT_UNIT = FMOD_TIMEUNIT_MS
# Types supported by FMOD Ex
FMOD_FILE_TYPES = ['ogg', 'aac', 'wma', 'mp3', 'wav', 'it', 'xm', 'mod', 's3m', 'mid', 'midi']
#============================================================================
# ** DLL
#----------------------------------------------------------------------------
# A class that manages importing functions from the DLL
#============================================================================
class DLL
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :filename # DLL file name for instance
attr_accessor :functions # hash of functions imported (by name)
#--------------------------------------------------------------------------
# * Object Initialization
# filename : Name of the DLL
#--------------------------------------------------------------------------
def initialize(filename = 'fmodex.dll')
@filename = filename
@functions = {}
@handle = 0 # Handle to the DLL
# Load specified library into the address space of game process
w32_LL = Win32API.new('kernel32.dll', 'LoadLibrary', 'p', 'l')
@handle = w32_LL.call(filename)
# System functions:
self.import('System_Create', 'p')
self.import('System_Init', 'llll')
self.import('System_Close', 'l')
self.import('System_Release', 'l')
self.import('System_CreateSound', 'lpllp')
self.import('System_CreateStream', 'lpllp')
self.import('System_PlaySound', 'llllp')
# Sound functions:
self.import('Sound_Release', 'l')
self.import('Sound_GetMode', 'lp')
self.import('Sound_SetMode', 'll')
self.import('Sound_SetLoopPoints', 'lllll')
self.import('Sound_GetLength', 'lpl')
# Channel functions:
self.import('Channel_Stop', 'l')
self.import('Channel_IsPlaying', 'lp')
self.import('Channel_GetPaused', 'lp')
self.import('Channel_SetPaused', 'll')
self.import('Channel_GetVolume', 'lp')
self.import('Channel_SetVolume', 'll')
self.import('Channel_GetPan', 'lp')
self.import('Channel_SetPan', 'll')
self.import('Channel_GetFrequency', 'lp')
self.import('Channel_SetFrequency', 'll')
self.import('Channel_GetPosition', 'lpl')
self.import('Channel_SetPosition', 'lll')
end
#--------------------------------------------------------------------------
# * Create a Win32API Object And Add it to Hashtable
# name : Function name
# args : Argument types (p = pointer, l = int, v = void)
# returnType: Type of value returned by function
#--------------------------------------------------------------------------
def import(name, args = '', returnType = 'l')
@functions[name] = Win32API.new(@filename, 'FMOD_' + name, args, returnType)
end
#--------------------------------------------------------------------------
# * Get Function by Name
# key : Function name
#--------------------------------------------------------------------------
def [](key)
return @functions[key]
end
#--------------------------------------------------------------------------
# * Call a Function With Passed Arguments
# name : Function name
# args : Argument to function
#--------------------------------------------------------------------------
def invoke(name, *args)
fn = @functions[name]
raise "function not imported: #{name}" if fn.nil?
result = fn.call(*args)
unless result == FMOD_OK or result == FMOD_ERR_CHANNEL_STOLEN or
result == FMOD_ERR_FILE_NOT_FOUND
raise "FMOD Ex returned error #{result}"
end
return result
end
#--------------------------------------------------------------------------
# * Store Float as Binary Int Because Floats Can't be Passed Directly
# f : Float to convert
#--------------------------------------------------------------------------
def convertFloat(f)
# First pack the float in a string as a native binary float
temp = [f].pack('f')
# Then unpack the native binary float as an integer
return unpackInt(temp)
end
#--------------------------------------------------------------------------
# * Unpack Binary Data to Integer
# s : String containing binary data
#--------------------------------------------------------------------------
def unpackInt(s)
return s.unpack('l')[0]
end
#--------------------------------------------------------------------------
# * Unpack Binary Data to Float
# s : String containing binary data
#--------------------------------------------------------------------------
def unpackFloat(s)
return s.unpack('f')[0]
end
#--------------------------------------------------------------------------
# * Unpack Binary Data to Boolean
# s : String containing binary data
#--------------------------------------------------------------------------
def unpackBool(s)
return s.unpack('l')[0] != 0
end
end
#============================================================================
# ** System
#----------------------------------------------------------------------------
# A class that manages an instance of FMOD::System
#============================================================================
class System
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :fmod # Instance of DLL class (fmodex.dll)
attr_accessor :handle # Handle (pointer) to System object
attr_accessor :maxChannels # Maximum number of channels
#--------------------------------------------------------------------------
# * Object Initialization
# fmod : An instance of DLL class
# maxChannels : Maximum number of used channels
# flags : FMOD_INITFLAGS
# extraDriverData : Driver specific data
#--------------------------------------------------------------------------
def initialize(theDLL, maxChannels = 32, flags = FMOD_INIT_NORMAL, extraDriverData = 0)
@fmod = theDLL
@maxChannels = maxChannels
# Create and initialize FMOD::System
temp = 0.chr * 4
@fmod.invoke('System_Create', temp)
@handle = @fmod.unpackInt(temp)
@fmod.invoke('System_Init', @handle, maxChannels, flags, extraDriverData)
end
#--------------------------------------------------------------------------
# * Create FMOD::Sound (fully loaded into memory by default)
# filename : Name of file to open
# mode : FMOD_MODE flags
#--------------------------------------------------------------------------
def createSound(filename, mode = FMOD_DEFAULT_SOFTWARWE)
# Create sound and return it
temp = 0.chr * 4
result = @fmod.invoke('System_CreateSound', @handle, filename, mode, 0, temp)
raise "File not found: \"#{filename}\"" if result == FMOD_ERR_FILE_NOT_FOUND
newSound = Sound.new(self, @fmod.unpackInt(temp))
return newSound
end
#--------------------------------------------------------------------------
# * Create Streamed FMOD::Sound (chunks loaded on demand)
# filename : Name of file to open
# mode : FMOD_MODE flags
#--------------------------------------------------------------------------
def createStream(filename, mode = FMOD_DEFAULT_SOFTWARWE)
# Create sound and return it
temp = 0.chr * 4
result = @fmod.invoke('System_CreateStream', @handle, filename, mode, 0, temp)
raise "File not found: \"#{filename}\"" if result == FMOD_ERR_FILE_NOT_FOUND
newSound = Sound.new(self, @fmod.unpackInt(temp))
return newSound
end
#--------------------------------------------------------------------------
# * Close And Release System
#--------------------------------------------------------------------------
def dispose
if (@handle > 0)
@fmod.invoke('System_Close', @handle)
@fmod.invoke('System_Release', @handle)
@handle = 0
end
@fmod = nil
end
end
#============================================================================
# ** Sound
#----------------------------------------------------------------------------
# A class that manages an instance of FMOD::Sound
#============================================================================
class Sound
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :system # System that created this Sound
attr_accessor :fmod # Instance of DLL class (fmodex.dll)
attr_accessor :handle # Handle (pointer) to Sound object
#--------------------------------------------------------------------------
# * Object Initialization
# theSystem : The System that created this Sound object
# handle : Handle to the FMOD::Sound object
#--------------------------------------------------------------------------
def initialize(theSystem, theHandle)
@system = theSystem
@fmod = theSystem.fmod
@handle = theHandle
end
#--------------------------------------------------------------------------
# * Play Sound
# paused : Start paused?
# channel : Channel allocated to sound (nil for automatic)
#--------------------------------------------------------------------------
def play(paused = false, channel = nil)
# If channel wasn't specified, let FMOD pick a free one,
# otherwise use the passed channel (id from 0 to maxChannels)
unless channel
temp = 0.chr * 4
else
temp = [channel].pack('l')
end
@fmod.invoke('System_PlaySound', @system.handle,
(channel == nil) ? FMOD_CHANNEL_FREE : FMOD_CHANNEL_REUSE,
@handle,
(paused == true) ? 1 : 0,
temp)
theChannel = @fmod.unpackInt(temp)
# Create a Channel object based on returned channel
newChannel = Channel.new(self, theChannel)
return newChannel
end
#--------------------------------------------------------------------------
# * Get FMOD_MODE Bits
#--------------------------------------------------------------------------
def mode
temp = 0.chr * 4
@fmod.invoke('Sound_GetMode', @handle, temp)
return @fmod.unpackInt(temp)
end
#--------------------------------------------------------------------------
# * Set FMOD_MODE Bits
#--------------------------------------------------------------------------
def mode=(newMode)
@fmod.invoke('Sound_SetMode', @handle, newMode)
end
#--------------------------------------------------------------------------
# * Get FMOD_LOOP_MODE
#--------------------------------------------------------------------------
def loopMode
temp = 0.chr * 4
@fmod.invoke('Sound_GetMode', @handle, temp)
return @fmod.unpackInt(temp) & FMOD_LOOP_BITMASK
end
#--------------------------------------------------------------------------
# * Set FMOD_LOOP_MODE
#--------------------------------------------------------------------------
def loopMode=(newMode)
@fmod.invoke('Sound_SetMode', @handle, (self.mode & ~FMOD_LOOP_BITMASK) | newMode)
end
#--------------------------------------------------------------------------
# * Return Sound Length
#--------------------------------------------------------------------------
def length(unit = FMOD_DEFAULT_UNIT)
temp = 0.chr * 4
@fmod.invoke('Sound_GetLength', @handle, temp, unit)
return @fmod.unpackInt(temp)
end
#--------------------------------------------------------------------------
# * Set Loop Points
# first : Loop start point in milliseconds
# second : Loop end point in milliseconds
# unit : FMOD_TIMEUNIT for points
#--------------------------------------------------------------------------
def setLoopPoints(first, second, unit = FMOD_DEFAULT_UNIT)
@fmod.invoke('Sound_SetLoopPoints', @handle, first, unit, second, unit)
end
#--------------------------------------------------------------------------
# * Release Sound
#--------------------------------------------------------------------------
def dispose
if (@handle > 0)
@fmod.invoke('Sound_Release', @handle)
@handle = 0
end
@fmod = nil
@system = nil
end
end
#============================================================================
# ** Channel
#----------------------------------------------------------------------------
# A class that represents an FMOD::Channel
#============================================================================
class Channel
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :system # System that created the Sound
attr_accessor :sound # Sound using the Channel
attr_accessor :fmod # Instance of DLL class (fmodex.dll)
attr_accessor :handle # Handle (pointer) to Sound object
#--------------------------------------------------------------------------
# * Object Initialization
# theSound : The Sound using this Channel object
# handle : Handle to the FMOD::Channel object
#--------------------------------------------------------------------------
def initialize(theSound, theHandle)
@sound = theSound
@system = theSound.system
@fmod = theSound.system.fmod
@handle = theHandle
end
#--------------------------------------------------------------------------
# * Stop Channel and Make it Available for Other Sounds
#--------------------------------------------------------------------------
def stop
@fmod.invoke('Channel_Stop', @handle)
end
#--------------------------------------------------------------------------
# * Is the Channel Handle Valid?
#--------------------------------------------------------------------------
def valid?
temp = 0.chr * 4
begin
result = @fmod.invoke('Channel_IsPlaying', @handle, temp)
rescue
if (result == FMOD_ERR_INVALID_HANDLE)
return false
else
raise
end
end
# If we get here then it's valid
return true
end
#--------------------------------------------------------------------------
# * Is the Channel Playing?
#--------------------------------------------------------------------------
def playing?
temp = 0.chr * 4
@fmod.invoke('Channel_IsPlaying', @handle, temp)
return @fmod.unpackBool(temp)
end
#--------------------------------------------------------------------------
# * Get Channel Volume Level (0.0 -> 1.0)
#--------------------------------------------------------------------------
def volume
temp = 0.chr * 4
@fmod.invoke('Channel_GetVolume', @handle, temp)
return @fmod.unpackFloat(temp)
end
#--------------------------------------------------------------------------
# * Set Channel Volume Level (0.0 -> 1.0)
#--------------------------------------------------------------------------
def volume=(newVolume)
@fmod.invoke('Channel_SetVolume', @handle, @fmod.convertFloat(newVolume))
end
#--------------------------------------------------------------------------
# * Get Channel Pan Position (-1.0 -> 1.0)
#--------------------------------------------------------------------------
def pan
temp = 0.chr * 4
@fmod.invoke('Channel_GetPan', @handle, temp)
return @fmod.unpackFloat(temp)
end
#--------------------------------------------------------------------------
# * Set Channel Pan Position (-1.0 -> 1.0)
#--------------------------------------------------------------------------
def pan=(newPan)
@fmod.invoke('Channel_SetPan', @handle, @fmod.convertFloat(newPan))
end
#--------------------------------------------------------------------------
# * Get Channel Frequency in HZ (Speed/Pitch)
#--------------------------------------------------------------------------
def frequency
temp = 0.chr * 4
@fmod.invoke('Channel_GetFrequency', @handle, temp)
return @fmod.unpackFloat(temp)
end
#--------------------------------------------------------------------------
# * Set Channel Frequency in HZ (Speed/Pitch)
#--------------------------------------------------------------------------
def frequency=(newFrequency)
@fmod.invoke('Channel_SetFrequency', @handle, @fmod.convertFloat(newFrequency))
end
#--------------------------------------------------------------------------
# * Is Channel Paused?
#--------------------------------------------------------------------------
def paused
temp = 0.chr * 4
@fmod.invoke('Channel_GetPaused', @handle, temp)
return @fmod.unpackBool(temp)
end
#--------------------------------------------------------------------------
# * Pause Channel
#--------------------------------------------------------------------------
def paused=(newPaused)
@fmod.invoke('Channel_SetPaused', @handle, (newPaused == true) ? 1 : 0)
end
#--------------------------------------------------------------------------
# * Get Current Playback Position
# unit : FMOD_TIMEUNIT to return position in
#--------------------------------------------------------------------------
def position(unit = FMOD_DEFAULT_UNIT)
temp = 0.chr * 4
@fmod.invoke('Channel_GetPosition', @handle, temp, unit)
return @fmod.unpackInt(temp)
end
#--------------------------------------------------------------------------
# * Set Current Playback Position
# newPosition : New playback position
# unit : FMOD_TIMEUNIT to use when setting position
#--------------------------------------------------------------------------
def position=(newPosition, unit = FMOD_DEFAULT_UNIT)
@fmod.invoke('Channel_SetPosition', @handle, newPosition, unit)
end
#--------------------------------------------------------------------------
# * Dispose of Channel
#--------------------------------------------------------------------------
def dispose
@handle = 0
@sound = nil
@system = nil
@fmod = nil
end
end
end
#==============================================================================
# ** FMod
#------------------------------------------------------------------------------
# A higher level module to access FMOD Ex
#==============================================================================
module FMod
#============================================================================
# ** SoundFile
#----------------------------------------------------------------------------
# Represents a Sound file (BGM, BGS, SE, etc.) and associated Channel
#============================================================================
class SoundFile
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :name # File name
attr_accessor :sound # FModEx::Sound object
attr_accessor :channel # Channel playing sound
attr_accessor :volume # Volume in RPG::AudioFile format
attr_accessor :pitch # Pitch in RPG::AudioFile format
attr_accessor :looping # Sound loops
attr_accessor :streaming # Sound is streamed
attr_accessor :length # Sound length in milliseconds
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize(name, sound, channel, volume, pitch, looping, streaming, length)
@name = name
@sound = sound
@channel = channel
@volume = volume
@pitch = pitch
@looping = looping
@streaming = streaming
@length = length
end
end
#--------------------------------------------------------------------------
# * Instance Variables
#--------------------------------------------------------------------------
@fmod_dll = FModEx::DLL.new # The FMOD Ex DLL
@fmod = FModEx::System.new(@fmod_dll) # The global System object
@fmod_se = [] # Array of Sound Effects
@rtp_folder = nil # Name of RTP folder
#--------------------------------------------------------------------------
# * Get Path of RTP Folder From Registry
#--------------------------------------------------------------------------
def self.getRTPFolder
if @rtp_folder
return @rtp_folder
end
open_key = Win32API.new('advapi32.dll', 'RegOpenKeyExA', 'LPLLP', 'L')
query_value = Win32API.new('advapi32.dll', 'RegQueryValueExA', 'LPLPPP', 'L')
close_key = Win32API.new('advapi32', 'RegCloseKey', 'L', 'L')
key = 0.chr * 4
# Open a HKEY_LOCAL_MACHINE with KEY_READ attribute and save handle in key
open_key.call(0x80000002, 'Software\Enterbrain\RGSS\RTP', 0, 0x20019, key)
key = @fmod_dll.unpackInt(key)
type = 0.chr * 4
size = 0.chr * 4
# Query to get string size
query_value.call(key, 'Standard', 0, type, 0, size)
data = ' ' * @fmod_dll.unpackInt(size)
# Query the string value itself using size
query_value.call(key, 'Standard', 0, type, data, size)
@rtp_folder = data.chop
close_key.call(key)
# Make sure the directory ends with a backslash
@rtp_folder += "\\" if @rtp_folder[-1].chr != "\\"
return @rtp_folder
end
#--------------------------------------------------------------------------
# * Return Proper File Name (With Extensions)
# name : Name of the file
# extensions : Extensions to add to file name
#--------------------------------------------------------------------------
def self.checkExtensions(name, extensions)
if FileTest.exist?(name)
return name
end
# Add extension if needed
extensions.each do |ext|
if FileTest.exist?(name + '.' + ext)
return name + '.' + ext
end
end
# File doesn't exist
return name
end
#--------------------------------------------------------------------------
# * Get Valid File Name
# name : Name of the file
#--------------------------------------------------------------------------
def self.selectBGMFilename(name)
name = name.gsub("/", "\\")
# See if file exists in game folder
localname = self.checkExtensions(name, FModEx::FMOD_FILE_TYPES)
# See if file exists in RTP
commonname = self.checkExtensions(getRTPFolder + name, FModEx::FMOD_FILE_TYPES)
if FileTest.exist?(localname)
return localname
end
if FileTest.exist?(commonname)
return commonname
end
# An invalid name was provided
return name
end
#--------------------------------------------------------------------------
# * Play a Sound File Then Return it
# name : Name of the file
# volume : Channel volume
# pitch : Channel frequency
# position : Starting position in milliseconds
# looping : Does the sound loop?
# streaming : Stream sound or load whole thing to memory?
#--------------------------------------------------------------------------
def self.play(name, volume, pitch, position, looping, streaming)
# Get a valid file name
filename = self.selectBGMFilename(name)
# Create Sound or Stream and set initial values
sound = streaming ? @fmod.createStream(filename) : @fmod.createSound(filename)
sound.loopMode = looping ? FModEx::FMOD_LOOP_NORMAL : FModEx::FMOD_LOOP_OFF
channel = sound.play
volume = volume * 1.0
pitch = pitch * 1.0
file_length = sound.length(FModEx::FMOD_DEFAULT_UNIT)
sound_file = SoundFile.new(filename, sound, channel, volume,
pitch, looping, streaming, file_length)
sound_file.channel.volume = volume / 100.0
sound_file.channel.frequency = sound_file.channel.frequency * pitch / 100
sound_file.channel.position = position
return sound_file
end
#--------------------------------------------------------------------------
# * Stop and Dispose of Sound File
#--------------------------------------------------------------------------
def self.stop(sound_file)
unless sound_file and sound_file.channel
return
end
# Stop channel, then clear variables and dispose of bgm
sound_file.channel.stop
sound_file.channel = nil
sound_file.sound.dispose
end
#--------------------------------------------------------------------------
# * Return Length in Milliseconds
#--------------------------------------------------------------------------
def self.get_length(sound_file, unit = FModEx::FMOD_DEFAULT_UNIT)
return sound_file.length(unit)
end
#--------------------------------------------------------------------------
# * Check if Another Sound File is Playing
#--------------------------------------------------------------------------
def self.already_playing?(sound_file, name, position = 0)
# Get a valid file name
filename = self.selectBGMFilename(name)
if (sound_file)
# If the same sound file is already playing don't play it again
if (sound_file.name == filename and position == 0)
return true
end
# If another sound file is playing, stop it
if sound_file.channel
self.stop(sound_file)
end
end
# No sound file is playing or it was already stopped
return false
end
#--------------------------------------------------------------------------
# * Check if Sound File is Playing
#--------------------------------------------------------------------------
def self.playing?(sound_file)
unless sound_file and sound_file.channel
return false
end
return sound_file.channel.playing?
end
#--------------------------------------------------------------------------
# * Get Current Sound File Playing Position
#--------------------------------------------------------------------------
def self.get_position(sound_file)
unless sound_file and sound_file.channel
return 0
end
return sound_file.channel.position
end
#--------------------------------------------------------------------------
# * Seek to a New Sound File Playing Position
#--------------------------------------------------------------------------
def self.set_position(sound_file, new_pos)
unless sound_file and sound_file.channel
return
end
sound_file.channel.position = new_pos
end
#--------------------------------------------------------------------------
# * Get Current Sound File Volume
#--------------------------------------------------------------------------
def self.get_volume(sound_file)
unless sound_file
return 0
end
return sound_file.volume
end
#--------------------------------------------------------------------------
# * Set Sound File Volume
#--------------------------------------------------------------------------
def self.set_volume(sound_file, volume)
unless sound_file and sound_file.channel
return
end
sound_file.volume = volume * 1.0
sound_file.channel.volume = volume / 100.0
end
#--------------------------------------------------------------------------
# * Set Loop Points
# first : Loop start point in milliseconds
# second : Loop end point in milliseconds (-1 for file end)
# unit : FMOD_TIMEUNIT for points
#--------------------------------------------------------------------------
def self.set_loop_points(sound_file, first, second, unit = FModEx::FMOD_DEFAULT_UNIT)
unless sound_file and sound_file.channel
return
end
# If second is -1 then set loop end to the file end
if second == -1
second = sound_file.length - 1
end
# Set loop points and reflush stream buffer
sound_file.channel.sound.setLoopPoints(first, second, unit)
sound_file.channel.position = sound_file.channel.position
return sound_file
end
#--------------------------------------------------------------------------
# * Play BGM (or ME)
# name : Name of the file
# volume : Channel volume
# pitch : Channel frequency
# position : Starting position in milliseconds
# looping : Does the BGM loop?
#--------------------------------------------------------------------------
def self.bgm_play(name, volume, pitch, position = 0, looping = true)
return if self.already_playing?(@fmod_bgm, name, position)
# Now play the new BGM as a stream
@fmod_bgm = self.play(name, volume, pitch, position, looping, true)
end
#--------------------------------------------------------------------------
# * Stop and Dispose of BGM
#--------------------------------------------------------------------------
def self.bgm_stop
self.stop(@fmod_bgm)
@fmod_bgm = nil
end
#--------------------------------------------------------------------------
# * Return BGM Length in Milliseconds
#--------------------------------------------------------------------------
def self.bgm_length(sound_file)
self.get_length(@fmod_bgm)
end
#--------------------------------------------------------------------------
# * Check if a BGM is Playing
#--------------------------------------------------------------------------
def self.bgm_playing?
return self.playing?(@fmod_bgm)
end
#--------------------------------------------------------------------------
# * Get Current BGM Playing Position
#--------------------------------------------------------------------------
def self.bgm_position
return self.get_position(@fmod_bgm)
end
#--------------------------------------------------------------------------
# * Seek to New BGM Playing Position
#--------------------------------------------------------------------------
def self.bgm_position=(new_pos)
self.set_position(@fmod_bgm, new_pos)
end
#--------------------------------------------------------------------------
# * Get Current BGM Volume
#--------------------------------------------------------------------------
def self.bgm_volume
return self.get_volume(@fmod_bgm)
end
#--------------------------------------------------------------------------
# * Set BGM Volume
#--------------------------------------------------------------------------
def self.bgm_volume=(volume)
self.set_volume(@fmod_bgm, volume)
end
#--------------------------------------------------------------------------
# * Set Loop Points
# first : Loop start point in milliseconds
# second : Loop end point in milliseconds
# unit : FMOD_TIMEUNIT for points
#--------------------------------------------------------------------------
def self.bgm_set_loop_points(first, second, unit = FModEx::FMOD_DEFAULT_UNIT)
@fmod_bgm = self.set_loop_points(@fmod_bgm, first, second, unit)
end
#--------------------------------------------------------------------------
# * Play BGS
# name : Name of the file
# volume : Channel volume
# pitch : Channel frequency
# position : Starting position in milliseconds
# looping : Does the BGS loop?
#--------------------------------------------------------------------------
def self.bgs_play(name, volume, pitch, position = 0, looping = true)
return if self.already_playing?(@fmod_bgs, name, position)
# Now play the new BGS as a stream
@fmod_bgs = self.play(name, volume, pitch, position, looping, true)
end
#--------------------------------------------------------------------------
# * Stop and Dispose of BGS
#--------------------------------------------------------------------------
def self.bgs_stop
self.stop(@fmod_bgs)
@fmod_bgs = nil
end
#--------------------------------------------------------------------------
# * Return BGS Length in Milliseconds
#--------------------------------------------------------------------------
def self.bgm_length(sound_file)
self.get_length(@fmod_bgs)
end
#--------------------------------------------------------------------------
# * Check if a BGS is Playing
#--------------------------------------------------------------------------
def self.bgs_playing?
return self.playing?(@fmod_bgs)
end
#--------------------------------------------------------------------------
# * Get Current BGS Playing Position
#--------------------------------------------------------------------------
def self.bgs_position
return self.get_position(@fmod_bgs)
end
#--------------------------------------------------------------------------
# * Seek to New BGS Playing Position
#--------------------------------------------------------------------------
def self.bgs_position=(new_pos)
self.set_position(@fmod_bgs, new_pos)
end
#--------------------------------------------------------------------------
# * Get Current BGS Volume
#--------------------------------------------------------------------------
def self.bgs_volume
return self.get_volume(@fmod_bgs)
end
#--------------------------------------------------------------------------
# * Set BGS Volume
#--------------------------------------------------------------------------
def self.bgs_volume=(volume)
self.set_volume(@fmod_bgs, volume)
end
#--------------------------------------------------------------------------
# * Set Loop Points
# first : Loop start point in milliseconds
# second : Loop end point in milliseconds
# unit : FMOD_TIMEUNIT for points
#--------------------------------------------------------------------------
def self.bgs_set_loop_points(first, second, unit = FModEx::FMOD_DEFAULT_UNIT)
@fmod_bgs = self.set_loop_points(@fmod_bgs, first, second, unit)
end
#--------------------------------------------------------------------------
# * Play SE
# name : Name of the file
# volume : Channel volume
# pitch : Channel frequency
#--------------------------------------------------------------------------
def self.se_play(name, volume, pitch)
if @fmod_se.size > @fmod.maxChannels
se = @fmod_se.shift
self.stop(se)
end
# Load SE into memory and play it
@fmod_se << self.play(name, volume, pitch, 0, false, false)
end
#--------------------------------------------------------------------------
# * Stop and Dispose of all SEs
#--------------------------------------------------------------------------
def self.se_stop
for se in @fmod_se
self.stop(se)
end
@fmod_se.clear
end
#--------------------------------------------------------------------------
# * Get Rid of Non-Playing SEs
#--------------------------------------------------------------------------
def self.se_clean
for se in @fmod_se
unless self.playing?(se)
self.stop(se)
@fmod_se.delete(se)
end
end
end
#--------------------------------------------------------------------------
# * Check if There's Some SE in SE Array
#--------------------------------------------------------------------------
def self.se_list_empty?
return @fmod_se.empty?
end
#--------------------------------------------------------------------------
# * Dispose of Everything
#--------------------------------------------------------------------------
def self.dispose
self.bgm_stop
self.bgs_stop
self.se_stop
@fmod.dispose
end
end
#==============================================================================
# ** Audio
#------------------------------------------------------------------------------
# The module that carries out music and sound processing.
#==============================================================================
module Audio
#--------------------------------------------------------------------------
# * Constants
#--------------------------------------------------------------------------
BGM_FADE_IN_INCREMENT = 5 # BGM volume incremented 0.2 seconds
#--------------------------------------------------------------------------
# * Instance Variables
#--------------------------------------------------------------------------
@bgm_fading_out = false # BGM started fading out
@bgm_fade_decrement = 0.0 # BGM volume decremented each update
@bgs_fading_out = false # BGS started fading out
@bgs_fade_decrement = 0.0 # BGS volume decremented each update
@me_fading_out = false # ME started fading out
@me_fade_decrement = 0.0 # ME volume decremented each update
@me_playing = false # Is some ME playing?
@playing_bgm = nil # BGM currently being played
@next_bgm = nil # The BGM to be played after fading out
@next_bgm_position = 0 # Starting position of next bgm
@next_bgs = nil # The BGS to be played after fading out
@next_bgs_position = 0 # Starting position of next bgm
@next_me = nil # The ME to be played after fading
#--------------------------------------------------------------------------
# * Starts BGM Playback
# name : Name of the file
# volume : Channel volume
# pitch : Channel frequency
# position : Starting position in milliseconds
#--------------------------------------------------------------------------
def Audio.bgm_play(filename, volume = 100, pitch = 100, position = 0,
fade_in = false)
if @bgm_fading_out and !fade_in
@next_bgm = RPG::AudioFile.new(filename, volume, pitch)
@next_bgm_position = position
return
end
start_volume = volume
if fade_in
@bgm_target_volume = volume unless @bgm_fading_in
@bgm_fading_in = true
start_volume = 0
end
@bgm_fading_out = false
# If a ME is playing we wait until it's over before playing BGM
unless @me_playing
FMod::bgm_play(filename, start_volume, pitch, position)
end
@playing_bgm = RPG::AudioFile.new(filename, volume, pitch)
@memorized_bgm = @playing_bgm
@memorized_bgm_position = position
end
#--------------------------------------------------------------------------
# * Stops BGM Playback
#--------------------------------------------------------------------------
def Audio.bgm_stop
@memorized_bgm = nil
@playing_bgm = nil
@bgm_fading_in = false
@bgm_fading_out = false
# MEs are internally BGMs, but are stopped with me_stop instead
if @me_playing
return
end
FMod::bgm_stop
end
#--------------------------------------------------------------------------
# * Starts BGM fadeout.
# time : Length of the fadeout in milliseconds.
#--------------------------------------------------------------------------
def Audio.bgm_fade(time)
return if @me_playing or !FMod::bgm_playing?
@bgm_fading_out = true
time = time / 1000
@bgm_fade_decrement = FMod::bgm_volume / (time * 5)
end
#--------------------------------------------------------------------------
# * Starts BGS Playback
# name : Name of the file
# volume : Channel volume
# pitch : Channel frequency
# position : Starting position in milliseconds
#--------------------------------------------------------------------------
def Audio.bgs_play(filename, volume = 100, pitch = 100, position = 0)
if @bgs_fading_out
@next_bgs = RPG::AudioFile.new(filename, volume, pitch)
@next_bgs_position = position
return
end
FMod::bgs_play(filename, volume, pitch, position)
end
#--------------------------------------------------------------------------
# * Stops BGS Playback
#--------------------------------------------------------------------------
def Audio.bgs_stop
FMod::bgs_stop
@bgs_fading_out = false
end
#--------------------------------------------------------------------------
# * Starts BGS fadeout.
# time : Length of the fadeout in milliseconds.
#--------------------------------------------------------------------------
def Audio.bgs_fade(time)
return unless FMod::bgs_playing?
@bgs_fading_out = true
time = time / 1000
@bgs_fade_decrement = FMod::bgs_volume / (time * 5)
end
#--------------------------------------------------------------------------
# * Starts ME Playback
# name : Name of the file
# volume : Channel volume
# pitch : Channel frequency
#--------------------------------------------------------------------------
def Audio.me_play(filename, volume = 100, pitch = 100)
if @me_fading_out
@next_me = RPG::AudioFile.new(filename, volume, pitch)
return
end
if @bgm_fading_out
self.bgm_stop
end
# Memorize playing bgm
if @playing_bgm and !@me_playing
bgm = @playing_bgm
@playing_bgm = RPG::AudioFile.new(bgm.name, FMod::bgm_volume, bgm.pitch)
@memorized_bgm = @playing_bgm
@memorized_bgm_position = FMod::bgm_position
end
@me_playing = true
FMod::bgm_play(filename, volume, pitch, 0, false)
end
#--------------------------------------------------------------------------
# * Stops ME Playback
#--------------------------------------------------------------------------
def Audio.me_stop
return unless @me_playing
@me_playing = false
@me_fading_out = false
# Play memorized bgm, fading in
if @memorized_bgm and !@bgm_fading_out
bgm = @memorized_bgm
self.bgm_play(bgm.name, bgm.volume, bgm.pitch, @memorized_bgm_position, true)
else
self.bgm_stop
end
end
#--------------------------------------------------------------------------
# * Starts ME fadeout.
# time : Length of the fadeout in milliseconds.
#--------------------------------------------------------------------------
def Audio.me_fade(time)
return unless FMod::bgm_playing?
@me_fading_out = true
time = time / 1000
@bgm_fade_decrement = FMod::bgm_volume / (time * 5)
end
#--------------------------------------------------------------------------
# * Starts SE Playback
# name : Name of the file
# volume : Channel volume
# pitch : Channel frequency
#--------------------------------------------------------------------------
def Audio.se_play(filename, volume = 100, pitch = 100)
FMod::se_play(filename, volume, pitch)
end
#--------------------------------------------------------------------------
# * Stops SE Playback
#--------------------------------------------------------------------------
def Audio.se_stop
FMod::se_stop
end
#--------------------------------------------------------------------------
# * Update ME Playback, SE Disposal and Fading, Called Each Frame
#--------------------------------------------------------------------------
def Audio.update
# Stop ME when it's over (and continue playing BGM)
if @me_playing
unless FMod::bgm_playing?
self.me_stop
end
end
# Remove any finished SEs
unless FMod::se_list_empty?
FMod::se_clean
end
if @bgm_fading_in
# Stop fading when target is reached, otherwise increase volume
if FMod::bgm_volume >= @bgm_target_volume
@bgm_fading_in = false
else
current_volume = FMod::bgm_volume + BGM_FADE_IN_INCREMENT
FMod::bgm_volume = current_volume
end
end
if FMod::bgm_playing? and @bgm_fading_out and
!@me_playing
if FMod::bgm_volume <= 0
@bgm_fading_out = false
self.bgm_stop
# If another BGM played while fading out, play it (most recent)
if @next_bgm
self.bgm_play(@next_bgm.name, @next_bgm.volume,
@next_bgm.pitch, @next_bgm_position)
@next_bgm = nil
end
else
current_volume = FMod::bgm_volume - @bgm_fade_decrement
FMod::bgm_volume = current_volume
end
end
if FMod::bgs_playing? and @bgs_fading_out
if FMod::bgs_volume <= 0
@bgs_fading_out = false
self.bgs_stop
# If another BGS played while fading out, play it (most recent)
if @next_bgs
self.bgs_play(@next_bgs.name, @next_bgs.volume,
@next_bgs.pitch, @next_bgs_position)
@next_bgs = nil
end
else
current_volume = FMod::bgs_volume - @bgs_fade_decrement
FMod::bgs_volume = current_volume
end
end
if FMod::bgm_playing? and @me_fading_out
if FMod::bgm_volume <= 0
# If another ME played while fading out, play it (most recent)
if @next_me
self.me_play(@next_me.name, @next_me.volume, @next_me.pitch)
@next_me = nil
else
@me_fading_out = false
self.me_stop
end
else
current_volume = FMod::bgm_volume - @bgm_fade_decrement
FMod::bgm_volume = current_volume
end
end
end
end
# Create an endless loop to update Audio module
Thread.new do
loop do
sleep 0.2
Audio.update
end
end
FMOD Ex สริปต์สำหรับ Audio
admannon
![[-]](https://irpg.in.th/images/collapse.png)
