FMOD Engine User Manual 2.03

6. Studio API Reference | Studio::System

The main system object for FMOD Studio.

Initializing the studio system object also initializes the core System object.

Lifetime:


Update:

Banks:



Listeners:

Buses:

Events:

Parameters:

VCAs:

Advanced settings:


Command capture and replay:


Profiling:


Plug-ins:

System callback:


Sound table:


General:

FMOD_STUDIO_ADVANCEDSETTINGS

Settings for advanced features like configuring memory and cpu usage.

C
C++
C#
JS

typedef struct FMOD_STUDIO_ADVANCEDSETTINGS {
  int            cbsize;
  unsigned int   commandqueuesize;
  unsigned int   handleinitialsize;
  int            studioupdateperiod;
  int            idlesampledatapoolsize;
  unsigned int   streamingscheduledelay;
  const char*    encryptionkey;
} FMOD_STUDIO_ADVANCEDSETTINGS;
struct Studio.ADVANCEDSETTINGS
{
  int cbsize;
  int commandqueuesize;
  int handleinitialsize;
  int studioupdateperiod;
  int idlesampledatapoolsize;
  int streamingscheduledelay;
  StringWrapper encryptionkey;
}
FMOD_STUDIO_ADVANCEDSETTINGS
{
  commandqueuesize,
  handleinitialsize,
  studioupdateperiod,
  idlesampledatapoolsize,
  streamingscheduledelay;
};
cbsize
Size of this structure in bytes. Must be set to sizeof(FMOD_STUDIO_ADVANCEDSETTINGS) before calling Studio::System::setAdvancedSettings or Studio::System::getAdvancedSettings.
commandqueuesize

Command queue size for studio async processing.

  • Units: Bytes
  • Default: 32768
handleinitialsize

Initial size to allocate for handles. Memory for handles will grow as needed in pages.

  • Units: Bytes
  • Default: 8192 * sizeof(void*)
studioupdateperiod

Update period of Studio when in async mode, in milliseconds. Will be quantized to the nearest multiple of mixer duration.

  • Units: Milliseconds
  • Default: 20
idlesampledatapoolsize

Size in bytes of sample data to retain in memory when no longer used, to avoid repeated disk I/O. Use -1 to disable.

  • Units: Bytes
  • Default: 262144
streamingscheduledelay

Specify the schedule delay for streams, in samples. Lower values can reduce latency when scheduling events containing streams but may cause scheduling issues if too small.

  • Units: Samples
  • Default: 8192
encryptionkey
Specify the key for loading sounds from encrypted banks. (UTF-8 string)

When calling Studio::System::setAdvancedSettings any member other than cbsize may be set to zero to use the default value for that setting.

FMOD_STUDIO_BANK_INFO

Information for loading a bank using user callbacks.

C
C++
C#
JS

typedef struct FMOD_STUDIO_BANK_INFO {
  int                        size;
  void                      *userdata;
  int                        userdatalength;
  FMOD_FILE_OPEN_CALLBACK    opencallback;
  FMOD_FILE_CLOSE_CALLBACK   closecallback;
  FMOD_FILE_READ_CALLBACK    readcallback;
  FMOD_FILE_SEEK_CALLBACK    seekcallback;
} FMOD_STUDIO_BANK_INFO;
struct Studio.BANK_INFO
{
  int size;
  IntPtr userdata;
  int userdatalength;
  FILE_OPENCALLBACK opencallback;
  FILE_CLOSECALLBACK closecallback;
  FILE_READCALLBACK readcallback;
  FILE_SEEKCALLBACK seekcallback;
}
FMOD_STUDIO_BANK_INFO
{
  userdata,
  userdatalength,
  opencallback,
  closecallback,
  readcallback,
  seekcallback,
};
size
Size of this structure in bytes. Must be set to sizeof(FMOD_STUDIO_BANK_INFO).
userdata Opt
User data to be passed to the file callbacks. If userdatalength is zero, this must remain valid until the bank has been unloaded and all calls to opencallback have been matched by a call to closecallback.
userdatalength
Length of user data in bytes. If non-zero the userdata will be copied internally; this copy will be kept until the bank has been unloaded and all calls to opencallback have been matched by a call to closecallback.
opencallback
Callback for opening the bank file. (FMOD_FILE_OPEN_CALLBACK)
closecallback
Callback for closing the bank file. (FMOD_FILE_CLOSE_CALLBACK)
readcallback
Callback for reading from the bank file. (FMOD_FILE_READ_CALLBACK)
seekcallback
Callback for seeking within the bank file. (FMOD_FILE_SEEK_CALLBACK)

See Also: Studio::System::loadBankCustom

FMOD_STUDIO_BUFFER_INFO

Information for a single buffer in FMOD Studio.

C
C++
C#
JS

typedef struct FMOD_STUDIO_BUFFER_INFO {
  int     currentusage;
  int     peakusage;
  int     capacity;
  int     stallcount;
  float   stalltime;
} FMOD_STUDIO_BUFFER_INFO;
struct Studio.BUFFER_INFO
{
    int currentusage;
    int peakusage;
    int capacity;
    int stallcount;
    float stalltime;
}
FMOD_STUDIO_BUFFER_INFO
{
  currentusage,
  peakusage,
  capacity,
  stallcount,
  stalltime,
};
currentusage
Current buffer usage in bytes.
peakusage
Peak buffer usage in bytes.
capacity
Buffer capacity in bytes.
stallcount
Cumulative number of stalls due to buffer overflow.
stalltime
Cumulative amount of time stalled due to buffer overflow, in seconds.

See Also: FMOD_STUDIO_BUFFER_USAGE

FMOD_STUDIO_BUFFER_USAGE

Information for FMOD Studio buffer usage.

C
C++
C#
JS

typedef struct FMOD_STUDIO_BUFFER_USAGE {
  FMOD_STUDIO_BUFFER_INFO   studiocommandqueue;
  FMOD_STUDIO_BUFFER_INFO   studiohandle;
} FMOD_STUDIO_BUFFER_USAGE;
struct Studio.BUFFER_USAGE
{
  BUFFER_INFO studiocommandqueue;
  BUFFER_INFO studiohandle;
}
FMOD_STUDIO_BUFFER_USAGE
{
  studiocommandqueue,
  studiohandle,
};
studiocommandqueue
Information for the Studio Async Command buffer. (FMOD_STUDIO_BUFFER_INFO)
studiohandle
Information for the Studio handle table. (FMOD_STUDIO_BUFFER_INFO)

See Also: Studio::System::getBufferUsage

FMOD_STUDIO_COMMANDCAPTURE_FLAGS

Flags controling command capture.

C
C++
C#
JS

#define FMOD_STUDIO_COMMANDCAPTURE_NORMAL             0x00000000
#define FMOD_STUDIO_COMMANDCAPTURE_FILEFLUSH          0x00000001
#define FMOD_STUDIO_COMMANDCAPTURE_SKIP_INITIAL_STATE 0x00000002
enum Studio.COMMANDCAPTURE_FLAGS : uint
{
    NORMAL             = 0x00000000,
    FILEFLUSH          = 0x00000001,
    SKIP_INITIAL_STATE = 0x00000002,
}
STUDIO_COMMANDCAPTURE_NORMAL             0x00000000
STUDIO_COMMANDCAPTURE_FILEFLUSH          0x00000001
STUDIO_COMMANDCAPTURE_SKIP_INITIAL_STATE 0x00000002
FMOD_STUDIO_COMMANDCAPTURE_NORMAL
Use default options.
FMOD_STUDIO_COMMANDCAPTURE_FILEFLUSH
Call file flush on every command.
FMOD_STUDIO_COMMANDCAPTURE_SKIP_INITIAL_STATE
The initial state of banks and instances is captured, unless this flag is set.

See Also: Studio::System::startCommandCapture

FMOD_STUDIO_COMMANDREPLAY_FLAGS

Flags controlling command replay.

C
C++
C#
JS

#define FMOD_STUDIO_COMMANDREPLAY_NORMAL         0x00000000
#define FMOD_STUDIO_COMMANDREPLAY_SKIP_CLEANUP   0x00000001
#define FMOD_STUDIO_COMMANDREPLAY_FAST_FORWARD   0x00000002
#define FMOD_STUDIO_COMMANDREPLAY_SKIP_BANK_LOAD 0x00000004
enum Studio.COMMANDREPLAY_FLAGS : uint
{
  NORMAL         = 0x00000000,
  SKIP_CLEANUP   = 0x00000001,
  FAST_FORWARD   = 0x00000002,
  SKIP_BANK_LOAD = 0x00000004,
}
STUDIO_COMMANDREPLAY_NORMAL         0x00000000
STUDIO_COMMANDREPLAY_SKIP_CLEANUP   0x00000001
STUDIO_COMMANDREPLAY_FAST_FORWARD   0x00000002
STUDIO_COMMANDREPLAY_SKIP_BANK_LOAD 0x00000004
FMOD_STUDIO_COMMANDREPLAY_NORMAL
Use default options.
FMOD_STUDIO_COMMANDREPLAY_SKIP_CLEANUP
Do not free resources at the end of playback.
FMOD_STUDIO_COMMANDREPLAY_FAST_FORWARD
Play back at maximum speed, ignoring the timing of the original replay.
FMOD_STUDIO_COMMANDREPLAY_SKIP_BANK_LOAD
Skip commands related to bank loading.

See Also: Studio::System::loadCommandReplay

FMOD_STUDIO_CPU_USAGE

Performance information for Studio API functionality.

C
C++
C#
JS

typedef struct FMOD_STUDIO_CPU_USAGE {
  float   update;
} FMOD_STUDIO_CPU_USAGE;
struct Studio.CPU_USAGE
{
    float update;
}
FMOD_STUDIO_CPU_USAGE
{
  update
};
update

Studio::System::update CPU usage. Percentage of main thread, or main thread if FMOD_STUDIO_INIT_SYNCHRONOUS_UPDATE flag is used with Studio::System::initialize.

  • Units: Percent
  • Range: [0, 100]

