FMOD Studio

https://fmod.com/docs/2.03/
Admin
FMOD Studio is an intuitive audio middleware solution for game developers to design adaptive audio,...
Tokens:525,588
Snippets:6,199
Trust Score:9.2
Update:2 months ago
Show doc for...
Tokens:
Raw
### Dynamic Plugin File Path Example

Source: https://fmod.com/docs/2.03/unreal/plugins.html

Example path for placing a dynamic plugin file in the project's binary directory for Win64 builds.

```text
FMODStudio/Binaries/Win64/fmod_gain.dll

```

--------------------------------

### Start playback with Play

Source: https://fmod.com/docs/2.03/unity/api-studioeventemitter.html

Creates and starts the FMOD Studio event instance.

```C#
void Play();
```

--------------------------------

### Toggle Setup Wizard Visibility

Source: https://fmod.com/docs/2.03/unity/api-settings.html

Determines whether the Setup Wizard is hidden.

```C#
bool HideSetupWizard;
```

--------------------------------

### Load Bank and Start Event

Source: https://fmod.com/docs/2.03/api/studio-guide.html

Loads a localized bank file and sets the dialogue key before starting the event instance.

```cpp
// Available banks
// "Dialogue_EN.bank", "Dialogue_JP.bank", "Dialogue_CN.bank"
FMOD::Studio::Bank* localizedBank = NULL;
system->loadBankFile(Common_MediaPath("Dialogue_JP.bank"), FMOD_STUDIO_LOAD_BANK_NORMAL, &localizedBank);
programmerSoundContext.dialogueString = "welcome";
eventInstance->start();
```

--------------------------------

### Studio::EventInstance::start

Source: https://fmod.com/docs/2.03/api/studio-api-eventinstance.html

Starts playback of the event instance.

```APIDOC
## Studio::EventInstance::start

### Description
Starts playback of the event instance. If the instance is already playing, it will be restarted.
```

--------------------------------

### Stereo Speaker Configuration

Source: https://fmod.com/docs/2.03/api/core-api-system.html

Example usage for configuring a standard stereo speaker setup.

```C
FMOD_System_SetSpeakerPosition(system, FMOD_SPEAKER_FRONT_LEFT, -1.0f,  0.0f, 1);
FMOD_System_SetSpeakerPosition(system, FMOD_SPEAKER_FRONT_RIGHT, 1.0f,  0.0f, 1);
```

```C++
system->setSpeakerPosition(FMOD_SPEAKER_FRONT_LEFT, -1.0f,  0.0f, true);
system->setSpeakerPosition(FMOD_SPEAKER_FRONT_RIGHT, 1.0f,  0.0f, true);
```

--------------------------------

### Configure SVN service with IPv6 preference

Source: https://fmod.com/docs/2.03/studio/using-source-control.html

Example command for starting the svnserve service with the --prefer-ipv6 flag to improve connection performance.

```bash
"C:\Program Files\TortoiseSVN\bin\svnserve.exe" --prefer-ipv6 --service -r E:\SVN\Repository
```

--------------------------------

### Studio::System::startCommandCapture

Source: https://fmod.com/docs/2.03/api/studio-api-system.html

Starts recording Studio API commands to a file.

```APIDOC
## Studio::System::startCommandCapture

### Description
Starts recording Studio API commands to a file for later replay.

### Method
Method

### Signature
Studio::System::startCommandCapture(const char *path, FMOD_STUDIO_COMMANDCAPTURE_FLAGS flags)
```

--------------------------------

### 7.1 Speaker Configuration

Source: https://fmod.com/docs/2.03/api/core-api-system.html

Example usage for configuring a 7.1 surround sound speaker setup using trigonometric positioning.

```C
FMOD_System_SetSpeakerPosition(system, FMOD_SPEAKER_FRONT_LEFT,     sin(degtorad( -30)), cos(degtorad( -30)), 1);
FMOD_System_SetSpeakerPosition(system, FMOD_SPEAKER_FRONT_RIGHT,    sin(degtorad(  30)), cos(degtorad(  30)), 1);
FMOD_System_SetSpeakerPosition(system, FMOD_SPEAKER_FRONT_CENTER,   sin(degtorad(   0)), cos(degtorad(   0)), 1);
FMOD_System_SetSpeakerPosition(system, FMOD_SPEAKER_LOW_FREQUENCY,  sin(degtorad(   0)), cos(degtorad(   0)), 1);
FMOD_System_SetSpeakerPosition(system, FMOD_SPEAKER_SURROUND_LEFT,  sin(degtorad( -90)), cos(degtorad( -90)), 1);
FMOD_System_SetSpeakerPosition(system, FMOD_SPEAKER_SURROUND_RIGHT, sin(degtorad(  90)), cos(degtorad(  90)), 1);
FMOD_System_SetSpeakerPosition(system, FMOD_SPEAKER_BACK_LEFT,      sin(degtorad(-150)), cos(degtorad(-150)), 1);
FMOD_System_SetSpeakerPosition(system, FMOD_SPEAKER_BACK_RIGHT,     sin(degtorad( 150)), cos(degtorad( 150)), 1);
```

```C++
system->setSpeakerPosition(FMOD_SPEAKER_FRONT_LEFT,     sin(degtorad( -30)), cos(degtorad( -30)), true);
system->setSpeakerPosition(FMOD_SPEAKER_FRONT_RIGHT,    sin(degtorad(  30)), cos(degtorad(  30)), true);
system->setSpeakerPosition(FMOD_SPEAKER_FRONT_CENTER,   sin(degtorad(   0)), cos(degtorad(   0)), true);
system->setSpeakerPosition(FMOD_SPEAKER_LOW_FREQUENCY,  sin(degtorad(   0)), cos(degtorad(   0)), true);
system->setSpeakerPosition(FMOD_SPEAKER_SURROUND_LEFT,  sin(degtorad( -90)), cos(degtorad( -90)), true);
system->setSpeakerPosition(FMOD_SPEAKER_SURROUND_RIGHT, sin(degtorad(  90)), cos(degtorad(  90)), true);
system->setSpeakerPosition(FMOD_SPEAKER_BACK_LEFT,      sin(degtorad(-150)), cos(degtorad(-150)), true);
system->setSpeakerPosition(FMOD_SPEAKER_BACK_RIGHT,     sin(degtorad( 150)), cos(degtorad( 150)), true);
```

--------------------------------

### System::recordStart

Source: https://fmod.com/docs/2.03/api/core-api-system.html

