Hellow!
Je vais tester ça et editer se post
.
Je vais tester ça et editer se post
.| 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 |
.