This structure is filled in with Studio::System::getCPUUsage.

See Also: System::getCPUUsage, FMOD_CPU_USAGE

FMOD_STUDIO_INITFLAGS

Studio System initialization flags.

C
C++
C#
JS

#define FMOD_STUDIO_INIT_NORMAL                0x00000000
#define FMOD_STUDIO_INIT_LIVEUPDATE            0x00000001
#define FMOD_STUDIO_INIT_ALLOW_MISSING_PLUGINS 0x00000002
#define FMOD_STUDIO_INIT_SYNCHRONOUS_UPDATE    0x00000004
#define FMOD_STUDIO_INIT_DEFERRED_CALLBACKS    0x00000008
#define FMOD_STUDIO_INIT_LOAD_FROM_UPDATE      0x00000010
#define FMOD_STUDIO_INIT_MEMORY_TRACKING       0x00000020
enum Studio.INITFLAGS : uint
{
    NORMAL                = 0x00000000
    LIVEUPDATE            = 0x00000001
    ALLOW_MISSING_PLUGINS = 0x00000002
    SYNCHRONOUS_UPDATE    = 0x00000004
    DEFERRED_CALLBACKS    = 0x00000008
    LOAD_FROM_UPDATE      = 0x00000010
    MEMORY_TRACKING       = 0x00000020
}
STUDIO_INIT_NORMAL                0x00000000
STUDIO_INIT_LIVEUPDATE            0x00000001
STUDIO_INIT_ALLOW_MISSING_PLUGINS 0x00000002
STUDIO_INIT_SYNCHRONOUS_UPDATE    0x00000004
STUDIO_INIT_DEFERRED_CALLBACKS    0x00000008
STUDIO_INIT_LOAD_FROM_UPDATE      0x00000010
STUDIO_INIT_MEMORY_TRACKING       0x00000020
FMOD_STUDIO_INIT_NORMAL
Use defaults for all initialization options.
FMOD_STUDIO_INIT_LIVEUPDATE
Enable live update.
FMOD_STUDIO_INIT_ALLOW_MISSING_PLUGINS
Load banks even if they reference plug-ins that have not been loaded.
FMOD_STUDIO_INIT_SYNCHRONOUS_UPDATE
Disable asynchronous processing and perform all processing on the calling thread instead.
FMOD_STUDIO_INIT_DEFERRED_CALLBACKS
Defer timeline callbacks until the main update. See Studio::EventInstance::setCallback for more information.
FMOD_STUDIO_INIT_LOAD_FROM_UPDATE
No additional threads are created for bank and resource loading. Loading is driven from Studio::System::update.
FMOD_STUDIO_INIT_MEMORY_TRACKING
Enables detailed memory usage statistics. Increases memory footprint and impacts performance. See Studio::Bus::getMemoryUsage and Studio::EventInstance::getMemoryUsage for more information. Implies FMOD_INIT_MEMORY_TRACKING.

See Also: Studio::System::initialize

FMOD_STUDIO_LOAD_BANK_FLAGS

Flags for controlling bank loading.

C
C++
C#
JS

#define FMOD_STUDIO_LOAD_BANK_NORMAL             0x00000000
#define FMOD_STUDIO_LOAD_BANK_NONBLOCKING        0x00000001
#define FMOD_STUDIO_LOAD_BANK_DECOMPRESS_SAMPLES 0x00000002
#define FMOD_STUDIO_LOAD_BANK_UNENCRYPTED        0x00000004
enum Studio.LOAD_BANK_FLAGS : uint
{
    NORMAL             = 0x00000000,
    NONBLOCKING        = 0x00000001,
    DECOMPRESS_SAMPLES = 0x00000002,
    UNENCRYPTED        = 0x00000004,
}
STUDIO_LOAD_BANK_NORMAL             0x00000000
STUDIO_LOAD_BANK_NONBLOCKING        0x00000001
STUDIO_LOAD_BANK_DECOMPRESS_SAMPLES 0x00000002
STUDIO_LOAD_BANK_UNENCRYPTED        0x00000004
FMOD_STUDIO_LOAD_BANK_NORMAL
Standard behavior.
FMOD_STUDIO_LOAD_BANK_NONBLOCKING
Bank loading occurs asynchronously rather than occurring immediately.
FMOD_STUDIO_LOAD_BANK_DECOMPRESS_SAMPLES
Force samples to decompress into memory when they are loaded, rather than staying compressed.
FMOD_STUDIO_LOAD_BANK_UNENCRYPTED
Ignore the encryption key specified by Studio::System::setAdvancedSettings when loading sounds from this bank (assume the sounds in the bank are not encrypted).

See Also: Studio::System::loadBankFile, Studio::System::loadBankMemory, Studio::System::loadBankCustom

FMOD_STUDIO_LOAD_MEMORY_ALIGNMENT

The required memory alignment of banks in user memory.

C
C++
C#
JS

#define FMOD_STUDIO_LOAD_MEMORY_ALIGNMENT   32

Not supported for C#.

Not supported for JavaScript.

See Also: Studio::System::loadBankMemory

FMOD_STUDIO_LOAD_MEMORY_MODE

Specifies how to use the memory buffer passed to Studio::System::loadBankMemory.

C
C++
C#
JS

typedef enum FMOD_STUDIO_LOAD_MEMORY_MODE {
  FMOD_STUDIO_LOAD_MEMORY,
  FMOD_STUDIO_LOAD_MEMORY_POINT
} FMOD_STUDIO_LOAD_MEMORY_MODE;

Not supported for C#.

STUDIO_LOAD_MEMORY       0
STUDIO_LOAD_MEMORY_POINT 1
FMOD_STUDIO_LOAD_MEMORY
Memory buffer is copied internally.
FMOD_STUDIO_LOAD_MEMORY_POINT
Memory buffer is used directly in user memory.

It is not currently possible for the FMOD Engine to use banks loaded into user memory. Only FMOD.STUDIO_LOAD_MEMORY is supported.

See Also: Studio::System::loadBankMemory

FMOD_STUDIO_SOUND_INFO

Describes a sound in the audio table.

C
C++
C#
JS

typedef struct FMOD_STUDIO_SOUND_INFO {
  const char              *name_or_data;
  FMOD_MODE                mode;
  FMOD_CREATESOUNDEXINFO   exinfo;
  int                      subsoundindex;
} FMOD_STUDIO_SOUND_INFO;
class Studio.SOUND_INFO
{
  byte[] name_or_data;
  MODE mode;
  CREATESOUNDEXINFO exinfo;
  int subsoundindex;
  string name { get; }
}
FMOD_STUDIO_SOUND_INFO
{
  name_or_data,
  mode,
  exinfo,
  subsoundindex,
};
name_or_data
The filename (UTF-8 string) or memory buffer that contains the sound.
mode

Mode flags required for loading the sound. (FMOD_MODE)

exinfo
Extra information required for loading the sound. (FMOD_CREATESOUNDEXINFO)
subsoundindex
Subsound index for loading the sound.

The name property is a getter for the name_or_data member which will return null if the sound should be loaded from memory.

See Also: Studio::System::getSoundInfo

FMOD_STUDIO_SYSTEM_CALLBACK

Callback for Studio system events.

C
C++
C#
JS

FMOD_RESULT F_CALL FMOD_STUDIO_SYSTEM_CALLBACK(
  FMOD_STUDIO_SYSTEM *system,
  FMOD_STUDIO_SYSTEM_CALLBACK_TYPE type,
  void *commanddata,
  void *userdata
);
delegate RESULT Studio.SYSTEM_CALLBACK(
  IntPtr system,
  SYSTEM_CALLBACK_TYPE type,
  IntPtr commanddata,
  IntPtr userdata
);
function FMOD_STUDIO_SYSTEM_CALLBACK(
  system,
  type,
  commanddata,
  userdata
)
system
Studio system. (Studio::System)
type
Callback type. (FMOD_STUDIO_SYSTEM_CALLBACK_TYPE)
commanddata
Data specific to callback type.
userdata
User data set with Studio::System::setUserData.

system can be cast to Studio::System *.

See Also: Callback Behavior, User Data

FMOD_STUDIO_SYSTEM_CALLBACK_TYPE

Callback types for the Studio System callback.

C
C++
C#
JS

#define FMOD_STUDIO_SYSTEM_CALLBACK_PREUPDATE               0x00000001
#define FMOD_STUDIO_SYSTEM_CALLBACK_POSTUPDATE              0x00000002
#define FMOD_STUDIO_SYSTEM_CALLBACK_BANK_UNLOAD             0x00000004
#define FMOD_STUDIO_SYSTEM_CALLBACK_LIVEUPDATE_CONNECTED    0x00000008
#define FMOD_STUDIO_SYSTEM_CALLBACK_LIVEUPDATE_DISCONNECTED 0x00000010
#define FMOD_STUDIO_SYSTEM_CALLBACK_ALL                     0xFFFFFFFF
enum Studio.SYSTEM_CALLBACK_TYPE : uint
{
    PREUPDATE               = 0x00000001,
    POSTUPDATE              = 0x00000002,
    BANK_UNLOAD             = 0x00000004,
    LIVEUPDATE_CONNECTED    = 0x00000008,
    LIVEUPDATE_DISCONNECTED = 0x00000010,
    ALL                     = 0xFFFFFFFF,
}
STUDIO_SYSTEM_CALLBACK_PREUPDATE                0x00000001
STUDIO_SYSTEM_CALLBACK_POSTUPDATE               0x00000002
STUDIO_SYSTEM_CALLBACK_BANK_UNLOAD              0x00000004
STUDIO_SYSTEM_CALLBACK_LIVEUPDATE_CONNECTED     0x00000008
STUDIO_SYSTEM_CALLBACK_LIVEUPDATE_DISCONNECTED  0x00000010
STUDIO_SYSTEM_CALLBACK_ALL                      0xFFFFFFFF
FMOD_STUDIO_SYSTEM_CALLBACK_PREUPDATE
Called at the start of the main Studio update. For async mode this will be on its own thread.
FMOD_STUDIO_SYSTEM_CALLBACK_POSTUPDATE
Called at the end of the main Studio update. For async mode this will be on its own thread.
FMOD_STUDIO_SYSTEM_CALLBACK_BANK_UNLOAD
Called directly when a bank has just been unloaded, after all resources are freed. The commanddata argument is the bank handle.
FMOD_STUDIO_SYSTEM_CALLBACK_ALL
Pass this mask to Studio::System::setCallback to receive all callback types.
FMOD_STUDIO_SYSTEM_CALLBACK_LIVEUPDATE_CONNECTED
Called after a live update connection has been established.
FMOD_STUDIO_SYSTEM_CALLBACK_LIVEUPDATE_DISCONNECTED
Called after live update session disconnects.