Starts the recording engine recording to a pre-created Sound object.

```APIDOC
## System::recordStart

### Description
Starts the recording engine recording to a pre-created Sound object.
```

--------------------------------

### StudioEventEmitter::Play

Source: https://fmod.com/docs/2.03/unity/api-studioeventemitter.html

Starts the event instance.

```APIDOC
## StudioEventEmitter::Play

### Description
Creates and starts the FMOD.Studio.EventInstance.

### Signature
`void Play();`
```

--------------------------------

### Define FMOD_OUTPUT_START_CALLBACK

Source: https://fmod.com/docs/2.03/api/plugin-api-output.html

Callback invoked to start the output driver's audio stream. Use this for starting audio rather than memory allocation.

```C
FMOD_RESULT F_CALL FMOD_OUTPUT_START_CALLBACK(
  FMOD_OUTPUT_STATE *output_state
);
```

--------------------------------

### Event.returnToStart

Source: https://fmod.com/docs/2.03/studio/scripting-api-reference-project-model-event.html

Moves the playback position to the cursor position or the start of the timeline.

```APIDOC
## Event.returnToStart

### Description
Moves the playback position to the cursor position if called while the event instance is playing, stopping, or paused, or to the start of the timeline while the event instance is stopped.

### Signature
`Event.returnToStart()`
```

--------------------------------

### IsAvailable

Source: https://fmod.com/docs/2.03/unreal/api-reference-ifmodstudiomodule.html

Verifies if the module is loaded and ready for use before calling Get().

```cpp
bool IsAvailable()
```

--------------------------------

### EventInstancePlay

Source: https://fmod.com/docs/2.03/unreal/blueprint-reference-eventinstance.html

Starts playback of an FMOD Event Instance.

```APIDOC
## EventInstancePlay

### Description
Play an FMOD Event Instance.

### Signature
`static void EventInstancePlay(FFMODEventInstance EventInstance);`

### Parameters
- **EventInstance** (FFMODEventInstance) - The instance to play.
```

--------------------------------

### Initialize Reverb Properties

Source: https://fmod.com/docs/2.03/api/core-api-system.html

Example of using a preset to initialize an FMOD_REVERB_PROPERTIES structure.

```C
FMOD_REVERB_PROPERTIES prop = FMOD_PRESET_GENERIC;
```

--------------------------------

### CreateInstance

Source: https://fmod.com/docs/2.03/unity/api-runtimemanager.html

Creates a new FMOD.Studio.EventInstance from a path, GUID, or EventReference.

```APIDOC
## static FMOD.Studio.EventInstance CreateInstance(string path)
## static FMOD.Studio.EventInstance CreateInstance(Guid guid)
## static FMOD.Studio.EventInstance CreateInstance(EventReference eventReference)

### Description
Create a new FMOD.Studio.EventInstance. The instance will be in the stopped state. It is the caller's responsibility to call Release on the instance when finished.

### Parameters
- **path** (string) - Full event path (e.g., event:/Music/Level1)
- **guid** (Guid) - GUID of the event to create
- **eventReference** (EventReference) - Event reference of the event to create
```

--------------------------------

### Studio::System::initialize

Source: https://fmod.com/docs/2.03/api/studio-api-system.html

Initializes the Studio System.

```APIDOC
## Studio::System::initialize

### Description
Initializes the Studio System.
```

--------------------------------

### Get UE GUID from FMOD instance

Source: https://fmod.com/docs/2.03/unreal/api-reference-common.html

Retrieves the Unreal FGuid associated with an FMOD instanced object.

```C++
FGuid GetID(
    StudioType *Instance
);
```

--------------------------------

### Start recording with System::recordStart

Source: https://fmod.com/docs/2.03/api/core-api-system.html

Initiates recording to a pre-created Sound object. Requires the sound to be created as FMOD_CREATESAMPLE.

```cpp
FMOD_RESULT System::recordStart(
  int id,
  Sound *sound,
  bool loop
);
```

```c
FMOD_RESULT FMOD_System_RecordStart(
  FMOD_SYSTEM *system,
  int id,
  FMOD_SOUND *sound,
  FMOD_BOOL loop
);
```

```csharp
RESULT System.recordStart(
  int id,
  Sound sound,
  bool loop
);
```

```javascript
System.recordStart(
  id,
  sound,
  loop
);
```

--------------------------------

### System Setup

Source: https://fmod.com/docs/2.03/api/core-api-system.html

Methods for configuring the software mixer, buffer sizes, and 3D audio parameters.

```APIDOC
## System Setup

### Description
These methods configure the software mixing engine, including channel counts, buffer sizes, speaker positions, and 3D audio settings.

### Methods
- **System::setSoftwareChannels / getSoftwareChannels**: Manage maximum software mixed channels.
- **System::setSoftwareFormat / getSoftwareFormat**: Configure the software mixer output format.
- **System::setDSPBufferSize / getDSPBufferSize**: Configure the software mixing engine buffer size.
- **System::set3DSettings / get3D3DSettings**: Configure global 3D audio parameters like doppler scale and distance factor.
- **System::set3DNumListeners / get3DNumListeners**: Manage the number of 3D listeners in the scene.
```

--------------------------------

### System::init

Source: https://fmod.com/docs/2.03/api/core-api-system.html

Initializes the system object and prepares FMOD for playback.

```APIDOC
## System::init

### Description
Initialize the system object and prepare FMOD for playback. A system object must be created with System_create before calling this method.

### Parameters
- **maxchannels** (int) - Required - Maximum number of Channel objects available for playback (Range: [0, 4095]).
- **flags** (FMOD_INITFLAGS) - Required - Initialization flags.
- **extradriverdata** (void*) - Optional - Additional output specific initialization data.
```

--------------------------------

### Retrieve EventDescription by GUID

Source: https://fmod.com/docs/2.03/api/studio-api-system.html

Retrieves an event or snapshot description using its unique GUID.

```cpp
FMOD_RESULT Studio::System::getEventByID(
  const FMOD_GUID *id,
  Studio::EventDescription **event
);
```

```c
FMOD_RESULT FMOD_Studio_System_GetEventByID(
  FMOD_STUDIO_SYSTEM *system,
  const FMOD_GUID *id,
  FMOD_STUDIO_EVENTDESCRIPTION **event
);
```

```csharp
RESULT Studio.System.getEventByID(
  Guid id,
  out EventDescription _event
);
```

```javascript
Studio.System.getEventByID(
  id,
  event
);
```