Callbacks are called from the Studio Update Thread in default / async mode and the main (calling) thread in synchronous mode.

See Also: Callback Behavior, FMOD_STUDIO_SYSTEM_CALLBACK, Studio::System::setCallback

Studio::System::create

FMOD Studio System creation function.

C
C++
C#
JS

static FMOD_RESULT Studio::System::create(
  Studio::System **system,
  unsigned int headerversion = FMOD_VERSION
);
FMOD_RESULT FMOD_Studio_System_Create(
  FMOD_STUDIO_SYSTEM **system,
  unsigned int headerversion
);
static RESULT Studio.System.create(
  out System system
);
static Studio_System_Create(
  system
);
system Out
Studio System object. (Studio::System)
headerversion
Expected Studio API version.

Pass FMOD_VERSION in headerversion to ensure the library and header versions being used match.

Call Studio::System::release to free the Studio System.

Studio::System::create and Studio::System::release are not thread-safe. Calling either of these functions concurrently with any Studio API function (including these two functions) may cause undefined behavior. External synchronization must be used if calls to Studio::System::create or Studio::System::release could overlap other Studio API calls. All other Studio API functions are thread safe and may be called freely from any thread unless otherwise documented.

See Also: Creating the Studio System

Studio::System::flushCommands

Block until all pending commands have been executed.

C
C++
C#
JS

FMOD_RESULT Studio::System::flushCommands();
FMOD_RESULT FMOD_Studio_System_FlushCommands(FMOD_STUDIO_SYSTEM *system);
RESULT Studio.System.flushCommands();
Studio.System.flushCommands();

This function blocks the calling thread until all pending commands have been executed and all non-blocking bank loads have been completed.

This is equivalent to calling Studio::System::update and then sleeping until the asynchronous thread has finished executing all pending commands.

See Also: Studio::System::initialize, Studio::System::update, Studio::System::flushSampleLoading

Studio::System::flushSampleLoading

Block until all sample loading and unloading has completed.

C
C++
C#
JS

FMOD_RESULT Studio::System::flushSampleLoading();
FMOD_RESULT FMOD_Studio_System_FlushSampleLoading(FMOD_STUDIO_SYSTEM *system);
RESULT Studio.System.flushSampleLoading();
Studio.System.flushSampleLoading();

This function may stall for a long time if other threads are continuing to issue calls to load and unload sample data, e.g. by creating new event instances.

See Also: Studio::System::flushCommands, Sample Data Loading

Studio::System::getAdvancedSettings

Retrieves advanced settings.

C
C++
C#
JS

FMOD_RESULT Studio::System::getAdvancedSettings(
  FMOD_STUDIO_ADVANCEDSETTINGS *settings
);
FMOD_RESULT FMOD_Studio_System_GetAdvancedSettings(
  FMOD_STUDIO_SYSTEM *system,
  FMOD_STUDIO_ADVANCEDSETTINGS *settings
);
RESULT Studio.System.getAdvancedSettings(
  out ADVANCEDSETTINGS settings
);
Studio.System.getAdvancedSettings(
  settings
);
settings Out
Studio System advanced settings. (FMOD_STUDIO_ADVANCEDSETTINGS)

See Also: Studio::System::setAdvancedSettings

Studio::System::getBank

Retrieves a loaded bank with the specified file path.

C
C++
C#
JS

FMOD_RESULT Studio::System::getBank(
  const char *path,
  Studio::Bank **bank
);
FMOD_RESULT FMOD_Studio_System_GetBank(
  FMOD_STUDIO_SYSTEM *system,
  const char *path,
  FMOD_STUDIO_BANK **bank
);
RESULT Studio.System.getBank(
  string path,
  out Bank bank
);
Studio.System.getBank(
  path,
  bank
);
path
The bank path or the ID string that identifies the bank. (UTF-8 string)
bank Out
Bank object. (Studio::Bank)

path may be a path, such as bank:/Weapons or an ID string such as {793cddb6-7fa1-4e06-b805-4c74c0fd625b}.

Note that path lookups will only succeed if the strings bank has been loaded.

See Also: Studio::System::getBankByID

Studio::System::getBankByID

Retrieves a loaded bank with the specified ID.

C
C++
C#
JS

FMOD_RESULT Studio::System::getBankByID(
  const FMOD_GUID *id,
  Studio::Bank **bank
);
FMOD_RESULT FMOD_Studio_System_GetBankByID(
  FMOD_STUDIO_SYSTEM *system,
  const FMOD_GUID *id,
  FMOD_STUDIO_BANK **bank
);
RESULT Studio.System.getBankByID(
  Guid id,
  out Bank bank
);
Studio.System.getBankByID(
  id,
  bank
);
id
Bank GUID. (FMOD_GUID)
bank Out
Bank object. (Studio::Bank)

See Also: Studio::parseID, Studio::System::lookupID, Studio::System::getBank

Studio::System::getBankCount

Retrieves the number of currently-loaded banks.

C
C++
C#
JS

FMOD_RESULT Studio::System::getBankCount(
  int *count
);
FMOD_RESULT FMOD_Studio_System_GetBankCount(
  FMOD_STUDIO_SYSTEM *system,
  int *count
);
RESULT Studio.System.getBankCount(
  out int count
);
Studio.System.getBankCount(
  count
);
count Out
Number of loaded banks.

May be used in conjunction with Studio::System::getBankList to enumerate the loaded banks.

Studio::System::getBankList

Retrieves a list of the currently-loaded banks.

C
C++
C#
JS

FMOD_RESULT Studio::System::getBankList(
  Studio::Bank **array,
  int capacity,
  int *count
);
FMOD_RESULT FMOD_Studio_System_GetBankList(
  FMOD_STUDIO_SYSTEM *system,
  FMOD_STUDIO_BANK **array,
  int capacity,
  int *count
);
RESULT Studio.System.getBankList(
  out Bank[] array
);
Studio.System.getBankList(
  array,
  capacity,
  count
);
array Out
Array to receive the list. (Studio::Bank)
capacity
Capacity of array.
count OutOpt
Number of banks written to array.

May be used in conjunction with Studio::System::getBankCount to enumerate the loaded banks.

Studio::System::getBufferUsage

Retrieves buffer usage information.

C
C++
C#
JS

FMOD_RESULT Studio::System::getBufferUsage(
  FMOD_STUDIO_BUFFER_USAGE *usage
);
FMOD_RESULT FMOD_Studio_System_GetBufferUsage(
  FMOD_STUDIO_SYSTEM *system,
  FMOD_STUDIO_BUFFER_USAGE *usage
);
RESULT Studio.System.getBufferUsage(
  out BUFFER_USAGE usage
);
Studio.System.getBufferUsage(
  usage
);
usage Out
Buffer usage information. (FMOD_STUDIO_BUFFER_USAGE)

Stall count and time values are cumulative. They can be reset by calling Studio::System::resetBufferUsage.

Stalls due to the studio command queue overflowing can be avoided by setting a larger command queue size with Studio::System::setAdvancedSettings.

Studio::System::getBus

Retrieves a loaded bus.

C
C++
C#
JS

FMOD_RESULT Studio::System::getBus(
  const char *path,
  Studio::Bus **bus
);
FMOD_RESULT FMOD_Studio_System_GetBus(
  FMOD_STUDIO_SYSTEM *system,
  const char *path,
  FMOD_STUDIO_BUS **bus
);
RESULT Studio.System.getBus(
  string path,
  out Bus bus
);
Studio.System.getBus(
  path,
  bus
);
path
The bus path or the ID string that identifies the bus. (UTF-8 string)
bus Out
Bus object. (Studio::Bus)

This function allows you to retrieve a handle for any bus in the global mixer.

path may be a path, such as bus:/SFX/Ambience, or an ID string, such as {d9982c58-a056-4e6c-b8e3-883854b4bffb}.

Path lookups only succeed if the strings bank is loaded.

See Also: Studio::System::getBusByID

Studio::System::getBusByID

Retrieves a loaded bus.

C
C++
C#
JS

FMOD_RESULT Studio::System::getBusByID(
  const FMOD_GUID *id,
  Studio::Bus **bus
);
FMOD_RESULT FMOD_Studio_System_GetBusByID(
  FMOD_STUDIO_SYSTEM *system,
  const FMOD_GUID *id,
  FMOD_STUDIO_BUS **bus
);
RESULT Studio.System.getBusByID(
  Guid id,
  out Bus bus
);
Studio.System.getBusByID(
  id,
  bus
);
id
Bus GUID. (FMOD_GUID)
bus Out
Bus object. (Studio::Bus)

This function allows you to retrieve a handle for any bus in the global mixer.

See Also: Studio::System::getBus

Studio::System::getCoreSystem

Retrieves the Core System.

C
C++
C#
JS

FMOD_RESULT Studio::System::getCoreSystem(
  System **system
);
FMOD_RESULT FMOD_Studio_System_GetCoreSystem(
  FMOD_STUDIO_SYSTEM *system,
  FMOD_SYSTEM **system
);
RESULT Studio.System.getCoreSystem(
  out FMOD.System system
);
Studio.System.getCoreSystem(
  system
);
system Out
Core System object. (System)

The Core System object can be retrieved before initializing the Studio System object to call additional core configuration functions.

See Also: System::setFileSystem, System::setDSPBufferSize, System::setSoftwareChannels, System::setSoftwareFormat, System::setAdvancedSettings, System::setCallback

Studio::System::getCPUUsage

Retrieves the amount of CPU used for different parts of the FMOD Engine.

C
C++
C#
JS

FMOD_RESULT Studio::System::getCPUUsage(
  FMOD_STUDIO_CPU_USAGE *usage,
  FMOD_CPU_USAGE *usage_core
);
FMOD_RESULT FMOD_Studio_System_GetCPUUsage(
  FMOD_STUDIO_SYSTEM *system,
  FMOD_STUDIO_CPU_USAGE *usage,
  FMOD_CPU_USAGE *usage_core
);
RESULT Studio.System.getCPUUsage(
  out CPU_USAGE usage,
  out FMOD.CPU_USAGE usage_core
);
Studio.System.getCPUUsage(
  usage,
  usage_core
);
usage OutOpt
Studio API performance information. (FMOD_STUDIO_CPU_USAGE)
usage_core OutOpt
Core API performance information. (FMOD_CPU_USAGE)

For readability, the percentage values are smoothed to provide a more stable output.

See Also: System::getCPUUsage

Studio::System::getEvent

Retrieves an EventDescription of an event or snapshot with the specified file path.

C
C++
C#
JS

FMOD_RESULT Studio::System::getEvent(
  const char *path,
  Studio::EventDescription **event
);
FMOD_RESULT FMOD_Studio_System_GetEvent(
  FMOD_STUDIO_SYSTEM *system,
  const char *path,
  FMOD_STUDIO_EVENTDESCRIPTION **event
);
RESULT Studio.System.getEvent(
  string path,
  out EventDescription _event
);
Studio.System.getEvent(
  path,
  event
);
path
The path or the ID string that identifies the event or snapshot. (UTF-8 string)
event Out
EventDescription object. (Studio::EventDescription)

This function allows you to retrieve a handle to any loaded event description.

path may be a path, such as event:/UI/Cancel or snapshot:/IngamePause, or an ID string, such as {2a3e48e6-94fc-4363-9468-33d2dd4d7b00}.

Path lookups only succeed if the strings bank is loaded.

See Also: Studio::parseID, Studio::System::lookupID, Studio::System::getEventByID, Studio::EventDescription::isSnapshot, Studio::EventDescription::createInstance

Studio::System::getEventByID

Retrieves an EventDescription.

C
C++
C#
JS

FMOD_RESULT Studio::System::getEventByID(
  const FMOD_GUID *id,
  Studio::EventDescription **event
);
FMOD_RESULT FMOD_Studio_System_GetEventByID(
  FMOD_STUDIO_SYSTEM *system,
  const FMOD_GUID *id,
  FMOD_STUDIO_EVENTDESCRIPTION **event
);
RESULT Studio.System.getEventByID(
  Guid id,
  out EventDescription _event
);
Studio.System.getEventByID(
  id,
  event
);
id
The event or snapshot's GUID. (FMOD_GUID)
event Out
EventDescription object. (Studio::EventDescription)

This function allows you to retrieve a handle to any loaded event description.

See Also: Studio::System::getEvent

Studio::System::getListenerAttributes

Retrieves listener 3D attributes.

C
C++
C#
JS

FMOD_RESULT Studio::System::getListenerAttributes(
  int listener,
  FMOD_3D_ATTRIBUTES *attributes,
  FMOD_VECTOR *attenuationposition = nullptr
);
FMOD_RESULT FMOD_Studio_System_GetListenerAttributes(
  FMOD_STUDIO_SYSTEM *system,
  int listener,
  FMOD_3D_ATTRIBUTES *attributes,
  FMOD_VECTOR *attenuationposition
);
RESULT Studio.System.getListenerAttributes(
  int listener,
  out _3D_ATTRIBUTES attributes
);
RESULT Studio.System.getListenerAttributes(
  int listener,
  out _3D_ATTRIBUTES attributes,
  out VECTOR attenuationposition
);
Studio.System.getListenerAttributes(
  listener,
  attributes,
  attenuationposition
);
listener
Index of listener to get 3D attributes for. Listeners are indexed from 0, to FMOD_MAX_LISTENERS - 1, in a multi-listener environment.
attributes Out
3D attributes. (FMOD_3D_ATTRIBUTES)
attenuationposition OutOpt
Position used for calculating attenuation. (FMOD_VECTOR)

See Also: Studio::EventInstance::get3DAttributes, Studio::System::getNumListeners, Studio::System::setListenerAttributes

Studio::System::getListenerWeight

Retrieves listener weighting.

C
C++
C#
JS

FMOD_RESULT Studio::System::getListenerWeight(
  int listener,
  float *weight
);
FMOD_RESULT FMOD_Studio_System_GetListenerWeight(
  FMOD_STUDIO_SYSTEM *system,
  int listener,
  float *weight
);
RESULT Studio.System.getListenerWeight(
  int listener,
  out float weight
);
Studio.System.getListenerWeight(
  listener,
  weight
);
listener
Listener index.
weight Out
Weighting value.

See Also: Studio::System::setListenerWeight, Studio::System::setNumListeners, Studio::System::getListenerAttributes

Studio::System::getMemoryUsage

Retrieves memory usage statistics.

C
C++
C#
JS

FMOD_RESULT Studio::System::getMemoryUsage(
  FMOD_STUDIO_MEMORY_USAGE *memoryusage
);
FMOD_RESULT FMOD_Studio_System_GetMemoryUsage(
  FMOD_STUDIO_SYSTEM *system,
  FMOD_STUDIO_MEMORY_USAGE *memoryusage
);
RESULT Studio.System.getMemoryUsage(
  out MEMORY_USAGE memoryusage
);

Not supported for JavaScript.

memoryusage Out
Memory usage. (FMOD_STUDIO_MEMORY_USAGE)

The memory usage sampledata value for the system is the total size of non-streaming sample data currently loaded.

Memory usage statistics are only available in logging builds, in release builds memoryusage will contain zero for all values after calling this function.

Studio::System::getNumListeners

Retrieves the number of listeners.

C
C++
C#
JS

FMOD_RESULT Studio::System::getNumListeners(
  int *numlisteners
);
FMOD_RESULT FMOD_Studio_System_GetNumListeners(
  FMOD_STUDIO_SYSTEM *system,
  int *numlisteners
);
RESULT Studio.System.getNumListeners(
  out int numlisteners
);
Studio.System.getNumListeners(
  numlisteners
);
numlisteners Out
Number of listeners.

See Also: Studio::System::setNumListeners

Studio::System::getParameterByID

Retrieves a global parameter value by unique identifier.

C
C++
C#
JS

FMOD_RESULT Studio::System::getParameterByID(
  FMOD_STUDIO_PARAMETER_ID id,
  float *value,
  float *finalvalue = nullptr
);
FMOD_RESULT FMOD_Studio_System_GetParameterByID(
  FMOD_STUDIO_SYSTEM *system,
  FMOD_STUDIO_PARAMETER_ID id,
  float *value,
  float *finalvalue
);
RESULT Studio.System.getParameterByID(
  PARAMETER_ID id,
  out float value
);
RESULT Studio.System.getParameterByID(
  PARAMETER_ID id,
  out float value,
  out float finalvalue
);
Studio.System.getParameterByID(
  id,
  value,
  finalvalue
);
id
Parameter identifier. (FMOD_STUDIO_PARAMETER_ID)
value OutOpt
Parameter value as set from the public API.
finalvalue OutOpt
Final combined value.

finalvalue is the final value of the parameter after applying adjustments due to automation, modulation, seek speed, and parameter velocity to value. This is calculated asynchronously when the Studio system updates.

See Also: Studio::System::setParameterByID

Studio::System::getParameterByName

Retrieves a global parameter value by name, including the path if needed.

C
C++
C#
JS

FMOD_RESULT Studio::System::getParameterByName(
  const char *name,
  float *value,
  float *finalvalue = nullptr
);
FMOD_RESULT FMOD_Studio_System_GetParameterByName(
  FMOD_STUDIO_SYSTEM *system,
  const char *name,
  float *value,
  float *finalvalue
);
RESULT Studio.System.getParameterByName(
  string name,
  out float value
);
RESULT Studio.System.getParameterByName(
  string name,
  out float value,
  out float finalvalue
);
Studio.System.getParameterByName(
  name,
  value,
  finalvalue
);
name
Parameter name, including the path if needed (case-insensitive). (UTF-8 string)
value OutOpt
Parameter value as set from the public API.
finalvalue OutOpt
Final combined value.

finalvalue is the final value of the parameter after applying adjustments due to automation, modulation, seek speed, and parameter velocity to value. This is calculated asynchronously when the Studio system updates.

See Also: Studio::System::setParameterByName

Studio::System::getParameterDescriptionByID

Retrieves a global parameter by ID.

C
C++
C#
JS

FMOD_RESULT Studio::System::getParameterDescriptionByID(
  FMOD_STUDIO_PARAMETER_ID id,
  FMOD_STUDIO_PARAMETER_DESCRIPTION *parameter
);
FMOD_RESULT FMOD_Studio_System_GetParameterDescriptionByID(
  FMOD_STUDIO_SYSTEM *system,
  FMOD_STUDIO_PARAMETER_ID id,
  FMOD_STUDIO_PARAMETER_DESCRIPTION *parameter
);
RESULT Studio.System.getParameterDescriptionByID(
  PARAMETER_ID id,
  out PARAMETER_DESCRIPTION parameter
);
Studio.System.getParameterDescriptionByID(
  id,
  parameter
);
id
Parameter ID. (FMOD_STUDIO_PARAMETER_ID)
parameter Out
Parameter description. (FMOD_STUDIO_PARAMETER_DESCRIPTION)