--------------------------------

### Legacy EventRef Field Example

Source: https://fmod.com/docs/2.03/unity/tools.html

Example of a component using the legacy [FMODUnity.EventRef] attribute before migration.

```csharp
public class EventTrigger : MonoBehaviour
{
    [FMODUnity.EventRef]
    public string EventPath;

    // (remainder of class removed for brevity)
}
```

--------------------------------

### Implement DSP Process Callback

Source: https://fmod.com/docs/2.03/api/plugin-api-dsp.html

Example implementations showing how to process audio buffers at half volume, handling both query and perform operations.

```C
FMOD_RESULT F_CALL Process(FMOD_DSP_STATE *dsp_state, unsigned int length, const FMOD_DSP_BUFFER_ARRAY *inbufferarray, FMOD_DSP_BUFFER_ARRAY *outbufferarray, FMOD_BOOL inputsidle, FMOD_DSP_PROCESS_OPERATION op)
{
    if (op == FMOD_DSP_PROCESS_QUERY)
    {
        if (outbufferarray && inbufferarray)
        {
            if (outbufferarray[0].buffernumchannels[0] != inbufferarray[0].buffernumchannels[0])
            {
                FMOD_ERR_DSP_SILENCE;
            }
        }
        if (inputsidle)
        {
            return FMOD_ERR_DSP_DONTPROCESS;
        }
    }
    else
    {
        int numchannels = outbufferarray[0].buffernumchannels[0];
        float *input = inbufferarray[0].buffers[0];
        float *output = outbufferarray[0].buffers[0];

        for (unsigned int sample = 0; sample < length; sample++)
        {
            for (int channel = 0; channel < numchannels; channel++)
            {
                output[sample * numchannels + channel] = input[sample * numchannels + channel] * 0.5f;
            }
        }
    }

    return FMOD_OK;
}
```

```C#
[AOT.MonoPInvokeCallback(typeof(FMOD.DSP_PROCESS_CALLBACK))]
static RESULT Process(ref DSP_STATE dsp_state, uint length, ref DSP_BUFFER_ARRAY inbufferarray, ref DSP_BUFFER_ARRAY outbufferarray, bool inputsidle, DSP_PROCESS_OPERATION op)
{
    if (op == DSP_PROCESS_OPERATION.PROCESS_QUERY)
    {
        if (inbufferarray.numchannels != outbufferarray.numchannels)
        {
            return RESULT.ERR_DSP_SILENCE;
        }
        if (inputsidle)
        {
            return RESULT.ERR_DSP_DONTPROCESS;
        }
    }
    else if (op == DSP_PROCESS_OPERATION.PROCESS_PERFORM)
    {
        int numchannels = outbufferarray.numchannels;
        float[] input = new float[length * numchannels];
        float[] output = new float[length * numchannels];

        Marshal.Copy(inbufferarray.buffer, input, 0, (int)length * numchannels);

        for (int sample = 0; sample < length; sample++)
        {
            for (int channel = 0; channel < numchannels; channel++)
            {
                output[sample * numchannels + channel] = input[sample * numchannels + channel] * 0.5f;
            }
        }

        Marshal.Copy(output, 0, outbufferarray.buffer, (int)length * numchannels);
    }

    return RESULT.OK;
}
```

--------------------------------

### Get Music Speed

Source: https://fmod.com/docs/2.03/api/core-api-sound.html

Gets the relative playback speed of MOD, S3M, XM, IT, or MIDI music.

```C++
FMOD_RESULT Sound::getMusicSpeed(
  float *speed
);
```

```C
FMOD_RESULT FMOD_Sound_GetMusicSpeed(
  FMOD_SOUND *sound,
  float *speed
);
```

```C#
RESULT Sound.getMusicSpeed(
  out float speed
);
```

```JavaScript
Sound.getMusicSpeed(
  speed
);
```

--------------------------------

### Convert Path to GUID

Source: https://fmod.com/docs/2.03/unity/api-runtimemanager.html

Retrieves the GUID associated with a specific event path. Requires the strings bank to be loaded.

```C#
static Guid PathToGUID(
  string path
);
```

--------------------------------

### Create Studio System

Source: https://fmod.com/docs/2.03/api/studio-api-system.html

Initializes the Studio System object. Ensure FMOD_VERSION is passed to headerversion to maintain compatibility.

```C++
static FMOD_RESULT Studio::System::create(
  Studio::System **system,
  unsigned int headerversion = FMOD_VERSION
);
```

```C
FMOD_RESULT FMOD_Studio_System_Create(
  FMOD_STUDIO_SYSTEM **system,
  unsigned int headerversion
);
```

```C#
static RESULT Studio.System.create(
  out System system
);
```

```JS
static Studio_System_Create(
  system
);
```

--------------------------------

### Parse GUID from string

Source: https://fmod.com/docs/2.03/api/studio-api-common.html

Parses a GUID from a string formatted as 32 digits separated by hyphens and enclosed in braces.

```C++
FMOD_RESULT Studio::parseID(
  const char *idstring,
  FMOD_GUID *id
);
```

```C
FMOD_RESULT FMOD_Studio_ParseID(
  const char *idstring,
  FMOD_GUID *id
);
```

```C#
static RESULT Studio.Util.parseID(
  string idstring,
  out Guid id
);
```

--------------------------------

### Studio::System::create

Source: https://fmod.com/docs/2.03/api/studio-api-system.html

Creates the studio system object.

```APIDOC
## Studio::System::create

### Description
Creates the studio system object. Initializing the studio system object also initializes the core System object.
```

--------------------------------

### Create a sound with manual sample data

Source: https://fmod.com/docs/2.03/api/loading-and-playing-sounds-in-the-core-api.html

Configures FMOD_CREATESOUNDEXINFO to define audio properties and initializes a sound with FMOD_OPENUSER.

```cpp
FMOD::Sound *sound;
FMOD_CREATESOUNDEXINFO exinfo;

// Create extended sound info struct
memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
exinfo.cbsize           = sizeof(FMOD_CREATESOUNDEXINFO);   // Size of the struct
exinfo.numchannels      = 2;                                // Number of channels in the sound
exinfo.defaultfrequency = 44100;                            // Default playback rate of sound
exinfo.length           = exinfo.defaultfrequency * exinfo.numchannels * sizeof(signed short) * 5;   // Length of sound - PCM data in bytes. 5 = seconds
exinfo.format           = FMOD_SOUND_FORMAT_PCM16;          // Data format of sound
exinfo.pcmreadcallback  = MyReadCallbackFunction;           // To read sound data, you must specify a read callback using the pcmreadcallback field
// Alternatively, use Sound::lock and Sound::unlock to submit sample data to the sound when playing it back

// As sample data is being loaded via callback or Sound::lock and Sound::unlock, pass null or equivalent as first argument
system->createSound(0, FMOD_OPENUSER, &exinfo, &sound);
```