Studio::System::getParameterDescriptionByName

Retrieves a global parameter by name, including the path if needed.

C
C++
C#
JS

FMOD_RESULT Studio::System::getParameterDescriptionByName(
  const char *name,
  FMOD_STUDIO_PARAMETER_DESCRIPTION *parameter
);
FMOD_RESULT FMOD_Studio_System_GetParameterDescriptionByName(
  FMOD_STUDIO_SYSTEM *system,
  const char *name,
  FMOD_STUDIO_PARAMETER_DESCRIPTION *parameter
);
RESULT Studio.System.getParameterDescriptionByName(
  string name,
  out PARAMETER_DESCRIPTION parameter
);
Studio.System.getParameterDescriptionByName(
  name,
  parameter
);
name
Parameter name, including the path if needed (case-insensitive). (UTF-8 string)
parameter Out
Parameter description. (FMOD_STUDIO_PARAMETER_DESCRIPTION)

name can be the short name (such as 'Wind') or the full path (such as 'parameter:/Ambience/Wind'). Path lookups only succeed if the strings bank is loaded.

Studio::System::getParameterDescriptionCount

Retrieves the number of global parameters.

C
C++
C#
JS

FMOD_RESULT Studio::System::getParameterDescriptionCount(
  int *count
);
FMOD_RESULT FMOD_Studio_System_GetParameterDescriptionCount(
  FMOD_STUDIO_SYSTEM *system,
  int *count
);
RESULT Studio.System.getParameterDescriptionCount(
  out int count
);
Studio.System.getParameterDescriptionCount(
  count
);
count Out
Global parameter count.

See Also: Studio::System::getParameterDescriptionList

Studio::System::getParameterDescriptionList

Retrieves a list of global parameters.

C
C++
C#
JS

FMOD_RESULT Studio::System::getParameterDescriptionList(
  FMOD_STUDIO_PARAMETER_DESCRIPTION *array,
  int capacity,
  int *count
);
FMOD_RESULT FMOD_Studio_System_GetParameterDescriptionList(
  FMOD_STUDIO_SYSTEM *system,
  FMOD_STUDIO_PARAMETER_DESCRIPTION *array,
  int capacity,
  int *count
);
RESULT Studio.System.getParameterDescriptionList(
  out PARAMETER_DESCRIPTION[] array
);
Studio.System.getParameterDescriptionList(
  array,
  capacity,
  count
);
array Out
Global parameters. (FMOD_STUDIO_PARAMETER_DESCRIPTION)
capacity
Capacity of array.
count Out
Number of parameters written to array.

See Also: Studio::System::getParameterDescriptionCount

Studio::System::getParameterLabelByID

Retrieves a global parameter label by ID.

C
C++
C#
JS

FMOD_RESULT Studio::System::getParameterLabelByID(
  FMOD_STUDIO_PARAMETER_ID id,
  int labelindex,
  char *label,
  int size,
  int *retrieved
);
FMOD_RESULT FMOD_Studio_System_GetParameterLabelByID(
  FMOD_STUDIO_SYSTEM *system,
  FMOD_STUDIO_PARAMETER_ID id,
  int labelindex,
  char *label,
  int size,
  int *retrieved
);
RESULT Studio.System.getParameterLabelByID(
  PARAMETER_ID id,
  int labelindex,
  out string label
);
Studio.System.getParameterLabelByID(
  id,
  labelindex,
  label,
  size,
  retrieved
);
id
Parameter ID. (FMOD_STUDIO_PARAMETER_ID)
labelindex

Label index to retrieve.

label Out
Buffer to receive the label. (UTF-8 string)
size
Size of the label buffer in bytes. Must be 0 if label is null.
retrieved OutOpt
Length of the label in bytes, including the terminating null character.

If the label is longer than size then it is truncated and this function returns FMOD_ERR_TRUNCATED.

The retrieved parameter can be used to get the buffer size required to hold the full label.

Studio::System::getParameterLabelByName

Retrieves a global parameter label by name, including the path if needed.

C
C++
C#
JS

FMOD_RESULT Studio::System::getParameterLabelByName(
  const char *name,
  int labelindex,
  char *label,
  int size,
  int *retrieved
);
FMOD_RESULT FMOD_Studio_System_GetParameterLabelByName(
  FMOD_STUDIO_SYSTEM *system,
  const char *name,
  int labelindex,
  char *label,
  int size,
  int *retrieved
);
RESULT Studio.System.getParameterLabelByName(
  string name,
  int labelindex,
  out string label
);
Studio.System.getParameterLabelByName(
  name,
  labelindex,
  label,
  size,
  retrieved
);
name
Parameter name, including the path if needed (case-insensitive). (UTF-8 string)
labelindex

Label index to retrieve.

label Out
Buffer to receive the label. (UTF-8 string)
size
Size of the label buffer in bytes. Must be 0 if label is null.
retrieved OutOpt
Length of the label in bytes, including the terminating null character.

name can be the short name (such as 'Wind') or the full path (such as 'parameter:/Ambience/Wind'). Path lookups only succeed if the strings bank is loaded.

If the label is longer than size then it is truncated and this function returns FMOD_ERR_TRUNCATED.

The retrieved parameter can be used to get the buffer size required to hold the full label.

Studio::System::getSoundInfo

Retrieves information for loading a sound from the audio table.

C
C++
C#
JS

FMOD_RESULT Studio::System::getSoundInfo(
  const char *key,
  FMOD_STUDIO_SOUND_INFO *info
);
FMOD_RESULT FMOD_Studio_System_GetSoundInfo(
  FMOD_STUDIO_SYSTEM *system,
  const char *key,
  FMOD_STUDIO_SOUND_INFO *info
);
RESULT Studio.System.getSoundInfo(
  string key,
  out SOUND_INFO info
);
Studio.System.getSoundInfo(
  key,
  info
);
key
The key that identifies the sound. (UTF-8 string)
info Out
Sound loading information. (FMOD_STUDIO_SOUND_INFO)

The FMOD_STUDIO_SOUND_INFO structure contains information to be passed to System::createSound (which will create a parent sound), along with a subsound index to be passed to Sound::getSubSound once the parent sound is loaded.

The user is expected to call System::createSound with the given information. It is up to the user to combine in any desired loading flags, such as FMOD_CREATESTREAM, FMOD_CREATECOMPRESSEDSAMPLE or FMOD_NONBLOCKING with the flags in FMOD_STUDIO_SOUND_INFO::mode.

If the banks were loaded by Studio::System::loadBankMemory, the mode is returned as FMOD_OPENMEMORY_POINT. This won't work with the default FMOD_CREATESAMPLE mode. For in-memory banks, you should add in the FMOD_CREATECOMPRESSEDSAMPLE or FMOD_CREATESTREAM flag, or remove FMOD_OPENMEMORY_POINT and add FMOD_OPENMEMORY to decompress the sample into a new allocation.

Studio::System::getUserData

Retrieves the user data.

C
C++
C#
JS

FMOD_RESULT Studio::System::getUserData(
  void **userdata
);
FMOD_RESULT FMOD_Studio_System_GetUserData(
  FMOD_STUDIO_SYSTEM *system,
  void **userdata
);
RESULT Studio.System.getUserData(
  out IntPtr userdata
);
Studio.System.getUserData(
  userdata
);
userdata Out
User data set by calling Studio::System::setUserData.

This function allows arbitrary user data to be retrieved from this object. See the User Data section of the glossary for an example of how to get and set user data.

Studio::System::getVCA

Retrieves a loaded VCA.

C
C++
C#
JS

FMOD_RESULT Studio::System::getVCA(
  const char *path,
  Studio::VCA **vca
);
FMOD_RESULT FMOD_Studio_System_GetVCA(
  FMOD_STUDIO_SYSTEM *system,
  const char *path,
  FMOD_STUDIO_VCA **vca
);
RESULT Studio.System.getVCA(
  string path,
  out VCA vca
);
Studio.System.getVCA(
  path,
  vca
);
path
The path or the ID string that identifies the VCA. (UTF-8 string)
vca Out
VCA object. (Studio::VCA)

This function allows you to retrieve a handle for any VCA in the global mixer.

path may be a path, such as vca:/MyVCA, or an ID string, such as {d9982c58-a056-4e6c-b8e3-883854b4bffb}.

Path lookups only succeed if the strings bank is loaded.

See Also: Studio::System::getVCAByID

Studio::System::getVCAByID

Retrieves a loaded VCA.

C
C++
C#
JS

FMOD_RESULT Studio::System::getVCAByID(
  const FMOD_GUID *id,
  Studio::VCA **vca
);
FMOD_RESULT FMOD_Studio_System_GetVCAByID(
  FMOD_STUDIO_SYSTEM *system,
  const FMOD_GUID *id,
  FMOD_STUDIO_VCA **vca
);
RESULT Studio.System.getVCAByID(
  Guid id,
  out VCA vca
);
Studio.System.getVCAByID(
  id,
  vca
);
id
VCA GUID. (FMOD_GUID)
vca Out
VCA object. (Studio::VCA)

This function allows you to retrieve a handle for any VCA in the global mixer.

See Also: Studio::System::getVCA

Studio::System::initialize

Initializes the Studio System.

C
C++
C#
JS

FMOD_RESULT Studio::System::initialize(
  int maxchannels,
  FMOD_STUDIO_INITFLAGS studioflags,
  FMOD_INITFLAGS flags,
  void *extradriverdata
);
FMOD_RESULT FMOD_Studio_System_Initialize(
  FMOD_STUDIO_SYSTEM *system,
  int maxchannels,
  FMOD_STUDIO_INITFLAGS studioflags,
  FMOD_INITFLAGS flags,
  void *extradriverdata
);
RESULT Studio.System.initialize(
  int maxchannels,
  INITFLAGS studioflags,
  FMOD.INITFLAGS flags,
  IntPtr extradriverdata
);
Studio.System.initialize(
  maxchannels,
  studioflags,
  flags,
  extradriverdata
);
maxchannels
The maximum number of Channels, including both virtual and real, to be used in FMOD.
studioflags
Studio system initialization flags. (FMOD_STUDIO_INITFLAGS)
flags
Core system initialization flags. (FMOD_INITFLAGS)
extradriverdata Opt
Driver specific data to be passed to the output plug-in.

The core system used by the studio system is initialized at the same time as the studio system.

The flags and extradriverdata parameters are passed to System::init to initialize the core.

See Also: Creating the Studio System

Studio::System::isValid

Checks that the System reference is valid and has been initialized.

C
C++
C#
JS

bool Studio::System::isValid()
bool FMOD_Studio_System_IsValid(FMOD_STUDIO_SYSTEM *system)
bool Studio.System.isValid()
Studio.System.isValid()

Studio::System::loadBankCustom

Loads the metadata of a bank using custom read callbacks.

C
C++
C#
JS

FMOD_RESULT Studio::System::loadBankCustom(
  const FMOD_STUDIO_BANK_INFO *info,
  FMOD_STUDIO_LOAD_BANK_FLAGS flags,
  Studio::Bank **bank
);
FMOD_RESULT FMOD_Studio_System_LoadBankCustom(
  FMOD_STUDIO_SYSTEM *system,
  const FMOD_STUDIO_BANK_INFO *info,
  FMOD_STUDIO_LOAD_BANK_FLAGS flags,
  FMOD_STUDIO_BANK **bank
);
RESULT Studio.System.loadBankCustom(
  BANK_INFO info,
  LOAD_BANK_FLAGS flags,
  out Bank bank
);
Studio.System.loadBankCustom(
  info,
  flags,
  bank
);
info
Information for loading the bank. (FMOD_STUDIO_BANK_INFO)
flags
Flags to control bank loading. (FMOD_STUDIO_LOAD_BANK_FLAGS)
bank Out
Bank object. (Studio::Bank)

Sample data must be loaded separately see Sample Data Loading for details.

By default this function blocks until the load finishes, and returns the FMOD_RESULT to indicate the result. If the load fails then bank contains NULL.

Using the FMOD_STUDIO_LOAD_BANK_NONBLOCKING flag causes the bank to be loaded asynchronously. In that case, this function always returns FMOD_OK and bank contains a valid bank handle. Load errors for asynchronous banks can be detected by calling Studio::Bank::getLoadingState. Failed asynchronous banks should be released by calling Studio::Bank::unload.

If info.userdata is set but info.userdatalength is zero, info.userdata must remain valid until the bank is unloaded and each call to info.opencallback is matched by a call to info.closecallback. This requirement allows playback of shared streaming assets to continue after a bank is unloaded.

If a bank is split, separating out sample data and optionally streams from the metadata bank, all parts must be loaded before any APIs that use the data are called. We recommend you load each part one after another (the order in which they are loaded is not important), then proceed with dependent API calls such as Studio::Bank::loadSampleData or Studio::System::getEvent.

See Also: Studio::System::loadBankFile, Studio::System::loadBankMemory

Studio::System::loadBankFile

Loads the metadata of a bank. This does not load the bank's sample data.

C
C++
C#
JS

FMOD_RESULT Studio::System::loadBankFile(
  const char *filename,
  FMOD_STUDIO_LOAD_BANK_FLAGS flags,
  Studio::Bank **bank
);
FMOD_RESULT FMOD_Studio_System_LoadBankFile(
  FMOD_STUDIO_SYSTEM *system,
  const char *filename,
  FMOD_STUDIO_LOAD_BANK_FLAGS flags,
  FMOD_STUDIO_BANK **bank
);
RESULT Studio.System.loadBankFile(
  string filename,
  LOAD_BANK_FLAGS flags,
  out Bank bank
);
Studio.System.loadBankFile(
  filename,
  flags,
  bank
);
filename
Name of the file on disk. (UTF-8 string)
flags
Flags to control bank loading. (FMOD_STUDIO_LOAD_BANK_FLAGS)
bank Out
Bank object. (Studio::Bank)

Sample data must be loaded separately see Sample Data Loading for details.

By default this function blocks until the file load finishes and returns the FMOD_RESULT to indicate the result. If the load fails, then bank contains NULL.

Using the FMOD_STUDIO_LOAD_BANK_NONBLOCKING flag causes the bank to be loaded asynchronously. In that case, this function returns FMOD_OK and bank contains a valid bank handle. Load errors for asynchronous banks can be detected by calling Studio::Bank::getLoadingState. Failed asynchronous banks should be released by calling Studio::Bank::unload.

If a bank is split, separating out sample data, metadata, and optionally streams into separate .bank files, all parts of the bank must be loaded before any APIs that use the data are called. We recommend you load each part one after another (the order is not important), then proceed with dependent API calls such as Studio::Bank::loadSampleData or Studio::System::getEvent.

See Also: Studio::System::loadBankCustom, Studio::System::loadBankMemory

Studio::System::loadBankMemory

Loads the metadata of a bank from memory. Does not load the bank's sample data.

C
C++
C#
JS

FMOD_RESULT Studio::System::loadBankMemory(
  const char *buffer,
  int length,
  FMOD_STUDIO_LOAD_MEMORY_MODE mode,
  FMOD_STUDIO_LOAD_BANK_FLAGS flags,
  Studio::Bank **bank
);
FMOD_RESULT FMOD_Studio_System_LoadBankMemory(
  FMOD_STUDIO_SYSTEM *system,
  const char *buffer,
  int length,
  FMOD_STUDIO_LOAD_MEMORY_MODE mode,
  FMOD_STUDIO_LOAD_BANK_FLAGS flags,
  FMOD_STUDIO_BANK **bank
);
RESULT Studio.System.loadBankMemory(
  byte[] buffer,
  LOAD_BANK_FLAGS flags,
  out Bank bank
);
Studio.System.loadBankMemory(
  buffer,
  length,
  mode,
  flags,
  bank
);
buffer
The memory buffer.
length
The length of the memory buffer.
mode
The loading mode to use. (FMOD_STUDIO_LOAD_MEMORY_MODE)
flags
Flags to control bank loading. (FMOD_STUDIO_LOAD_BANK_FLAGS)
bank Out
The bank object. (Studio::Bank)

Sample data must be loaded separately. See the Sample Data Loading section of the Studio API Guide chapter for details.

When mode is FMOD_STUDIO_LOAD_MEMORY, the FMOD Engine allocates an internal buffer and copies the data from the passed-in buffer before using it. When used in this mode, there are no alignment restrictions on buffer, and the memory pointed to by buffer may be cleaned up at any time after this function returns.

When mode is FMOD_STUDIO_LOAD_MEMORY_POINT, the FMOD Engine uses the passed memory buffer directly. When using this mode, the buffer must be aligned to FMOD_STUDIO_LOAD_MEMORY_ALIGNMENT and the memory must persist until the bank is fully unloaded, which may not happen until some time after calling Studio::Bank::unload. You can ensure the memory is not being freed prematurely by only freeing it after receiving the FMOD_STUDIO_SYSTEM_CALLBACK_BANK_UNLOAD callback.

By default this function blocks until the load finishes and returns the FMOD_RESULT to indicate the result. If the load fails, bank contains NULL.

Using the FMOD_STUDIO_LOAD_BANK_NONBLOCKING flag causes the bank to be loaded asynchronously. In that case, this function always returns FMOD_OK and bank contains a valid bank handle. Load errors for asynchronous banks can be detected by calling Studio::Bank::getLoadingState. Failed asynchronous banks should be released by calling Studio::Bank::unload.

This function is not compatible with FMOD_STUDIO_ADVANCEDSETTINGS::encryptionkey, using them together will cause an error to be returned.

If a bank is split, separating out sample data, metadata, and optionally streams into separate .bank files, all parts of the bank must be loaded before any APIs that use the data are called. We recommend you load each part one after another (the order is not important), then proceed with dependent API calls such as Studio::Bank::loadSampleData or Studio::System::getEvent.

See Also: Studio::System::loadBankFile, Studio::System::loadBankCustom, Studio::System::setCallback

Studio::System::loadCommandReplay

Load a command replay.

C
C++
C#
JS

FMOD_RESULT Studio::System::loadCommandReplay(
  const char *filename,
  FMOD_STUDIO_COMMANDREPLAY_FLAGS flags,
  Studio::CommandReplay **replay
);
FMOD_RESULT FMOD_Studio_System_LoadCommandReplay(
  FMOD_STUDIO_SYSTEM *system,
  const char *filename,
  FMOD_STUDIO_COMMANDREPLAY_FLAGS flags,
  FMOD_STUDIO_COMMANDREPLAY **replay
);
RESULT Studio.System.loadCommandReplay(
  string filename,
  COMMANDREPLAY_FLAGS flags,
  out Studio.CommandReplay replay
);
Studio.System.loadCommandReplay(
  filename,
  flags,
  replay
);
filename
The name of the file from which to load the command replay. (UTF-8 string)
flags
Flags that control the command replay. (FMOD_STUDIO_COMMANDREPLAY_FLAGS)
replay Out
Command replay. (Studio::CommandReplay)

See Also: Studio::System::startCommandCapture, Studio::System::stopCommandCapture, Studio::CommandReplay::start, Studio::CommandReplay::stop, Studio::CommandReplay::release

Studio::System::lookupID

Retrieves the ID for a bank, event, snapshot, bus or VCA.

C
C++
C#
JS

FMOD_RESULT Studio::System::lookupID(
  const char *path,
  FMOD_GUID *id
);
FMOD_RESULT FMOD_Studio_System_LookupID(
  FMOD_STUDIO_SYSTEM *system,
  const char *path,
  FMOD_GUID *id
);
RESULT Studio.System.lookupID(
  string path,
  out Guid id
);
Studio.System.lookupID(
  path,
  id
);
path
Path. (UTF-8 string)
id Out
GUID. (FMOD_GUID)

The strings bank must be loaded prior to calling this function, otherwise FMOD_ERR_EVENT_NOTFOUND is returned.