```c
FMOD_Sound *sound;
FMOD_CREATESOUNDEXINFO exinfo;

// Create extended sound info struct
memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
exinfo.cbsize           = sizeof(FMOD_CREATESOUNDEXINFO);   // Size of the struct
exinfo.numchannels      = 2;                                // Number of channels in the sound
exinfo.defaultfrequency = 44100;                            // Default playback rate of sound
exinfo.length           = exinfo.defaultfrequency * exinfo.numchannels * sizeof(signed short) * 5;   // Length of sound - PCM data in bytes. 5 = seconds
exinfo.format           = FMOD_SOUND_FORMAT_PCM16;          // Data format of sound
exinfo.pcmreadcallback  = MyReadCallbackFunction;           // To read sound data, you must specify a read callback using the pcmreadcallback field
// Alternatively, use Sound::lock and Sound::unlock to submit sample data to the sound when playing it back

// As sample data is being loaded via callback or Sound::lock and Sound::unlock, pass null or equivalent as second argument
FMOD_System_CreateSound(system, NULL, FMOD_OPENUSER, &exinfo, &sound);
```

```csharp
FMOD.Sound sound
FMOD.CREATESOUNDEXINFO exinfo;

// Create extended sound info struct
exinfo = new FMOD.CREATESOUNDEXINFO();
exinfo.cbsize           = Marshal.SizeOf(typeof(FMOD.CREATESOUNDEXINFO));  // Size of the struct
exinfo.numchannels      = 2;                                // Number of channels in the sound
exinfo.defaultfrequency = 44100;                            // Default playback rate of sound
exinfo.length           = exinfo.defaultfrequency * exinfo.numchannels * sizeof(short) * 5;   // Length of sound - PCM data in bytes. 5 = seconds
exinfo.format           = FMOD.SOUND_FORMAT.PCM16;          // Data format of sound
exinfo.pcmreadcallback  = MyReadCallbackFunction;           // To read sound data, you must specify a read callback using the pcmreadcallback field
// Alternatively, use Sound::lock and Sound::unlock to submit sample data to the sound when playing it back

// As sample data is being loaded via callback or Sound::lock and Sound::unlock, pass null or equivalent as first argument
system.createSound("", FMOD.MODE.OPENUSER, ref exinfo, out sound);
```

```javascript
var sound = {};
var outval = {};
var exinfo = FMOD.CREATESOUNDEXINFO();

// Create extended sound info struct
// No need to define cbsize, the struct already knows its own size in JS
exinfo.numchannels      = 2;                                // Number of channels in the sound
exinfo.defaultfrequency = 44100;                            // Default playback rate of sound
exinfo.length           = exinfo.defaultfrequency * exinfo.numchannels * 2 * 5;      // Length of sound - PCM data in bytes. 2 = sizeof(short) and 5 = seconds
exinfo.format           = FMOD_SOUND_FORMAT.PCM16;          // Data format of sound
exinfo.pcmreadcallback  = MyReadCallbackFunction;           // To read sound data, you must specify a read callback using the pcmreadcallback field
// Alternatively, use Sound::lock and Sound::unlock to submit sample data to the sound when playing it back

// As sample data is being loaded via callback or Sound::lock and Sound::unlock, pass null or equivalent as first argument
system.createSound("", FMOD.OPENUSER, exinfo, outval);
sound = outval.val;
```

--------------------------------

### Velocity Calculation Examples

Source: https://fmod.com/docs/2.03/api/spatializing-sounds-in-the-core-api.html

Examples showing how velocity remains consistent across different frame rates when using time-adjusted deltas.

```text
vel = 0.1 * 1000 / 16.67 = 6 meters per second.
```

```text
vel = 0.2 * 1000 / 33.33 = 6 meters per second.
```

--------------------------------

### Implement DSP read callback for volume attenuation

Source: https://fmod.com/docs/2.03/api/plugin-api-dsp.html

Example implementations showing how to copy input to output at half volume within the callback.

```C
FMOD_RESULT F_CALL Read(FMOD_DSP_STATE *dsp_state, float *inbuffer, float *outbuffer, unsigned int length, int inchannels, int *outchannels)
{
    for (unsigned int sample = 0; sample < length; sample++)
    {
        for (int channel = 0; channel < inchannels; channel++)
        {
            outbuffer[sample * *outchannels + channel] = inbuffer[sample * inchannels + channel] * 0.5f;
        }
    }

    return FMOD_OK;
}
```

```C#
[AOT.MonoPInvokeCallback(typeof(FMOD.DSP_READ_CALLBACK))]
static RESULT Read(ref DSP_STATE dsp_state, IntPtr inbuffer, IntPtr outbuffer, uint length, int inchannels, ref int outchannels)
{
    float[] input = new float[length * inchannels];
    float[] output = new float[length * outchannels];

    Marshal.Copy(inbuffer, input, 0, (int)length * inchannels);

    for (int sample = 0; sample < length; sample++)
    {
        for (int channel = 0; channel < outchannels; channel++)
        {
            output[sample * outchannels + channel] = input[sample * outchannels + channel] * 0.5f;
        }
    }

    Marshal.Copy(output, 0, outbuffer, (int)length * outchannels);

    return RESULT.OK;
}
```

```JS
function Read(dsp_state, inbuffer, outbuffer, length, inchannels, outchannels)
{
    for (var sample = 0; sample < length; sample++)
    {
        for (var channel = 0; channel < outchannels; channel++)
        {
            let val = FMOD.getValue(inbuffer + (((sample * inchannels) + channel) * 4), 'float') * 0.5;

            FMOD.setValue(outbuffer + (((sample * outchannels) + channel) * 4), val, 'float');
            dsp_state.plugindata.buffer[(sample * outchannels) + channel] = val;
        }
    }

    return FMOD.OK;
}
```

--------------------------------

### FMOD_DSP_GETPARAM_BOOL_CALLBACK

Source: https://fmod.com/docs/2.03/api/plugin-api-dsp.html