The path can be copied to the system clipboard from FMOD Studio by using the "Copy Path" context menu command.

See Also: Studio::System::lookupPath

Studio::System::lookupPath

Retrieves the path for a bank, event, snapshot, bus or VCA.

C
C++
C#
JS

FMOD_RESULT Studio::System::lookupPath(
  const FMOD_GUID *id,
  char *path,
  int size,
  int *retrieved
);
FMOD_RESULT FMOD_Studio_System_LookupPath(
  FMOD_STUDIO_SYSTEM *system,
  const FMOD_GUID *id,
  char *path,
  int size,
  int *retrieved
);
RESULT Studio.System.lookupPath(
  Guid id,
  out string path
);
Studio.System.lookupPath(
  id,
  path,
  size,
  retrieved
);
id
The GUID. (FMOD_GUID)
path OutOpt
The buffer to receive the path. (UTF-8 string)
size
The size of the path buffer in bytes. Must be 0 if path is null.
retrieved OutOpt
The length of the path in bytes, including the terminating null character.

The strings bank must be loaded prior to calling this function, otherwise FMOD_ERR_EVENT_NOTFOUND is returned.

If the path is longer than size then it is truncated and this function returns FMOD_ERR_TRUNCATED.

The retrieved parameter can be used to get the buffer size required to hold the full path.

See Also: Studio::System::lookupID

Studio::System::registerPlugin

Registers a DSP plug-in.

C
C++
C#
JS

FMOD_RESULT Studio::System::registerPlugin(
  const FMOD_DSP_DESCRIPTION *description
);
FMOD_RESULT FMOD_Studio_System_RegisterPlugin(
  FMOD_STUDIO_SYSTEM *system,
  const FMOD_DSP_DESCRIPTION *description
);
Studio.System.registerPlugin(
  description
);

Not supported for C#.

description
The description of the DSP. (FMOD_DSP_DESCRIPTION)

DSP plug-ins used by an event must be registered using this function before loading the bank containing the event.

See Also: Studio::System::unregisterPlugin

Studio::System::release

Shut down and free the Studio System object.

C
C++
C#
JS

FMOD_RESULT Studio::System::release();
FMOD_RESULT FMOD_Studio_System_Release(FMOD_STUDIO_SYSTEM *system);
RESULT Studio.System.release();
Studio.System.release();

This function will free the memory used by the Studio System object and everything created under it.

Studio::System::create and Studio::System::release are not thread-safe. Calling either of these functions concurrently with any Studio API function (including these two functions) may cause undefined behavior. External synchronization must be used if calls to Studio::System::create or Studio::System::release could overlap other Studio API calls. All other Studio API functions are thread safe and may be called freely from any thread unless otherwise documented.

All handles or pointers to objects associated with a Studio System object become invalid when the Studio System object is released. The Studio API attempts to protect against stale handles and pointers being used with a different Studio System object but this protection cannot be guaranteed and attempting to use stale handles or pointers may cause undefined behavior.

See Also: Creating the Studio System

Studio::System::resetBufferUsage

Resets memory buffer usage statistics.

C
C++
C#
JS

FMOD_RESULT Studio::System::resetBufferUsage();
FMOD_RESULT FMOD_Studio_System_ResetBufferUsage(FMOD_STUDIO_SYSTEM *system);
RESULT Studio.System.resetBufferUsage();
Studio.System.resetBufferUsage();

This function resets the buffer usage data tracked by the Studio system.

See Also: FMOD_STUDIO_BUFFER_USAGE, Studio::System::getBufferUsage

Studio::System::setAdvancedSettings

Sets advanced settings.

C
C++
C#
JS

FMOD_RESULT Studio::System::setAdvancedSettings(
  FMOD_STUDIO_ADVANCEDSETTINGS *settings
);
FMOD_RESULT FMOD_Studio_System_SetAdvancedSettings(
  FMOD_STUDIO_SYSTEM *system,
  FMOD_STUDIO_ADVANCEDSETTINGS *settings
);
RESULT Studio.System.setAdvancedSettings(
  ADVANCEDSETTINGS settings
);

RESULT Studio.System.setAdvancedSettings(
  ADVANCEDSETTINGS settings,
  String encryptionkey
);
Studio.System.setAdvancedSettings(
  settings
);
settings
The Studio system's advanced settings. (FMOD_STUDIO_ADVANCEDSETTINGS)
encryptionkey C#
The key for loading sounds from encrypted banks. (UTF-8 string)

This function must be called prior to Studio system initialization.

Use the overloaded function to provide a C# string rather than directly setting ADVANCEDSETTINGS.encryptionkey.

See Also: Studio::System::getAdvancedSettings, Studio::System::initialize

Studio::System::setCallback

Sets a callback for the Studio System.

C
C++
C#
JS

FMOD_RESULT Studio::System::setCallback(
  FMOD_STUDIO_SYSTEM_CALLBACK callback,
  FMOD_STUDIO_SYSTEM_CALLBACK_TYPE callbackmask = FMOD_STUDIO_SYSTEM_CALLBACK_ALL
);
FMOD_RESULT FMOD_Studio_System_SetCallback(
  FMOD_STUDIO_SYSTEM *system,
  FMOD_STUDIO_SYSTEM_CALLBACK callback,
  FMOD_STUDIO_SYSTEM_CALLBACK_TYPE callbackmask
);
RESULT Studio.System.setCallback(
  SYSTEM_CALLBACK callback,
  SYSTEM_CALLBACK_TYPE callbackmask = SYSTEM_CALLBACK_TYPE.ALL
);
Studio.System.setCallback(
  callback,
  callbackmask
);
callback
System callback function. (FMOD_STUDIO_SYSTEM_CALLBACK)
callbackmask
A bitfield specifying which callback types are required. Defaults to FMOD_STUDIO_SYSTEM_CALLBACK_ALL. (FMOD_STUDIO_SYSTEM_CALLBACK_TYPE)

The system callback function is called for a variety of reasons, use the callbackmask to choose which callbacks you are interested in.

Callbacks are called from the Studio Update Thread in default / async mode and the main (calling) thread in synchronous mode. See the FMOD_STUDIO_SYSTEM_CALLBACK_TYPE for details.

See Also: Callback Behavior, Studio::System::setUserData

Studio::System::setListenerAttributes

Sets the 3D attributes of the listener.

C
C++
C#
JS

FMOD_RESULT Studio::System::setListenerAttributes(
  int listener,
  const FMOD_3D_ATTRIBUTES *attributes,
  const FMOD_VECTOR *attenuationposition = nullptr
);
FMOD_RESULT FMOD_Studio_System_SetListenerAttributes(
  FMOD_STUDIO_SYSTEM *system,
  int listener,
  const FMOD_3D_ATTRIBUTES *attributes,
  const FMOD_VECTOR *attenuationposition
);
RESULT Studio.System.setListenerAttributes(
  int listener,
  _3D_ATTRIBUTES attributes
);
RESULT Studio.System.setListenerAttributes(
  int listener,
  _3D_ATTRIBUTES attributes,
  VECTOR attenuationposition
);
Studio.System.setListenerAttributes(
  listener,
  attributes,
  attenuationposition
);
listener
Index of listener to set 3D attributes on. Listeners are indexed from 0, to FMOD_MAX_LISTENERS - 1, in a multi-listener environment.
attributes
3D attributes. (FMOD_3D_ATTRIBUTES)
attenuationposition Opt
Position used for calculating attenuation. (FMOD_VECTOR)

Passing NULL for attenuationposition will result in the listener only using the position in attributes.

See Also: Studio::System::getListenerAttributes

Studio::System::setListenerWeight

Sets the listener weighting.

C
C++
C#
JS

FMOD_RESULT Studio::System::setListenerWeight(
  int listener,
  float weight
);
FMOD_RESULT FMOD_Studio_System_SetListenerWeight(
  FMOD_STUDIO_SYSTEM *system,
  int listener,
  float weight
);
RESULT Studio.System.setListenerWeight(
  int listener,
  float weight
);
Studio.System.setListenerWeight(
  listener,
  weight
);
listener
Listener index.
weight

Weighting value.

  • Range: [0, 1]
  • Default: 1

Listener weighting is a factor which determines how much the listener influences the mix. It is taken into account for 3D panning, doppler, and the automatic distance event parameter. A listener with a weight of 0 has no effect on the mix.

Listener weighting can be used to fade in and out multiple listeners. For example to do a crossfade, an additional listener can be created with a weighting of 0 that ramps up to 1 while the old listener weight is ramped down to 0. After the crossfade is finished the number of listeners can be reduced to 1 again.

The sum of all the listener weights should add up to at least 1. It is a user error to set all listener weights to 0.

See Also: Studio::System::getListenerWeight, Studio::System::setNumListeners

Studio::System::setNumListeners

Sets the number of listeners in the 3D sound scene.

C
C++
C#
JS

FMOD_RESULT Studio::System::setNumListeners(
  int numlisteners
);
FMOD_RESULT FMOD_Studio_System_SetNumListeners(
  FMOD_STUDIO_SYSTEM *system,
  int numlisteners
);
RESULT Studio.System.setNumListeners(
  int numlisteners
);
Studio.System.setNumListeners(
  numlisteners
);
numlisteners

Number of listeners.

If the number of listeners is set to more than 1 then FMOD uses a 'closest sound to the listener' method to determine what should be heard.

See the Studio 3D Events white paper for more information.

See Also: Studio::System::getNumListeners, Studio::System::setListenerAttributes, Studio::System::setListenerWeight

Studio::System::setParameterByID

Sets a global parameter value by unique identifier.

C
C++
C#
JS

FMOD_RESULT Studio::System::setParameterByID(
  FMOD_STUDIO_PARAMETER_ID id,
  float value,
  bool ignoreseekspeed = false
);
FMOD_RESULT FMOD_Studio_System_SetParameterByID(
  FMOD_STUDIO_SYSTEM *system,
  FMOD_STUDIO_PARAMETER_ID id,
  float value,
  FMOD_BOOL ignoreseekspeed
);
RESULT Studio.System.setParameterByID(
  PARAMETER_ID id,
  float value,
  bool ignoreseekspeed = false
);
Studio.System.setParameterByID(
  id,
  value,
  ignoreseekspeed
);
id
Parameter identifier. (FMOD_STUDIO_PARAMETER_ID)
value
Value for given identifier.
ignoreseekspeed

Specifies whether to ignore the parameter's seek speed and set the value immediately.

  • Units: Boolean

See Also: Studio::System::setParameterByName, Studio::System::setParametersByIDs, Studio::System::getParameterByID, Studio::System::getParameterByName

Studio::System::setParameterByIDWithLabel

Sets a global parameter value by unique identifier, looking up the value label.

C
C++
C#
JS

FMOD_RESULT Studio::System::setParameterByIDWithLabel(
  FMOD_STUDIO_PARAMETER_ID id,
  const char *label,
  bool ignoreseekspeed = false
);
FMOD_RESULT FMOD_Studio_System_SetParameterByIDWithLabel(
  FMOD_STUDIO_SYSTEM *system,
  FMOD_STUDIO_PARAMETER_ID id,
  const char *label,
  FMOD_BOOL ignoreseekspeed
);
RESULT Studio.System.setParameterByIDWithLabel(
  PARAMETER_ID id,
  string label,
  bool ignoreseekspeed = false
);
Studio.System.setParameterByIDWithLabel(
  id,
  label,
  ignoreseekspeed
);
id
Parameter identifier. (FMOD_STUDIO_PARAMETER_ID)
label
Labeled value for given identifier.
ignoreseekspeed
Specifies whether to ignore the parameter's seek speed and set the value immediately.

If the specified label is not found, FMOD_ERR_EVENT_NOTFOUND is returned. This lookup is case sensitive.

See Also: Studio::System::setParameterByName, Studio::System::setParametersByIDs, Studio::System::getParameterByID, Studio::System::getParameterByName

Studio::System::setParameterByName

Sets a global parameter value by name, including the path if needed.

C
C++
C#
JS

FMOD_RESULT Studio::System::setParameterByName(
  const char *name,
  float value,
  bool ignoreseekspeed = false
);
FMOD_RESULT FMOD_Studio_System_SetParameterByName(
  FMOD_STUDIO_SYSTEM *system,
  const char *name,
  float value,
  FMOD_BOOL ignoreseekspeed
);
RESULT Studio.System.setParameterByName(
  string name,
  float value,
  bool ignoreseekspeed = false
);
Studio.System.setParameterByName(
  name,
  value,
  ignoreseekspeed
);
name
Parameter name, including the path if needed (case-insensitive). (UTF-8 string)
value
Value for given name.
ignoreseekspeed

Specifies whether to ignore the parameter's seek speed and set the value immediately.

  • Units: Boolean

See Also: Studio::System::setParameterByID, Studio::System::setParametersByIDs, Studio::System::getParameterByID, Studio::System::getParameterByName

Studio::System::setParameterByNameWithLabel

Sets a global parameter value by name, including the path if needed, looking up the value label.

C
C++
C#
JS

FMOD_RESULT Studio::System::setParameterByNameWithLabel(
  const char *name,
  const char *label,
  bool ignoreseekspeed = false
);
FMOD_RESULT FMOD_Studio_System_SetParameterByNameWithLabel(
  FMOD_STUDIO_SYSTEM *system,
  const char *name,
  const char *label,
  FMOD_BOOL ignoreseekspeed
);
RESULT Studio.System.setParameterByNameWithLabel(
  string name,
  string label,
  bool ignoreseekspeed = false
);
Studio.System.setParameterByNameWithLabel(
  name,
  label,
  ignoreseekspeed
);
name
Parameter name, including the path if needed (case-insensitive). (UTF-8 string)
label
Labeled value for given name.
ignoreseekspeed
Specifies whether to ignore the parameter's seek speed and set the value immediately.

If the specified label is not found, FMOD_ERR_EVENT_NOTFOUND is returned. This lookup is case sensitive.

See Also: Studio::System::setParameterByID, Studio::System::setParametersByIDs, Studio::System::getParameterByID, Studio::System::getParameterByName

Studio::System::setParametersByIDs

Sets multiple global parameter values by unique identifier.

C
C++
C#
JS

FMOD_RESULT Studio::System::setParametersByIDs(
  const FMOD_STUDIO_PARAMETER_ID *ids,
  float *values,
  int count,
  bool ignoreseekspeed = false
);
FMOD_RESULT FMOD_Studio_System_SetParametersByIDs(
  FMOD_STUDIO_SYSTEM *system,
  const FMOD_STUDIO_PARAMETER_ID *ids,
  float *values,
  int count,
  FMOD_BOOL ignoreseekspeed
);
RESULT Studio.System.setParametersByIDs(
  PARAMETER_ID[] ids,
  float[] values,
  int count,
  bool ignoreseekspeed = false
);
Studio.System.setParametersByIDs(
  ids,
  values,
  count,
  ignoreseekspeed
);
ids
Array of parameter identifiers. (FMOD_STUDIO_PARAMETER_ID)
values
Array of values for each given identifier.
count

Number of items in the given arrays.

  • Range: [1, 32]
ignoreseekspeed

Specifies whether to ignore the parameter's seek speed and set the value immediately.

  • Units: Boolean

If any ID is set to all zeroes then the corresponding value will be ignored.

See Also: Studio::System::setParameterByID, Studio::System::setParameterByName, Studio::System::getParameterByID, Studio::System::getParameterByName

Studio::System::setUserData

Sets the user data.

C
C++
C#
JS

FMOD_RESULT Studio::System::setUserData(
  void *userdata
);
FMOD_RESULT FMOD_Studio_System_SetUserData(
  FMOD_STUDIO_SYSTEM *system,
  void *userdata
);
RESULT Studio.System.setUserData(
  IntPtr userdata
);
Studio.System.setUserData(
  userdata
);
userdata
User data to store within the system.

This function allows arbitrary user data to be attached to this object, which wll be passed through the userdata parameter in any FMOD_STUDIO_SYSTEM_CALLBACKs. See the User Data section of the glossary for an example of how to get and set user data.

See Also: Studio::System::getUserData, Studio::System::setCallback

Studio::System::startCommandCapture

Start recording Studio API commands to a file.

C
C++
C#
JS

FMOD_RESULT Studio::System::startCommandCapture(
  const char *filename,
  FMOD_STUDIO_COMMANDCAPTURE_FLAGS flags
);
FMOD_RESULT FMOD_Studio_System_StartCommandCapture(
  FMOD_STUDIO_SYSTEM *system,
  const char *filename,
  FMOD_STUDIO_COMMANDCAPTURE_FLAGS flags
);
RESULT Studio.System.startCommandCapture(
  string filename,
  COMMANDCAPTURE_FLAGS flags
);
Studio.System.startCommandCapture(
  filename,
  flags
);
filename
The name of the file to which the recorded commands are to be written. (UTF-8 string)
flags
Flags that control command capturing. (FMOD_STUDIO_COMMANDCAPTURE_FLAGS)

Commands generated by the Studio API can be captured and later replayed for debugging and profiling purposes.

Unless the FMOD_STUDIO_COMMANDCAPTURE_SKIP_INITIAL_STATE flag is specified, the command capture first records the set of all banks and event instances that currently exist.

See Also: Studio::System::stopCommandCapture, Studio::System::loadCommandReplay

Studio::System::stopCommandCapture

Stop recording Studio API commands.

C
C++
C#
JS

FMOD_RESULT Studio::System::stopCommandCapture();
FMOD_RESULT FMOD_Studio_System_StopCommandCapture(FMOD_STUDIO_SYSTEM *system);
RESULT Studio.System.stopCommandCapture();
Studio.System.stopCommandCapture();

See Also: Studio::System::startCommandCapture, Studio::System::loadCommandReplay

Studio::System::unloadAll

Unloads all currently loaded banks.

C
C++
C#
JS

FMOD_RESULT Studio::System::unloadAll();
FMOD_RESULT FMOD_Studio_System_UnloadAll(FMOD_STUDIO_SYSTEM *system);
RESULT Studio.System.unloadAll();
Studio.System.unloadAll();

See Also: Studio::System::loadBankFile, Studio::System::loadBankMemory, Studio::System::loadBankCustom

Studio::System::unregisterPlugin

Unregisters a DSP plug-in.

C
C++
C#
JS

FMOD_RESULT Studio::System::unregisterPlugin(
  const char *name
);
FMOD_RESULT FMOD_Studio_System_UnregisterPlugin(
  FMOD_STUDIO_SYSTEM *system,
  const char *name
);
Studio.System.unregisterPlugin(
  name
);

Not supported for C#.

name
The name of the DSP. This must match the description passed to Studio::System::registerPlugin.

See Also: Studio::System::registerPlugin

Studio::System::update

Update the studio system.

C
C++
C#
JS

FMOD_RESULT Studio::System::update();
FMOD_RESULT FMOD_Studio_System_Update(FMOD_STUDIO_SYSTEM *system);
RESULT Studio.System.update();
Studio.System.update();

When Studio is initialized in the default asynchronous processing mode this function submits all buffered commands for execution on the Studio Update thread for asynchronous processing. This is a fast operation since the commands are not processed on the calling thread. If Studio is initialized with FMOD_STUDIO_INIT_DEFERRED_CALLBACKS then any deferred callbacks fired during any asynchronous updates since the last call to this function will be called. If an error occurred during any asynchronous updates since the last call to this function then this function will return the error result.

When Studio is initialized with FMOD_STUDIO_INIT_SYNCHRONOUS_UPDATE queued commands will be processed immediately when calling this function, the scheduling and update logic for the Studio system are executed and all callbacks are fired. This may block the calling thread for a substantial amount of time.

See Also: Studio System Processing