Get boolean parameter callback. This callback is called when the user wants to get a boolean parameter value from a DSP unit.

```APIDOC
## FMOD_DSP_GETPARAM_BOOL_CALLBACK

### Description
This callback is called when the user wants to get a boolean parameter value from a DSP unit.

### Signature
FMOD_RESULT F_CALL FMOD_DSP_GETPARAM_BOOL_CALLBACK(FMOD_DSP_STATE *dsp_state, int index, FMOD_BOOL *value, char *valuestr);

### Parameters
- **dsp_state** (FMOD_DSP_STATE*) - DSP Plug-in state.
- **index** (int) - Parameter index.
- **value** (FMOD_BOOL*) - Out: Parameter value (Boolean).
- **valuestr** (char*) - OutOpt: String value of the parameter (UTF-8 string, max FMOD_DSP_GETPARAM_VALUESTR_LENGTH bytes).
```

--------------------------------

### Install Linux audio bridge dependencies

Source: https://fmod.com/docs/2.03/studio/appendix-b-reaper-integration.html

Command to install the necessary packages for routing PulseAudio to JACK on Debian-based Linux distributions.

```bash
sudo apt install qjackctl pulseaudio-module-jack
```

--------------------------------

### Configure Automatic Sample Loading

Source: https://fmod.com/docs/2.03/unity/api-settings.html

Banks loaded at initialization will also have their sample data loaded. Consumes more memory but reduces latency.

```C#
bool AutomaticSampleLoading;
```

--------------------------------

### Load and Set an Output Plug-in

Source: https://fmod.com/docs/2.03/api/advanced-core-api-topics.html

Loads an output dynamic library and configures the system to use it as the output device.

```C++
FMOD_RESULT result;
unsigned int handle;

result = system->loadPlugin("example_output.dll", &handle);
result = system->setOutputByPlugin(handle);
```

```C
FMOD_RESULT result;
unsigned int handle;

result = FMOD_System_LoadPlugin(system, "example_output.dll", &handle, 0);
result = FMOD_System_SetOutputByPlugin(system, handle);
```

```C#
FMOD.Result result;
uint handle;

result = system.loadPlugin("example_output.dll", out handle);
result = system.setOutputByPlugin(handle);
```

--------------------------------

### Initialize Studio System

Source: https://fmod.com/docs/2.03/api/studio-api-system.html

Initializes the Studio System and the underlying core system. The flags and extradriverdata parameters are passed to the core system initialization.

```C++
FMOD_RESULT Studio::System::initialize(
  int maxchannels,
  FMOD_STUDIO_INITFLAGS studioflags,
  FMOD_INITFLAGS flags,
  void *extradriverdata
);
```

```C
FMOD_RESULT FMOD_Studio_System_Initialize(
  FMOD_STUDIO_SYSTEM *system,
  int maxchannels,
  FMOD_STUDIO_INITFLAGS studioflags,
  FMOD_INITFLAGS flags,
  void *extradriverdata
);
```

```C#
RESULT Studio.System.initialize(
  int maxchannels,
  INITFLAGS studioflags,
  FMOD.INITFLAGS flags,
  IntPtr extradriverdata
);
```

```JavaScript
Studio.System.initialize(
  maxchannels,
  studioflags,
  flags,
  extradriverdata
);
```

--------------------------------

### Get Global Parameter By Name

Source: https://fmod.com/docs/2.03/unreal/blueprint-reference-common.html

Retrieves a global parameter value. This function is deprecated in FMOD 2.01; use Get Global Parameter Value By Name instead.

```C++
static float GetGlobalParameterByName(
  FName Name
);
```

--------------------------------

### Define Banks to Load

Source: https://fmod.com/docs/2.03/unity/api-settings.html

List of all the bank paths to be loaded at initialization.

```C#
List<string> BanksToLoad;
```

--------------------------------

### project.lookup

Source: https://fmod.com/docs/2.03/studio/scripting-api-reference-project.html

Looks up a ManagedObject by its GUID or path.

```APIDOC
## project.lookup(idOrPath)

### Description
Lookup a ManagedObject by path or GUID. Paths are formatted using the pattern type:/path/to/item.

### Parameters
- **idOrPath** (string) - Required - GUID or path of the ManagedObject.

### Returns
- **ManagedObject** - The object found by GUID or path.
```

--------------------------------

### project.lookup

Source: https://fmod.com/docs/2.03/studio/scripting-api-reference-project.html

Finds a ManagedObject by path or GUID.

```APIDOC
## project.lookup(pathOrGuid)

### Description
Lookup a ManagedObject by path or GUID.
```

--------------------------------

### Studio::CommandReplay::start

Source: https://fmod.com/docs/2.03/api/studio-api-commandreplay.html

Begins playback of the command replay. Restarts from the beginning if already running.

```C++
FMOD_RESULT Studio::CommandReplay::start();
```

```C
FMOD_RESULT FMOD_Studio_CommandReplay_Start(FMOD_STUDIO_COMMANDREPLAY *commandreplay);
```

```C#
RESULT Studio.CommandReplay.start();
```

```JavaScript
Studio.CommandReplay.start();
```

--------------------------------

### project.exportGUIDs

Source: https://fmod.com/docs/2.03/studio/scripting-api-reference-project.html

Exports the project GUIDs file.

```APIDOC
## project.exportGUIDs()

### Description
Exports project "guids.txt".
```

--------------------------------

### Implement DSP plug-in state management

Source: https://fmod.com/docs/2.03/api/plugin-api-dsp.html

Example of using plugindata to store oscillator state, with allocation in the create callback and cleanup in the release callback.

```C
#define TWO_PI (2.0f * 3.14159265358979323846f)

typedef struct
{
    unsigned int step[16];
} dsp_data;

FMOD_RESULT F_CALL Read(FMOD_DSP_STATE *dsp_state, float *inbuffer, float *outbuffer, unsigned int length, int inchannels, int *outchannels)
{
    dsp_data *data = (dsp_data *)dsp_state->plugindata;
    int samplerate;
    dsp_state->functions->getsamplerate(dsp_state, &samplerate);

    for (unsigned int sample = 0; sample < length; sample++)
    {
        for (int channel = 0; channel < inchannels; channel++)
        {
            outbuffer[sample * *outchannels + channel] = sinf((440.0f * TWO_PI * data->step[channel]++) / (float)samplerate);
        }
    }

    return FMOD_OK;
}

FMOD_RESULT F_CALL Create(FMOD_DSP_STATE *dsp_state)
{
    dsp_data *data = (dsp_data *)calloc(sizeof(dsp_data), 1);
    if (!data)
    {
        return FMOD_ERR_MEMORY;
    }
    memset(data, 0, sizeof(data));
    dsp_state->plugindata = data;

    return FMOD_OK;
}

FMOD_RESULT F_CALL Release(FMOD_DSP_STATE *dsp_state)
{
    if (dsp_state->plugindata)
    {
        dsp_data *data = (dsp_data *)dsp_state->plugindata;
        free(data);
    }

    return FMOD_OK;
}
```

--------------------------------

### Studio::System::getCoreSystem

Source: https://fmod.com/docs/2.03/api/studio-api-system.html

Retrieves the underlying Core System.

```APIDOC
## Studio::System::getCoreSystem

### Description
Retrieves the underlying FMOD Core System object.

### Method
Method

### Signature
Studio::System::getCoreSystem(FMOD::System **system)
```

--------------------------------

### Play

Source: https://fmod.com/docs/2.03/unreal/blueprint-reference-component.html

Starts playback of the sound on the audio component.

```APIDOC
## void Play()

### Description
Start a sound playing on an audio component.
```

--------------------------------

### Configure FMOD Sound and Handle Audio Samples

Source: https://fmod.com/docs/2.03/unity/examples-video-playback.html

Initializes the FMOD sound structure and sets up the sample frame provider for audio playback.

```csharp
        mExinfo.cbsize = Marshal.SizeOf(typeof(FMOD.CREATESOUNDEXINFO));
        mExinfo.numchannels = mProvider.channelCount;
        mExinfo.defaultfrequency = mSampleRate;
        mExinfo.length = mTargetLatencySamples * (uint)mExinfo.numchannels * sizeof(float);
        mExinfo.format = FMOD.SOUND_FORMAT.PCMFLOAT;

        FMODUnity.RuntimeManager.CoreSystem.createSound("", FMOD.MODE.LOOP_NORMAL | FMOD.MODE.OPENUSER, ref mExinfo, out mSound);

        mProvider.sampleFramesAvailable += SampleFramesAvailable;
        mProvider.enableSampleFramesAvailableEvents = true;
        mProvider.freeSampleFrameCountLowThreshold = mProvider.maxSampleFrameCount - mTargetLatencySamples;

        vp.Play();
    }

    private void SampleFramesAvailable(AudioSampleProvider provider, uint sampleFrameCount)
    {
        using (NativeArray<float> buffer = new NativeArray<float>((int)sampleFrameCount * provider.channelCount, Allocator.Temp))
        {
            uint samplesWritten = provider.ConsumeSampleFrames(buffer);
            mBuffer.AddRange(buffer);

            /*
             * Drift compensation
             * If we are behind our latency target, play a little faster
             * If we are ahead of our latency target, play a little slower
             */
            mTotalSamplesWritten += samplesWritten;

            if (samplesWritten != 0 && (samplesWritten < mMinimumSamplesWritten))
            {
                mMinimumSamplesWritten = samplesWritten;
                mAdjustedLatencySamples = Math.Max(samplesWritten, mTargetLatencySamples);
            }

            int latency = (int)mTotalSamplesWritten - (int)mTotalSamplesRead;
            mActualLatencySamples = (int)((0.93f * mActualLatencySamples) + (0.03f * latency));

            int playbackRate = mSampleRate;
            if (mActualLatencySamples < (int)(mAdjustedLatencySamples - mDriftThresholdSamples))
            {
                playbackRate = mSampleRate - (int)(mSampleRate * (DRIFT_CORRECTION_PERCENTAGE / 100.0f));
            }
            else if (mActualLatencySamples > (int)(mAdjustedLatencySamples + mDriftThresholdSamples))
            {
                playbackRate = mSampleRate + (int)(mSampleRate * (DRIFT_CORRECTION_PERCENTAGE / 100.0f));
            }
            mChannel.setFrequency(playbackRate);
        }
    }

    private void Update()
    {
        if (!mVideoPlayer.isPrepared)
        {
            return;
        }

        /*
         * Need to wait before playing to provide adequate space between read and write positions
         */
        if (!mChannel.hasHandle() && mTotalSamplesWritten > mAdjustedLatencySamples)
        {
            FMOD.ChannelGroup mMasterChannelGroup;
            FMODUnity.RuntimeManager.CoreSystem.getMasterChannelGroup(out mMasterChannelGroup);
            FMODUnity.RuntimeManager.CoreSystem.playSound(mSound, mMasterChannelGroup, false, out mChannel);
        }

        if (mBuffer.Count > 0 && mChannel.hasHandle())
        {
            uint readPositionBytes;
            mChannel.getPosition(out readPositionBytes, FMOD.TIMEUNIT.PCMBYTES);

            /*
             * Account for wrapping
             */
            uint bytesRead = readPositionBytes - mLastReadPositionBytes;
            if (readPositionBytes < mLastReadPositionBytes)
            {
                bytesRead += mExinfo.length;
            }

            if (bytesRead > 0 && mBuffer.Count >= bytesRead)
            {
                /*
                 * Fill previously read data with fresh samples
                 */
                IntPtr ptr1, ptr2;
                uint lenBytes1, lenBytes2;
                var res = mSound.@lock(mLastReadPositionBytes, bytesRead, out ptr1, out ptr2, out lenBytes1, out lenBytes2);
                if (res != FMOD.RESULT.OK) Debug.LogError(res);

                /*
                 * Though exinfo.format is float, data retrieved from Sound::lock is in bytes,
                 * therefore we only copy (len1+len2)/sizeof(float) full float values across
                 */
                int lenFloats1 = (int)(lenBytes1 / sizeof(float));
                int lenFloats2 = (int)(lenBytes2 / sizeof(float));
                int totalFloatsRead = lenFloats1 + lenFloats2;
                float[] tmpBufferFloats = new float[totalFloatsRead];

                mBuffer.CopyTo(0, tmpBufferFloats, 0, tmpBufferFloats.Length);
                mBuffer.RemoveRange(0, tmpBufferFloats.Length);

                if (lenBytes1 > 0)
                {
                    Marshal.Copy(tmpBufferFloats, 0, ptr1, lenFloats1);
                }
                if (lenBytes2 > 0)
                {
                    Marshal.Copy(tmpBufferFloats, lenFloats1, ptr2, lenFloats2);
                }
```

--------------------------------

### project.exportGUIDs

Source: https://fmod.com/docs/2.03/studio/scripting-api-reference-project.html

Exports the project GUIDs to a text file.

```APIDOC
## project.exportGUIDs()

### Description
Exports project "guids.txt".

### Returns
- **boolean** - Returns true if the operation succeeds, or false otherwise.
```

--------------------------------

### Studio::CommandReplay::start

Source: https://fmod.com/docs/2.03/api/studio-api-commandreplay.html

Begins playback of the command replay. If already running, it restarts from the beginning.

```APIDOC
## Studio::CommandReplay::start

### Description
Begins playback. If the replay is already running then calling this function will restart replay from the beginning.
```

--------------------------------

### Start Command Capture

Source: https://fmod.com/docs/2.03/api/studio-api-system.html

Records Studio API commands to a file for debugging and profiling.

```C++
FMOD_RESULT Studio::System::startCommandCapture(
  const char *filename,
  FMOD_STUDIO_COMMANDCAPTURE_FLAGS flags
);
```

```C
FMOD_RESULT FMOD_Studio_System_StartCommandCapture(
  FMOD_STUDIO_SYSTEM *system,
  const char *filename,
  FMOD_STUDIO_COMMANDCAPTURE_FLAGS flags
);
```

```C#
RESULT Studio.System.startCommandCapture(
  string filename,
  COMMANDCAPTURE_FLAGS flags
);
```

```JS
Studio.System.startCommandCapture(
  filename,
  flags
);
```

--------------------------------

### Studio::VCA::getID

Source: https://fmod.com/docs/2.03/api/studio-api-vca.html

Retrieves the GUID of the VCA.

```APIDOC
## Studio::VCA::getID

### Description
Retrieves the VCA's GUID.

### Parameters
- **id** (FMOD_GUID*) - Out - VCA GUID.
```

--------------------------------

### FSBank_Build

Source: https://fmod.com/docs/2.03/api/fsbank-api.html

Begins the building process for the provided subsound descriptions.

```APIDOC
## FSBank_Build

### Description
Starts the build process using the provided subsound configurations.

### Signature
FSBANK_RESULT FSBank_Build(const FSBANK_SUBSOUND *subsounds, unsigned int numSubsounds, FSBANK_BUILDFLAGS flags, FSBANK_FORMAT encodeFormat, FSBANK_FSBVERSION fsbVersion, const char *fileName)
```

--------------------------------

### Studio::parseID

Source: https://fmod.com/docs/2.03/api/studio-api-common.html

Parses a GUID from a string representation.

```APIDOC
## Studio::parseID

### Description
Parses a GUID from a string.

### Signature
FMOD_RESULT Studio::parseID(const char *id_string, FMOD_GUID *id);

### Parameters
- **id_string** (const char *) - The string representation of the GUID.
- **id** (FMOD_GUID *) - Pointer to the FMOD_GUID structure to store the parsed result.
```

--------------------------------

### Geometry::getPolygonNumVertices

Source: https://fmod.com/docs/2.03/api/core-api-geometry.html

Gets the number of vertices in a polygon.

```APIDOC
## Geometry::getPolygonNumVertices

### Description
Gets the number of vertices in a polygon.

### Parameters
- **index** (int) - Required - Polygon index. Range: [0, Geometry::getNumPolygons)
- **numvertices** (int*) - Optional - Number of vertices.
```

--------------------------------

### FSBank_Build

Source: https://fmod.com/docs/2.03/api/fsbank-api.html

Begins the building process for the provided subsound descriptions.

```APIDOC
## FSBank_Build

### Description
Begin the building process for the provided subsound descriptions. This function will block until complete.

### Signature
FSBANK_RESULT FSBank_Build(const FSBANK_SUBSOUND *subSounds, unsigned int numSubSounds, FSBANK_FORMAT encodeFormat, FSBANK_BUILDFLAGS buildFlags, unsigned int quality, const char *encryptKey, const char *outputFileName);

### Parameters
- **subSounds** (const FSBANK_SUBSOUND *) - Required - Array of subsound descriptions each defining one subsound for the FSB.
- **numSubSounds** (unsigned int) - Required - Number of elements in subSounds.
- **encodeFormat** (FSBANK_FORMAT) - Required - FSB encoding format.
- **buildFlags** (FSBANK_BUILDFLAGS) - Required - Building flags which control how the sample data is encoded.
- **quality** (unsigned int) - Required - Controls the post compression quality level (1-100).
- **encryptKey** (const char *) - Optional - Key used to encrypt the FSB.
- **outputFileName** (const char *) - Required - Path of the FSB to produce.
```

--------------------------------

### Implement FMODGetOutputDescription for Plugin Setup

Source: https://fmod.com/docs/2.03/api/plugin-api-output.html

Use this function to return the FMOD_OUTPUT_DESCRIPTION structure when creating a dynamically loadable plug-in.

```cpp
/*
    Plug-in setup example
*/
extern "C" FMOD_OUTPUT_DESCRIPTION* F_CALL FMODGetOutputDescription()
{
    static FMOD_OUTPUT_DESCRIPTION desc;

    /*
        Fill members of structure
    */

    return &desc;
}
```

--------------------------------

### StudioEventEmitter::Play

Source: https://fmod.com/docs/2.03/unity/api-studioeventemitter.html

Creates and starts the FMOD.Studio.EventInstance associated with the emitter.

```APIDOC
## Play()

### Description
Creates and starts the FMOD.Studio.EventInstance associated with the StudioEventEmitter component.
```

--------------------------------

### Define FMOD plugins for deployment

Source: https://fmod.com/docs/2.03/ue4/user-guide.html

Create a plugins.txt file in the platform-specific binaries directory to list plugins for deployment.

```text
fmod_gain
```

--------------------------------

### FMODUtils::LookupNameFromGuid

Source: https://fmod.com/docs/2.03/unreal/api-reference-common.html

Returns the name of an event using its Guid.

```APIDOC
## FMODUtils::LookupNameFromGuid

### Description
Helper function to return the name of an event using its Guid.

### Signatures
`FString LookupNameFromGuid(FMOD::Studio::System *StudioSystem, const FGuid &Guid)`
`FString LookupNameFromGuid(FMOD::Studio::System *StudioSystem, const FMOD::Studio::ID &Guid)`

### Parameters
- **StudioSystem** (FMOD::Studio::System*) - Current FMOD Studio System.
- **Guid** (FGuid or FMOD::Studio::ID) - GUID to retrieve the name of.
```

--------------------------------

### Create and Delete Project Objects

Source: https://fmod.com/docs/2.03/studio/scripting-terminal-reference.html

Use studio.project.create to instantiate objects and studio.project.deleteObject to remove them.

```javascript
var myEvent = studio.project.create("Event");
myEvent.name = "My New Event";
myEvent.folder = studio.project.workspace.masterEventFolder;
```

```javascript
studio.project.deleteObject(myEvent);
```

--------------------------------

### PathToGUID

Source: https://fmod.com/docs/2.03/unity/api-runtimemanager.html

Returns the GUID associated with a path from the strings bank.

```APIDOC
## static Guid PathToGUID(string path)

### Description
Return the GUID associated with a path from the strings bank. Path lookups only succeed if the strings bank is loaded.

### Parameters
- **path** (string) - Required - Full event path (e.g., event:/Music/Level1)
```

--------------------------------

### Manage Event Instance Lifecycle

Source: https://fmod.com/docs/2.03/unity/examples-basic.html

Demonstrates releasing resources on destruction and starting event instances.

```csharp
playerState.release();
```

```csharp
playerState.start();
```

--------------------------------

### Studio::EventDescription::getID

Source: https://fmod.com/docs/2.03/api/studio-api-eventdescription.html

Retrieves the GUID associated with the event.

```APIDOC
## Studio::EventDescription::getID

### Description
Retrieves the GUID associated with the event.

### Parameters
- **id** (FMOD_GUID*) - Out - Event description GUID.
```

--------------------------------

### Studio::Bus::getID

Source: https://fmod.com/docs/2.03/api/studio-api-bus.html

Retrieves the unique GUID for the bus.

```APIDOC
## Studio::Bus::getID

### Description
Retrieves the GUID.

### Parameters
- **id** (FMOD_GUID*) - Out - The GUID of the bus.
```

--------------------------------

### Define Default Plug-in Configurations

Source: https://fmod.com/docs/2.03/studio/plugin-reference.html

Provide preset parameter values that users can select from the plug-in context menu.

```javascript
defaultConfigurations: [
    {
        name:"Quiet",
        parameterValues: {
            "gain": -20,
        },
    },
    {
        name:"Bright",
        parameterValues: {
            "gain": 0,
            "freq": 5000,
        },
    },
],
```

--------------------------------

### Retrieve VCA GUID

Source: https://fmod.com/docs/2.03/api/studio-api-vca.html

Retrieves the unique identifier for the VCA.

```C++
FMOD_RESULT Studio::VCA::getID(
  FMOD_GUID *id
);
```

```C
FMOD_RESULT FMOD_Studio_VCA_GetID(
  FMOD_STUDIO_VCA *vca,
  FMOD_GUID *id
);
```

```C#
RESULT Studio.VCA.getID(
  out Guid id
);
```

```JavaScript
Studio.VCA.getID(
  id
);
```

--------------------------------

### Sound::getMusicSpeed

Source: https://fmod.com/docs/2.03/api/core-api-sound.html

Gets the relative speed of MOD/S3M/XM/IT/MIDI music.

```APIDOC
## Sound::getMusicSpeed

### Description
Gets the relative speed of MOD/S3M/XM/IT/MIDI music.

### Parameters
- **speed** (float*) - Out - Speed of the song.
```

--------------------------------

### FSBank_Init

Source: https://fmod.com/docs/2.03/api/fsbank-api.html

Initializes the FSBank system.

```APIDOC
## FSBank_Init

### Description
Initializes the FSBank system for use.

### Signature
FSBANK_RESULT FSBank_Init(FSBANK_INITFLAGS flags, unsigned int numThreads, const char *cacheDirectory)
```

--------------------------------

### Play Event Instance

Source: https://fmod.com/docs/2.03/unreal/blueprint-reference-eventinstance.html

Starts playback of an FMOD Event Instance.

```C++
static void EventInstancePlay(
  FFMODEventInstance EventInstance
);
```

--------------------------------

### Configure PulseAudio to JACK module loading

Source: https://fmod.com/docs/2.03/studio/appendix-b-reaper-integration.html

Commands to load the JACK sink and source modules and set the default sink to JACK, intended for use in QJackCtl startup scripts.

```bash
pactl load-module module-jack-sink channels=2; pactl load-module module-jack-source channels=2; pacmd set-default-sink jack_out
```

--------------------------------

### Channel::setLoopPoints

Source: https://fmod.com/docs/2.03/api/core-api-channel.html

Sets the start and end points for looping on a channel.

```APIDOC
## Channel::setLoopPoints

### Description
Sets the loop start and end points for a channel. This only applies to channels playing a sound, and the channel mode must be set to FMOD_LOOP_NORMAL or FMOD_LOOP_BIDI.

### Parameters
- **loopstart** (unsigned int) - Required - Loop start point.
- **loopstarttype** (FMOD_TIMEUNIT) - Required - Time units for loopstart.
- **loopend** (unsigned int) - Required - Loop end point.
- **loopendtype** (FMOD_TIMEUNIT) - Required - Time units for loopend.
```

--------------------------------

### Accessing FMOD Systems

Source: https://fmod.com/docs/2.03/unity/api.html

Demonstrates how to access the underlying FMOD Studio and Core systems through the RuntimeManager.

```APIDOC
## Accessing FMOD Systems

### Description
Use the FMODUnity.RuntimeManager to retrieve the StudioSystem and CoreSystem instances for direct API access.

### Code Example
```csharp
var studioSystem = FMODUnity.RuntimeManager.StudioSystem;
FMOD.Studio.CPU_USAGE cpuUsage;
studioSystem.getCPUUsage(out cpuUsage);

var coreSystem = FMODUnity.RuntimeManager.CoreSystem;
uint version, buildnumber;
coreSystem.getVersion(out version, out buildnumber);
```
```

--------------------------------

### Lookup ManagedObject

Source: https://fmod.com/docs/2.03/studio/scripting-api-reference-project.html

Finds a ManagedObject using its GUID or a path string.

```javascript
project.lookup(
    idOrPath
)
```

```javascript
var item = project.lookup("{3a731ab3-ce6d-453d-862e-32050cecf68a}");
var event = project.lookup("event:/path/to/eventname");
var eventFolder = project.lookup("event:/path/to/foldername");
var bank = project.lookup("bank:/path/to/bank");
var snapshot = project.lookup("snapshot:/snapshotname");
var vca = project.lookup("vca:/vcaname");
```
Tokens:
Raw