cmake windows

SimpleGame/FMOD/api/core/examples/3d.cpp

@@ -0,0 +1,215 @@
+/*==============================================================================
+3D Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to basic 3D positioning of sounds.
+
+For information on using FMOD example code in your own programs, visit
+https://www.fmod.com/legal
+==============================================================================*/
+#include "fmod.hpp"
+#include "common.h"
+
+const int   INTERFACE_UPDATETIME = 50;      // 50ms update for interface
+const float DISTANCEFACTOR = 1.0f;          // Units per meter.  I.e feet would = 3.28.  centimeters would = 100.
+
+int FMOD_Main()
+{
+    FMOD::System    *system;
+    FMOD::Sound     *sound1, *sound2, *sound3;
+    FMOD::Channel   *channel1 = 0, *channel2 = 0, *channel3 = 0;
+    FMOD_RESULT      result;
+    bool             listenerflag = true;
+    FMOD_VECTOR      listenerpos  = { 0.0f, 0.0f, -1.0f * DISTANCEFACTOR };
+    void            *extradriverdata = 0;
+
+    Common_Init(&extradriverdata);
+
+    /*
+        Create a System object and initialize.
+    */
+    result = FMOD::System_Create(&system);
+    ERRCHECK(result);
+    
+    result = system->init(100, FMOD_INIT_NORMAL, extradriverdata);
+    ERRCHECK(result);
+    
+    /*
+        Set the distance units. (meters/feet etc).
+    */
+    result = system->set3DSettings(1.0, DISTANCEFACTOR, 1.0f);
+    ERRCHECK(result);
+
+    /*
+        Load some sounds
+    */
+    result = system->createSound(Common_MediaPath("drumloop.wav"), FMOD_3D, 0, &sound1);
+    ERRCHECK(result);
+    result = sound1->set3DMinMaxDistance(0.5f * DISTANCEFACTOR, 5000.0f * DISTANCEFACTOR);
+    ERRCHECK(result);
+    result = sound1->setMode(FMOD_LOOP_NORMAL);
+    ERRCHECK(result);
+
+    result = system->createSound(Common_MediaPath("jaguar.wav"), FMOD_3D, 0, &sound2);
+    ERRCHECK(result);
+    result = sound2->set3DMinMaxDistance(0.5f * DISTANCEFACTOR, 5000.0f * DISTANCEFACTOR);
+    ERRCHECK(result);
+    result = sound2->setMode(FMOD_LOOP_NORMAL);
+    ERRCHECK(result);
+
+    result = system->createSound(Common_MediaPath("swish.wav"), FMOD_2D, 0, &sound3);
+    ERRCHECK(result);
+
+    /*
+        Play sounds at certain positions
+    */
+    {
+        FMOD_VECTOR pos = { -10.0f * DISTANCEFACTOR, 0.0f, 0.0f };
+        FMOD_VECTOR vel = {  0.0f, 0.0f, 0.0f };
+
+        result = system->playSound(sound1, 0, true, &channel1);
+        ERRCHECK(result);
+        result = channel1->set3DAttributes(&pos, &vel);
+        ERRCHECK(result);
+        result = channel1->setPaused(false);
+        ERRCHECK(result);
+    }
+
+    {
+        FMOD_VECTOR pos = { 15.0f * DISTANCEFACTOR, 0.0f, 0.0f };
+        FMOD_VECTOR vel = { 0.0f, 0.0f, 0.0f };
+
+        result = system->playSound(sound2, 0, true, &channel2);
+        ERRCHECK(result);
+        result = channel2->set3DAttributes(&pos, &vel);
+        ERRCHECK(result);
+        result = channel2->setPaused(false);
+        ERRCHECK(result);
+    }
+
+    /*
+        Main loop
+    */
+    do
+    {
+        Common_Update();
+
+        if (Common_BtnPress(BTN_ACTION1))
+        {
+            bool paused;
+            channel1->getPaused(&paused);
+            channel1->setPaused(!paused);
+        }
+
+        if (Common_BtnPress(BTN_ACTION2))
+        {
+            bool paused;
+            channel2->getPaused(&paused);
+            channel2->setPaused(!paused);
+        }
+
+        if (Common_BtnPress(BTN_ACTION3))
+        {
+            result = system->playSound(sound3, 0, false, &channel3);
+            ERRCHECK(result);
+        }
+
+        if (Common_BtnPress(BTN_MORE))
+        {
+            listenerflag = !listenerflag;
+        }
+
+        if (!listenerflag)
+        {
+            if (Common_BtnDown(BTN_LEFT))
+            {
+                listenerpos.x -= 1.0f * DISTANCEFACTOR;
+                if (listenerpos.x < -24 * DISTANCEFACTOR)
+                {
+                    listenerpos.x = -24 * DISTANCEFACTOR;
+                }
+            }
+
+            if (Common_BtnDown(BTN_RIGHT))
+            {
+                listenerpos.x += 1.0f * DISTANCEFACTOR;
+                if (listenerpos.x > 23 * DISTANCEFACTOR)
+                {
+                    listenerpos.x = 23 * DISTANCEFACTOR;
+                }
+            }
+        }
+
+        // ==========================================================================================
+        // UPDATE THE LISTENER
+        // ==========================================================================================
+        {
+            static float t = 0;
+            static FMOD_VECTOR lastpos = { 0.0f, 0.0f, 0.0f };
+            FMOD_VECTOR forward        = { 0.0f, 0.0f, 1.0f };
+            FMOD_VECTOR up             = { 0.0f, 1.0f, 0.0f };
+            FMOD_VECTOR vel;
+
+            if (listenerflag)
+            {
+                listenerpos.x = (float)sin(t * 0.05f) * 24.0f * DISTANCEFACTOR; // left right pingpong
+            }
+
+            // ********* NOTE ******* READ NEXT COMMENT!!!!!
+            // vel = how far we moved last FRAME (m/f), then time compensate it to SECONDS (m/s).
+            vel.x = (listenerpos.x - lastpos.x) * (1000 / INTERFACE_UPDATETIME);
+            vel.y = (listenerpos.y - lastpos.y) * (1000 / INTERFACE_UPDATETIME);
+            vel.z = (listenerpos.z - lastpos.z) * (1000 / INTERFACE_UPDATETIME);
+
+            // store pos for next time
+            lastpos = listenerpos;
+
+            result = system->set3DListenerAttributes(0, &listenerpos, &vel, &forward, &up);
+            ERRCHECK(result);
+
+            t += (30 * (1.0f / (float)INTERFACE_UPDATETIME));    // t is just a time value .. it increments in 30m/s steps in this example
+        }
+
+        result = system->update();
+        ERRCHECK(result);
+
+        // Create small visual display.
+        char s[80] = "|.............<1>......................<2>.......|";
+        s[(int)(listenerpos.x / DISTANCEFACTOR) + 25] = 'L';
+
+        Common_Draw("==================================================");
+        Common_Draw("3D Example.");
+        Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+        Common_Draw("==================================================");
+        Common_Draw("");
+        Common_Draw("Press %s to toggle sound 1 (16bit Mono 3D)", Common_BtnStr(BTN_ACTION1));
+        Common_Draw("Press %s to toggle sound 2 (8bit Mono 3D)", Common_BtnStr(BTN_ACTION2));
+        Common_Draw("Press %s to play a sound (16bit Stereo 2D)", Common_BtnStr(BTN_ACTION3));
+        Common_Draw("Press %s or %s to move listener in still mode", Common_BtnStr(BTN_LEFT), Common_BtnStr(BTN_RIGHT));
+        Common_Draw("Press %s to toggle listener auto movement", Common_BtnStr(BTN_MORE));
+        Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
+        Common_Draw("");
+        Common_Draw(s);
+
+        Common_Sleep(INTERFACE_UPDATETIME - 1);
+    } while (!Common_BtnPress(BTN_QUIT));
+
+    /*
+        Shut down
+    */
+    result = sound1->release();
+    ERRCHECK(result);
+    result = sound2->release();
+    ERRCHECK(result);
+    result = sound3->release();
+    ERRCHECK(result);
+
+    result = system->close();
+    ERRCHECK(result);
+    result = system->release();
+    ERRCHECK(result);
+
+    Common_Close();
+
+    return 0;
+}

SimpleGame/FMOD/api/core/examples/asyncio.cpp

@@ -0,0 +1,348 @@
+/*===============================================================================================
+ Async IO Example
+ Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+ This example shows how to play a stream and use a custom file handler that defers reads for the
+ streaming part.  FMOD will allow the user to return straight away from a file read request and
+ supply the data at a later time.
+===============================================================================================*/
+#include "fmod.hpp"
+#include "common.h"
+#include <list>
+
+struct AsyncData
+{
+    FMOD_ASYNCREADINFO *info;
+};
+
+struct ScopedMutex
+{
+    Common_Mutex *mMutex;
+    ScopedMutex(Common_Mutex *mutex) : mMutex(mutex) { Common_Mutex_Enter(mMutex); }
+    ~ScopedMutex() { Common_Mutex_Leave(mMutex); }
+};
+
+Common_Mutex gListCrit;
+std::list<AsyncData*> gList;
+bool gThreadQuit = false;
+bool gThreadFinished = false;
+bool gSleepBreak = false;
+
+
+/*
+    A little text buffer to allow a scrolling window
+*/
+const int DRAW_ROWS = NUM_ROWS - 8;
+const int DRAW_COLS = NUM_COLUMNS;
+
+char gLineData[DRAW_ROWS][DRAW_COLS];
+Common_Mutex gLineCrit;
+
+void AddLine(const char *formatString...)
+{
+    ScopedMutex mutex(&gLineCrit);
+    
+    char s[DRAW_COLS];
+    va_list args;
+    va_start(args, formatString);
+    Common_vsnprintf(s, DRAW_COLS, formatString, args);
+    va_end(args);
+
+    for (int i = 1; i < DRAW_ROWS; i++)
+    {
+        memcpy(gLineData[i-1], gLineData[i], DRAW_COLS);
+    }
+    strncpy(gLineData[DRAW_ROWS-1], s, DRAW_COLS);
+}
+
+void DrawLines()
+{
+    ScopedMutex mutex(&gLineCrit);
+
+    for (int i = 0; i < DRAW_ROWS; i++)
+    {
+        Common_Draw(gLineData[i]);
+    }
+}
+
+
+/*
+    File callbacks
+*/
+FMOD_RESULT F_CALL myopen(const char *name, unsigned int *filesize, void **handle, void * /*userdata*/)
+{
+    assert(name);
+    assert(filesize);
+    assert(handle);
+
+    Common_File_Open(name, 0, filesize, handle);    // mode 0 = 'read'.
+    
+    if (!handle)
+    {
+        return FMOD_ERR_FILE_NOTFOUND;
+    }
+
+    return FMOD_OK;
+}
+
+FMOD_RESULT F_CALL myclose(void *handle, void * /*userdata*/)
+{
+    assert(handle);
+
+    Common_File_Close(handle);
+
+    return FMOD_OK;
+}
+
+FMOD_RESULT F_CALL myread(void *handle, void *buffer, unsigned int sizebytes, unsigned int *bytesread, void * /*userdata*/)
+{
+    assert(handle);
+    assert(buffer);
+    assert(bytesread);
+
+    Common_File_Read(handle, buffer, sizebytes, bytesread);
+
+    if (*bytesread < sizebytes)
+    {
+        return FMOD_ERR_FILE_EOF;
+    }
+
+    return FMOD_OK;
+}
+
+FMOD_RESULT F_CALL myseek(void *handle, unsigned int pos, void * /*userdata*/)
+{
+    assert(handle);
+
+    Common_File_Seek(handle, pos);
+
+    return FMOD_OK;
+}
+
+FMOD_RESULT F_CALL myasyncread(FMOD_ASYNCREADINFO *info, void * /*userdata*/)
+{
+    assert(info);
+
+    ScopedMutex mutex(&gListCrit);
+
+    AsyncData *data = (AsyncData *)malloc(sizeof(AsyncData));
+    if (!data)
+    {
+        /* Signal FMOD to wake up, this operation has has failed */
+        info->done(info, FMOD_ERR_MEMORY);
+        return FMOD_ERR_MEMORY;
+    }
+
+    AddLine("REQUEST %5d bytes, offset %5d PRIORITY = %d.", info->sizebytes, info->offset, info->priority);
+    data->info = info;
+    gList.push_back(data);
+    
+    /* Example only: Use your native filesystem scheduler / priority here */
+    if (info->priority > 50)
+    {
+        gSleepBreak = true;
+    }
+
+    return FMOD_OK;
+}
+
+FMOD_RESULT F_CALL myasynccancel(FMOD_ASYNCREADINFO *info, void * /*userdata*/)
+{
+    assert(info);
+
+    ScopedMutex mutex(&gListCrit);
+
+    /* Find the pending IO request and remove it */
+    for (std::list<AsyncData*>::iterator itr = gList.begin(); itr != gList.end(); itr++)
+    {
+        AsyncData *data = *itr;
+        if (data->info == info)
+        {
+            gList.remove(data);
+            free(data);
+
+            /* Signal FMOD to wake up, this operation has been cancelled */
+            info->done(info, FMOD_ERR_FILE_DISKEJECTED);
+            return FMOD_ERR_FILE_DISKEJECTED;
+        }
+    }
+
+    /* IO request not found, it must have completed already */
+    return FMOD_OK;
+}
+
+
+/*
+    Async file IO processing thread
+*/
+void ProcessQueue(void * /*param*/)
+{
+    while (!gThreadQuit)
+    {
+        /* Grab the next IO task off the list */
+        FMOD_ASYNCREADINFO *info = NULL;
+        Common_Mutex_Enter(&gListCrit);
+        if (!gList.empty())
+        {
+            info = gList.front()->info;
+            gList.pop_front();
+        }
+        Common_Mutex_Leave(&gListCrit);
+
+        if (info)
+        {
+            /* Example only: Let's deprive the read of the whole block, only give 16kb at a time to make it re-ask for more later */
+            unsigned int toread = info->sizebytes;
+            if (toread > 16384)
+            {
+                toread = 16384;
+            }
+
+            /* Example only: Demonstration of priority influencing turnaround time */
+            for (int i = 0; i < 50; i++)
+            {
+                Common_Sleep(10);
+                if (gSleepBreak)
+                {
+                    AddLine("URGENT REQUEST - reading now!");
+                    gSleepBreak = false;
+                    break;
+                }
+            }
+
+            /* Process the seek and read request with EOF handling */
+            Common_File_Seek(info->handle, info->offset);
+
+            Common_File_Read(info->handle, info->buffer, toread, &info->bytesread);
+            
+            if (info->bytesread < toread)
+            {
+                AddLine("FED     %5d bytes, offset %5d (* EOF)", info->bytesread, info->offset);
+                info->done(info, FMOD_ERR_FILE_EOF);
+            }
+            else
+            {
+                AddLine("FED     %5d bytes, offset %5d", info->bytesread, info->offset);
+                info->done(info, FMOD_OK);
+            }
+        }
+        else
+        {
+            Common_Sleep(10); /* Example only: Use your native filesystem synchronisation to wait for more requests */
+        }
+    }
+
+    gThreadFinished = true;
+}
+
+
+int FMOD_Main()
+{
+    void *extradriverdata = NULL;
+    void *threadhandle = NULL;
+
+    Common_Init(&extradriverdata);
+
+    Common_Mutex_Create(&gLineCrit);
+    Common_Mutex_Create(&gListCrit);
+
+    Common_Thread_Create(ProcessQueue, NULL, &threadhandle);
+
+    /*
+        Create a System object and initialize.
+    */
+    FMOD::System *system = NULL;
+    FMOD_RESULT result = FMOD::System_Create(&system);
+    ERRCHECK(result);
+
+    result = system->init(1, FMOD_INIT_NORMAL, extradriverdata);
+    ERRCHECK(result);
+
+    result = system->setStreamBufferSize(32768, FMOD_TIMEUNIT_RAWBYTES);
+    ERRCHECK(result);
+    
+    result = system->setFileSystem(myopen, myclose, myread, myseek, myasyncread, myasynccancel, 2048);
+    ERRCHECK(result);
+
+    FMOD::Sound *sound = NULL;
+    result = system->createStream(Common_MediaPath("wave.mp3"), FMOD_LOOP_NORMAL | FMOD_2D | FMOD_IGNORETAGS, NULL, &sound);
+    ERRCHECK(result);
+
+    FMOD::Channel *channel = NULL;
+    result = system->playSound(sound, 0, false, &channel);
+    ERRCHECK(result);
+
+    /*
+        Main loop.
+    */
+    do
+    {
+        Common_Update();
+
+        if (sound)
+        {
+            bool starving = false;
+            FMOD_OPENSTATE openstate = FMOD_OPENSTATE_READY;
+            result = sound->getOpenState(&openstate, NULL, &starving, NULL);
+            ERRCHECK(result);
+            
+            if (starving)
+            {
+                AddLine("Starving");
+            }
+
+            result = channel->setMute(starving);
+            ERRCHECK(result);
+        }
+
+        if (Common_BtnPress(BTN_ACTION1))
+        {
+            result = sound->release();
+            if (result == FMOD_OK)
+            {
+                sound = NULL;
+                AddLine("Released sound");
+            }
+        }
+
+        result = system->update();
+        ERRCHECK(result);
+
+        Common_Draw("==================================================");
+        Common_Draw("Async IO Example.");
+        Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+        Common_Draw("==================================================");
+        Common_Draw("");
+        Common_Draw("Press %s to release playing stream", Common_BtnStr(BTN_ACTION1));
+        Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
+        Common_Draw("");
+        DrawLines();
+        Common_Sleep(50);
+    } while (!Common_BtnPress(BTN_QUIT));
+
+    /*
+        Shut down
+    */
+    if (sound)
+    {
+        result = sound->release();
+        ERRCHECK(result);
+    }
+    result = system->close();
+    ERRCHECK(result);
+    result = system->release();
+    ERRCHECK(result);
+
+    gThreadQuit = true;
+    while (!gThreadFinished)
+    {
+        Common_Sleep(10);
+    }
+
+    Common_Mutex_Destroy(&gListCrit);
+    Common_Mutex_Destroy(&gLineCrit);
+    Common_Thread_Destroy(threadhandle);
+    Common_Close();
+
+    return 0;
+}

SimpleGame/FMOD/api/core/examples/channel_groups.cpp

@@ -0,0 +1,189 @@
+/*==============================================================================
+Channel Groups Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to put channels into channel groups, so that you can
+affect a group of channels at a time instead of just one.
+
+For information on using FMOD example code in your own programs, visit
+https://www.fmod.com/legal
+==============================================================================*/
+#include "fmod.hpp"
+#include "common.h"
+
+int FMOD_Main()
+{
+    FMOD::System       *system;
+    FMOD::Sound        *sound[6];
+    FMOD::Channel      *channel[6];
+    FMOD::ChannelGroup *groupA, *groupB, *masterGroup;
+    FMOD_RESULT         result;
+    int                 count;
+    void               *extradriverdata = 0;
+
+    Common_Init(&extradriverdata);
+
+    /*
+        Create a System object and initialize.
+    */
+    result = FMOD::System_Create(&system);
+    ERRCHECK(result);
+
+    result = system->init(32, FMOD_INIT_NORMAL, extradriverdata);
+    ERRCHECK(result);
+
+    result = system->createSound(Common_MediaPath("drumloop.wav"), FMOD_LOOP_NORMAL, 0, &sound[0]);
+    ERRCHECK(result);
+    result = system->createSound(Common_MediaPath("jaguar.wav"), FMOD_LOOP_NORMAL, 0, &sound[1]);
+    ERRCHECK(result);
+    result = system->createSound(Common_MediaPath("swish.wav"), FMOD_LOOP_NORMAL, 0, &sound[2]);
+    ERRCHECK(result);
+    result = system->createSound(Common_MediaPath("c.ogg"), FMOD_LOOP_NORMAL, 0, &sound[3]);
+    ERRCHECK(result);
+    result = system->createSound(Common_MediaPath("d.ogg"), FMOD_LOOP_NORMAL, 0, &sound[4]);
+    ERRCHECK(result);
+    result = system->createSound(Common_MediaPath("e.ogg"), FMOD_LOOP_NORMAL, 0, &sound[5]);
+    ERRCHECK(result);
+
+    result = system->createChannelGroup("Group A", &groupA);
+    ERRCHECK(result);
+    result = system->createChannelGroup("Group B", &groupB);
+    ERRCHECK(result);
+
+    result = system->getMasterChannelGroup(&masterGroup);
+    ERRCHECK(result);
+
+    /*
+        Instead of being independent, set the group A and B to be children of the master group.
+    */
+    result = masterGroup->addGroup(groupA);
+    ERRCHECK(result);
+
+    result = masterGroup->addGroup(groupB);
+    ERRCHECK(result);
+
+    /*
+        Start all the sounds.
+    */
+    for (count = 0; count < 6; count++)
+    {
+        result = system->playSound(sound[count], 0, true, &channel[count]);
+        ERRCHECK(result);
+        
+        result = channel[count]->setChannelGroup((count < 3) ? groupA : groupB);
+        ERRCHECK(result);
+        
+        result = channel[count]->setPaused(false);
+        ERRCHECK(result);
+    }   
+
+    /*
+        Change the volume of each group, just because we can! (reduce overall noise).
+    */
+    result = groupA->setVolume(0.5f);
+    ERRCHECK(result);
+    result = groupB->setVolume(0.5f);
+    ERRCHECK(result);
+
+    /*
+        Main loop.
+    */
+    do
+    {
+        Common_Update();
+
+        if (Common_BtnPress(BTN_ACTION1))
+        {
+            bool mute = true;
+            groupA->getMute(&mute);
+            groupA->setMute(!mute);
+        }
+
+        if (Common_BtnPress(BTN_ACTION2))
+        {
+            bool mute = true;
+            groupB->getMute(&mute);
+            groupB->setMute(!mute);
+        }
+
+        if (Common_BtnPress(BTN_ACTION3))
+        {
+            bool mute = true;
+            masterGroup->getMute(&mute);
+            masterGroup->setMute(!mute);
+        }
+
+        result = system->update();
+        ERRCHECK(result);
+
+        {
+            int channelsplaying = 0;
+
+            result = system->getChannelsPlaying(&channelsplaying, NULL);
+            ERRCHECK(result);
+
+            Common_Draw("==================================================");
+            Common_Draw("Channel Groups Example.");
+            Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+            Common_Draw("==================================================");
+            Common_Draw("");
+            Common_Draw("Group A : drumloop.wav, jaguar.wav, swish.wav");
+            Common_Draw("Group B : c.ogg, d.ogg, e.ogg");
+            Common_Draw("");
+            Common_Draw("Press %s to mute/unmute group A", Common_BtnStr(BTN_ACTION1));
+            Common_Draw("Press %s to mute/unmute group B", Common_BtnStr(BTN_ACTION2));
+            Common_Draw("Press %s to mute/unmute master group", Common_BtnStr(BTN_ACTION3));
+            Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
+            Common_Draw("");
+            Common_Draw("Channels playing %d", channelsplaying);
+        }
+
+        Common_Sleep(50);
+    } while (!Common_BtnPress(BTN_QUIT));
+
+
+    /*
+        A little fade out over 2 seconds.
+    */
+    {
+        float pitch = 1.0f;
+        float vol = 1.0f;
+
+        for (count = 0; count < 200; count++)
+        {
+            masterGroup->setPitch(pitch);
+            masterGroup->setVolume(vol);
+
+            vol   -= (1.0f / 200.0f);
+            pitch -= (0.5f / 200.0f);
+
+            result = system->update();
+            ERRCHECK(result);
+
+            Common_Sleep(10);
+        }
+    }
+
+    /*
+        Shut down.
+    */
+    for (count = 0; count < 6; count++)
+    {
+        result = sound[count]->release();
+        ERRCHECK(result);
+    }
+
+    result = groupA->release();
+    ERRCHECK(result);
+    result = groupB->release();
+    ERRCHECK(result);
+
+    result = system->close();
+    ERRCHECK(result);
+    result = system->release();
+    ERRCHECK(result);
+
+    Common_Close();
+
+    return 0;
+}

SimpleGame/FMOD/api/core/examples/common.cpp

@@ -0,0 +1,234 @@
+/*==============================================================================
+FMOD Example Framework
+Copyright (c), Firelight Technologies Pty, Ltd 2012-2025.
+==============================================================================*/
+#include "common.h"
+#include "fmod_errors.h"
+
+/* Cross platform OS Functions internal to the FMOD library, exposed for the example framework. */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct FMOD_OS_FILE            FMOD_OS_FILE;
+typedef struct FMOD_OS_CRITICALSECTION FMOD_OS_CRITICALSECTION;
+
+FMOD_RESULT F_API FMOD_OS_Time_GetUs(unsigned int *us);
+FMOD_RESULT F_API FMOD_OS_Debug_Output(const char *format, ...);
+FMOD_RESULT F_API FMOD_OS_File_Open(const char *name, int mode, unsigned int *filesize, FMOD_OS_FILE **handle);
+FMOD_RESULT F_API FMOD_OS_File_Close(FMOD_OS_FILE *handle);
+FMOD_RESULT F_API FMOD_OS_File_Read(FMOD_OS_FILE *handle, void *buf, unsigned int count, unsigned int *read);
+FMOD_RESULT F_API FMOD_OS_File_Write(FMOD_OS_FILE *handle, const void *buffer, unsigned int bytesToWrite, bool flush);
+FMOD_RESULT F_API FMOD_OS_File_Seek(FMOD_OS_FILE *handle, unsigned int offset);
+FMOD_RESULT F_API FMOD_OS_Time_Sleep(unsigned int ms);
+FMOD_RESULT F_API FMOD_OS_CriticalSection_Create(FMOD_OS_CRITICALSECTION **crit, bool memorycrit);
+FMOD_RESULT F_API FMOD_OS_CriticalSection_Free(FMOD_OS_CRITICALSECTION *crit, bool memorycrit);
+FMOD_RESULT F_API FMOD_OS_CriticalSection_Enter(FMOD_OS_CRITICALSECTION *crit);
+FMOD_RESULT F_API FMOD_OS_CriticalSection_Leave(FMOD_OS_CRITICALSECTION *crit);
+FMOD_RESULT F_API FMOD_OS_CriticalSection_TryEnter(FMOD_OS_CRITICALSECTION *crit, bool *entered);
+FMOD_RESULT F_API FMOD_OS_CriticalSection_IsLocked(FMOD_OS_CRITICALSECTION *crit, bool *locked);
+FMOD_RESULT F_API FMOD_OS_Thread_Create(const char *name, void (*callback)(void *param), void *param, FMOD_THREAD_AFFINITY affinity, FMOD_THREAD_PRIORITY priority, FMOD_THREAD_STACK_SIZE stacksize, void **handle);
+FMOD_RESULT F_API FMOD_OS_Thread_Destroy(void *handle);
+
+#ifdef __cplusplus
+}
+#endif
+
+void (*Common_Private_Error)(FMOD_RESULT, const char *, int);
+
+void ERRCHECK_fn(FMOD_RESULT result, const char *file, int line)
+{
+    if (result != FMOD_OK)
+    {
+        if (Common_Private_Error)
+        {
+            Common_Private_Error(result, file, line);
+        }
+        Common_Fatal("%s(%d): FMOD error %d - %s", file, line, result, FMOD_ErrorString(result));
+    }
+}
+
+void Common_Format(char *buffer, int bufferSize, const char *formatString...)
+{
+    va_list args;
+    va_start(args, formatString);
+    Common_vsnprintf(buffer, bufferSize, formatString, args);
+    va_end(args);
+    buffer[bufferSize-1] = '\0';
+}
+
+void Common_Fatal(const char *format, ...)
+{
+    char error[1024];
+
+    va_list args;
+    va_start(args, format);
+    Common_vsnprintf(error, 1024, format, args);
+    va_end(args);
+    error[1023] = '\0';
+
+    do
+    {
+        Common_Draw("A fatal error has occurred...");
+        Common_Draw("");
+        Common_Draw("%s", error);
+        Common_Draw("");
+        Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
+
+        Common_Update();
+        Common_Sleep(50);
+    } while (!Common_BtnPress(BTN_QUIT));
+
+    Common_Exit(0);
+}
+
+void Common_Draw(const char *format, ...)
+{
+    char string[1024];
+    char *stringPtr = string;
+
+    va_list args;
+    va_start(args, format);
+    Common_vsnprintf(string, 1024, format, args);
+    va_end(args);
+    string[1023] = '\0';
+
+    unsigned int length = (unsigned int)strlen(string);
+
+    do
+    {
+        bool consumeNewLine = false;
+        unsigned int copyLength = length;
+
+        // Search for new line characters
+        char *newLinePtr = strchr(stringPtr, '\n');
+        if (newLinePtr)
+        {
+            consumeNewLine = true;
+            copyLength = (unsigned int)(newLinePtr - stringPtr);
+        }
+
+        if (copyLength > NUM_COLUMNS)
+        {
+            // Hard wrap by default
+            copyLength = NUM_COLUMNS;
+
+            // Loop for a soft wrap
+            for (int i = NUM_COLUMNS - 1; i >= 0; i--)
+            {
+                if (stringPtr[i] == ' ')
+                {
+                    copyLength = i + 1;
+                    break;
+                }
+            }
+        }
+
+        // Null terminate the sub string temporarily by swapping out a char
+        char tempChar = stringPtr[copyLength];
+        stringPtr[copyLength] = 0;
+        Common_DrawText(stringPtr);
+        stringPtr[copyLength] = tempChar;
+
+        copyLength += (consumeNewLine ? 1 : 0);
+        length -= copyLength;
+        stringPtr += copyLength;
+    } while (length > 0);
+}
+
+void Common_Time_GetUs(unsigned int *us)
+{
+    FMOD_OS_Time_GetUs(us);
+}
+
+void Common_Log(const char *format, ...)
+{
+    char string[1024];
+
+    va_list args;
+    va_start(args, format);
+    Common_vsnprintf(string, 1024, format, args);
+    va_end(args);
+    string[1023] = '\0';
+
+    FMOD_OS_Debug_Output(string);
+}
+
+void Common_LoadFileMemory(const char *name, void **buff, int *length)
+{
+    FMOD_OS_FILE *file = NULL;
+    unsigned int len, bytesread;
+
+    FMOD_OS_File_Open(name, 0, &len, &file);
+    void *mem = malloc(len);
+    FMOD_OS_File_Read(file, mem, len, &bytesread);
+    FMOD_OS_File_Close(file);
+
+    *buff = mem;
+    *length = bytesread;
+}
+
+void Common_UnloadFileMemory(void *buff)
+{
+    free(buff);
+}
+
+void Common_Sleep(unsigned int ms)
+{
+    FMOD_OS_Time_Sleep(ms);
+}
+
+void Common_File_Open(const char *name, int mode, unsigned int *filesize, void **handle)
+{
+    FMOD_OS_File_Open(name, mode, filesize, (FMOD_OS_FILE **)handle);
+}
+
+void Common_File_Close(void *handle)
+{
+    FMOD_OS_File_Close((FMOD_OS_FILE *)handle);
+}
+
+void Common_File_Read(void *handle, void *buf, unsigned int length, unsigned int *read)
+{
+    FMOD_OS_File_Read((FMOD_OS_FILE *)handle, buf, length, read);
+}
+
+void Common_File_Write(void *handle, void *buf, unsigned int length)
+{
+    FMOD_OS_File_Write((FMOD_OS_FILE *)handle, buf, length, true);
+}
+
+void Common_File_Seek(void *handle, unsigned int offset)
+{
+    FMOD_OS_File_Seek((FMOD_OS_FILE *)handle, offset);
+}
+
+void Common_Mutex_Create(Common_Mutex *mutex)
+{
+    FMOD_OS_CriticalSection_Create((FMOD_OS_CRITICALSECTION **)&mutex->crit, false);
+}
+
+void Common_Mutex_Destroy(Common_Mutex *mutex)
+{
+    FMOD_OS_CriticalSection_Free((FMOD_OS_CRITICALSECTION *)mutex->crit, false);
+}
+
+void Common_Mutex_Enter(Common_Mutex *mutex)
+{
+    FMOD_OS_CriticalSection_Enter((FMOD_OS_CRITICALSECTION *)mutex->crit);
+}
+
+void Common_Mutex_Leave(Common_Mutex *mutex)
+{
+    FMOD_OS_CriticalSection_Leave((FMOD_OS_CRITICALSECTION *)mutex->crit);
+}
+
+void Common_Thread_Create(void (*callback)(void *param), void *param, void **handle)
+{
+    FMOD_OS_Thread_Create("FMOD Example Thread", callback, param, FMOD_THREAD_AFFINITY_GROUP_A, FMOD_THREAD_PRIORITY_MEDIUM, (16 * 1024), handle);
+}
+
+void Common_Thread_Destroy(void *handle)
+{
+    FMOD_OS_Thread_Destroy(handle);
+}

SimpleGame/FMOD/api/core/examples/common.h

@@ -0,0 +1,93 @@
+/*==============================================================================
+FMOD Example Framework
+Copyright (c), Firelight Technologies Pty, Ltd 2012-2025.
+==============================================================================*/
+#ifndef FMOD_EXAMPLES_COMMON_H
+#define FMOD_EXAMPLES_COMMON_H
+
+#include "common_platform.h"
+#include "fmod.h"
+
+#include <stddef.h>
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <assert.h>
+
+#define NUM_COLUMNS 50
+#define NUM_ROWS 25
+
+#ifndef Common_Sin
+    #define Common_Sin sin
+#endif
+
+#ifndef Common_snprintf
+    #define Common_snprintf snprintf
+#endif
+
+#ifndef Common_vsnprintf
+    #define Common_vsnprintf vsnprintf
+#endif
+
+enum Common_Button
+{
+    BTN_ACTION1,
+    BTN_ACTION2,
+    BTN_ACTION3,
+    BTN_ACTION4,
+    BTN_LEFT,
+    BTN_RIGHT,
+    BTN_UP,
+    BTN_DOWN,
+    BTN_MORE,
+    BTN_QUIT
+};
+
+typedef struct
+{
+    void *crit;
+} Common_Mutex;
+
+/* Cross platform functions (common) */
+void Common_Format(char *buffer, int bufferSize, const char *formatString...);
+void Common_Fatal(const char *format, ...);
+void Common_Draw(const char *format, ...);
+void Common_Time_GetUs(unsigned int *us);
+void Common_Log(const char *format, ...);
+void Common_LoadFileMemory(const char *name, void **buff, int *length);
+void Common_UnloadFileMemory(void *buff);
+void Common_Sleep(unsigned int ms);
+void Common_File_Open(const char *name, int mode, unsigned int *filesize, void **handle);   // mode : 0 = read, 1 = write.
+void Common_File_Close(void *handle);
+void Common_File_Read(void *handle, void *buf, unsigned int length, unsigned int *read);
+void Common_File_Write(void *handle, void *buf, unsigned int length);
+void Common_File_Seek(void *handle, unsigned int offset);
+void Common_Mutex_Create(Common_Mutex *mutex);
+void Common_Mutex_Destroy(Common_Mutex *mutex);
+void Common_Mutex_Enter(Common_Mutex *mutex);
+void Common_Mutex_Leave(Common_Mutex *mutex);
+void Common_Thread_Create(void (*callback)(void *param), void *param, void **handle);
+void Common_Thread_Destroy(void *handle);
+
+void ERRCHECK_fn(FMOD_RESULT result, const char *file, int line);
+#define ERRCHECK(_result) ERRCHECK_fn(_result, __FILE__, __LINE__)
+#define Common_Max(_a, _b) ((_a) > (_b) ? (_a) : (_b))
+#define Common_Min(_a, _b) ((_a) < (_b) ? (_a) : (_b))
+#define Common_Clamp(_min, _val, _max) ((_val) < (_min) ? (_min) : ((_val) > (_max) ? (_max) : (_val)))
+
+/* Functions with platform specific implementation (common_platform) */
+void Common_Init(void **extraDriverData);
+void Common_Close();
+void Common_Update();
+void Common_Exit(int returnCode);
+void Common_DrawText(const char *text);
+bool Common_BtnPress(Common_Button btn);
+bool Common_BtnDown(Common_Button btn);
+const char *Common_BtnStr(Common_Button btn);
+const char *Common_MediaPath(const char *fileName);
+const char *Common_WritePath(const char *fileName);
+
+
+#endif

SimpleGame/FMOD/api/core/examples/common_platform.cpp

@@ -0,0 +1,306 @@
+/*==============================================================================
+FMOD Example Framework
+Copyright (c), Firelight Technologies Pty, Ltd 2012-2025.
+==============================================================================*/
+#define WIN32_LEAN_AND_MEAN
+
+#include "common.h"
+#include <stdio.h>
+#include <conio.h>
+#include <Windows.h>
+#include <Objbase.h>
+#include <vector>
+
+static HWND gWindow = nullptr;
+static int gScreenWidth = 0;
+static int gScreenHeight = 0;
+static unsigned int gPressedButtons = 0;
+static unsigned int gDownButtons = 0;
+static unsigned int gLastDownButtons = 0;
+static char gWriteBuffer[(NUM_COLUMNS+1) * NUM_ROWS] = {0};
+static char gDisplayBuffer[(NUM_COLUMNS+1) * NUM_ROWS] = {0};
+static unsigned int gYPos = 0;
+static bool gQuit = false;
+static std::vector<char *> gPathList;
+
+bool Common_Private_Test;
+int Common_Private_Argc;
+char** Common_Private_Argv;
+void (*Common_Private_Update)(unsigned int*);
+void (*Common_Private_Print)(const char*);
+void (*Common_Private_Close)();
+
+void Common_Init(void** /*extraDriverData*/)
+{
+    CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
+}
+
+void Common_Close()
+{
+    CoUninitialize();
+
+    for (std::vector<char *>::iterator item = gPathList.begin(); item != gPathList.end(); ++item)
+    {
+        free(*item);
+    }
+    if (Common_Private_Close)
+    {
+        Common_Private_Close();
+    }
+}
+
+static unsigned int translateButton(unsigned int button)
+{
+    switch (button)
+    {
+        case '1':       return (1 << BTN_ACTION1);
+        case '2':       return (1 << BTN_ACTION2);
+        case '3':       return (1 << BTN_ACTION3);
+        case '4':       return (1 << BTN_ACTION4);
+        case VK_LEFT:   return (1 << BTN_LEFT);
+        case VK_RIGHT:  return (1 << BTN_RIGHT);
+        case VK_UP:     return (1 << BTN_UP);
+        case VK_DOWN:   return (1 << BTN_DOWN);
+        case VK_SPACE:  return (1 << BTN_MORE);
+        case VK_ESCAPE: return (1 << BTN_QUIT);
+        default:        return 0;
+    }
+}
+
+void Common_Update()
+{
+    MSG msg = { };
+    while (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE))
+    {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+
+    gPressedButtons = (gLastDownButtons ^ gDownButtons) & gDownButtons;
+    gPressedButtons |= (gQuit ? (1 << BTN_QUIT) : 0);
+    gLastDownButtons = gDownButtons;
+
+    memcpy(gDisplayBuffer, gWriteBuffer, sizeof(gWriteBuffer));
+    InvalidateRect(gWindow, nullptr, FALSE);
+
+    gYPos = 0;
+    memset(gWriteBuffer, ' ', sizeof(gWriteBuffer));
+    for (int i = 0; i < NUM_ROWS; i++)
+    {
+        gWriteBuffer[(i * (NUM_COLUMNS + 1)) + NUM_COLUMNS] = '\n';
+    }
+
+    if (Common_Private_Update)
+    {
+        Common_Private_Update(&gPressedButtons);
+    }
+}
+
+void Common_Exit(int returnCode)
+{
+    exit(returnCode);
+}
+
+void Common_DrawText(const char *text)
+{
+    if (gYPos < NUM_ROWS)
+    {
+        char tempBuffer[NUM_COLUMNS + 1];
+        Common_Format(tempBuffer, sizeof(tempBuffer), "%s", text);
+        memcpy(&gWriteBuffer[gYPos * (NUM_COLUMNS + 1)], tempBuffer, strlen(tempBuffer));
+        gYPos++;
+    }
+}
+
+bool Common_BtnPress(Common_Button btn)
+{
+    return ((gPressedButtons & (1 << btn)) != 0);
+}
+
+bool Common_BtnDown(Common_Button btn)
+{
+    return ((gDownButtons & (1 << btn)) != 0);
+}
+
+const char *Common_BtnStr(Common_Button btn)
+{
+    switch (btn)
+    {
+        case BTN_ACTION1:   return "1";
+        case BTN_ACTION2:   return "2";
+        case BTN_ACTION3:   return "3";
+        case BTN_ACTION4:   return "4";
+        case BTN_LEFT:      return "Left";
+        case BTN_RIGHT:     return "Right";
+        case BTN_UP:        return "Up";
+        case BTN_DOWN:      return "Down";
+        case BTN_MORE:      return "Space";
+        case BTN_QUIT:      return "Escape";
+        default:            return "Unknown";
+    }
+}
+
+const char *Common_MediaPath(const char *fileName)
+{
+    char *filePath = (char *)calloc(256, sizeof(char));
+
+    static const char* pathPrefix = nullptr;
+    if (!pathPrefix)
+    {
+        const char *emptyPrefix = "";
+        const char *mediaPrefix = "../media/";
+        FILE *file = fopen(fileName, "r");
+        if (file)
+        {
+            fclose(file);
+            pathPrefix = emptyPrefix;
+        }
+        else
+        {
+            pathPrefix = mediaPrefix;
+        }
+    }
+
+    strcat(filePath, pathPrefix);
+    strcat(filePath, fileName);
+
+    gPathList.push_back(filePath);
+
+    return filePath;
+}
+
+const char *Common_WritePath(const char *fileName)
+{
+	return Common_MediaPath(fileName);
+}
+
+void Common_TTY(const char *format, ...)
+{
+    char string[1024] = {0};
+
+    va_list args;
+    va_start(args, format);
+    Common_vsnprintf(string, 1023, format, args);
+    va_end(args);
+
+    if (Common_Private_Print)
+    {
+        (*Common_Private_Print)(string);
+    }
+    else
+    {
+        OutputDebugStringA(string);
+    }
+}
+
+HFONT CreateDisplayFont()
+{
+    return CreateFontA(22, 0, 0, 0, FW_DONTCARE, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_OUTLINE_PRECIS,
+        CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, FIXED_PITCH, 0);
+}
+
+LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+    if (message == WM_PAINT)
+    {
+        PAINTSTRUCT ps;
+        HDC hdc = BeginPaint(hWnd, &ps);
+        HDC hdcBack = CreateCompatibleDC(hdc);
+        
+        HBITMAP hbmBack = CreateCompatibleBitmap(hdc, gScreenWidth, gScreenHeight);
+        HBITMAP hbmOld = (HBITMAP)SelectObject(hdcBack, hbmBack);
+
+        HFONT hfnt = CreateDisplayFont();
+        HFONT hfntOld = (HFONT)SelectObject(hdcBack, hfnt);
+
+        SetBkColor(hdcBack, RGB(0x0, 0x0, 0x0));
+        SetTextColor(hdcBack, RGB(0xFF, 0xFF, 0xFF));
+        DrawTextA(hdcBack, gDisplayBuffer, -1, &ps.rcPaint, 0);
+        BitBlt(hdc, 0, 0, gScreenWidth, gScreenHeight, hdcBack, 0, 0, SRCCOPY);
+
+        SelectObject(hdcBack, hfntOld);
+        DeleteObject(hfnt);
+
+        SelectObject(hdcBack, hbmOld);
+        DeleteObject(hbmBack);
+
+        DeleteDC(hdcBack);
+        EndPaint(hWnd, &ps);
+    }
+    else if (message == WM_DESTROY)
+    {
+        gQuit = true;
+    }
+    else if (message == WM_GETMINMAXINFO)
+    {
+        if (gScreenWidth == 0)
+        {
+            HDC hdc = GetDC(hWnd);
+
+            HFONT hfnt = CreateDisplayFont();
+            HFONT hfntOld = (HFONT)SelectObject(hdc, hfnt);
+
+            TEXTMETRICA metrics = { };
+            GetTextMetricsA(hdc, &metrics);
+
+            SelectObject(hdc, hfntOld);
+            DeleteObject(hfnt);
+
+            ReleaseDC(hWnd, hdc);
+
+            RECT rec = { };
+            rec.right = metrics.tmAveCharWidth * NUM_COLUMNS;
+            rec.bottom = metrics.tmHeight * NUM_ROWS;
+
+            BOOL success = AdjustWindowRect(&rec, WS_CAPTION | WS_SYSMENU, FALSE);
+            assert(success);
+
+            gScreenWidth = rec.right - rec.left;
+            gScreenHeight = rec.bottom - rec.top;
+        }
+
+        LPMINMAXINFO lpMMI = (LPMINMAXINFO)lParam;
+        lpMMI->ptMinTrackSize.x = gScreenWidth;
+        lpMMI->ptMinTrackSize.y = gScreenHeight;
+        lpMMI->ptMaxTrackSize = lpMMI->ptMinTrackSize;
+    }
+    else if (message == WM_KEYDOWN)
+    {
+        gDownButtons |= translateButton((unsigned int)wParam);
+    }
+    else if (message == WM_KEYUP)
+    {
+        gDownButtons &= ~translateButton((unsigned int)wParam);
+    }
+    else
+    {
+        return DefWindowProc(hWnd, message, wParam, lParam);
+    }
+
+    return 0;
+}
+
+int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, PSTR /*pCmdLine*/, int nCmdShow)
+{
+    const char CLASS_NAME[] = "FMOD Example Window Class";
+
+    Common_Private_Argc = __argc;
+    Common_Private_Argv = __argv;
+
+    WNDCLASSA wc = { };
+    wc.style = CS_HREDRAW | CS_VREDRAW;
+    wc.lpfnWndProc = WndProc;
+    wc.hInstance = hInstance;
+    wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
+    wc.lpszClassName = CLASS_NAME;
+
+    ATOM atom = RegisterClassA(&wc);
+    assert(atom);
+
+    gWindow = CreateWindowA(CLASS_NAME, "FMOD Example", WS_CAPTION | WS_SYSMENU, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, nullptr, nullptr, hInstance, nullptr);
+    assert(gWindow);
+
+    ShowWindow(gWindow, nCmdShow);
+
+    return FMOD_Main();
+}

SimpleGame/FMOD/api/core/examples/common_platform.h

@@ -0,0 +1,16 @@
+/*==============================================================================
+FMOD Example Framework
+Copyright (c), Firelight Technologies Pty, Ltd 2012-2025.
+==============================================================================*/
+#include <windows.h>
+
+int FMOD_Main();
+
+#define COMMON_PLATFORM_SUPPORTS_FOPEN
+
+#define Common_snprintf _snprintf
+#define Common_vsnprintf _vsnprintf
+
+void Common_TTY(const char *format, ...);
+
+

SimpleGame/FMOD/api/core/examples/convolution_reverb.cpp

@@ -0,0 +1,239 @@
+/*==============================================================================
+Convolution Reverb Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to set up a convolution reverb DSP as a global
+DSP unit that can be routed into by multiple seperate channels.
+
+Convolution reverb uses data from a real world locations called an 
+"Impulse Response" to model the reflection of audio waves back
+to a listener.
+
+Impulse Response is based on "St Andrew's Church" by
+
+    www.openairlib.net
+    Audiolab, University of York
+    Damian T. Murphy
+    http://www.openairlib.net/auralizationdb/content/st-andrews-church
+
+licensed under Attribution Share Alike Creative Commons license
+http://creativecommons.org/licenses/by-sa/3.0/
+
+
+Anechoic sample "Operatic Voice" by 
+
+    www.openairlib.net
+    http://www.openairlib.net/anechoicdb/content/operatic-voice
+
+licensed under Attribution Share Alike Creative Commons license
+http://creativecommons.org/licenses/by-sa/3.0/
+
+
+### Features Demonstrated ###
++ FMOD_DSP_CONVOLUTION_REVERB
++ DSP::addInput
+
+For information on using FMOD example code in your own programs, visit
+https://www.fmod.com/legal
+
+==============================================================================*/
+#include "fmod.hpp"
+#include "common.h"
+
+int FMOD_Main()
+{
+    void *extradriverdata = 0;    
+    Common_Init(&extradriverdata);
+
+    /*
+        Create a System object and initialize
+    */
+    FMOD_RESULT result;
+    FMOD::System* system;
+    result = FMOD::System_Create(&system);
+    ERRCHECK(result);
+    
+    result = system->init(32, FMOD_INIT_NORMAL, extradriverdata);
+    ERRCHECK(result);
+        
+
+    /*
+        Create a new channel group to hold the convolution DSP unit
+    */
+    FMOD::ChannelGroup* reverbGroup;
+    result = system->createChannelGroup("reverb", &reverbGroup);
+    ERRCHECK(result);
+
+    
+    /*
+        Create a new channel group to hold all the channels and process the dry path
+    */
+    FMOD::ChannelGroup* mainGroup;
+    result = system->createChannelGroup("main", &mainGroup);
+    ERRCHECK(result);
+
+    /*
+        Create the convultion DSP unit and set it as the tail of the channel group
+    */
+    FMOD::DSP* reverbUnit;    
+    result = system->createDSPByType(FMOD_DSP_TYPE_CONVOLUTIONREVERB, &reverbUnit);
+    ERRCHECK(result);
+    result = reverbGroup->addDSP(FMOD_CHANNELCONTROL_DSP_TAIL, reverbUnit);
+    ERRCHECK(result);
+
+    /*
+        Open the impulse response wav file, but use FMOD_OPENONLY as we want
+        to read the data into a seperate buffer
+    */
+    FMOD::Sound* irSound;
+    result = system->createSound(Common_MediaPath("standrews.wav"), FMOD_DEFAULT | FMOD_OPENONLY, NULL, &irSound);
+    ERRCHECK(result);
+
+    /*
+        Retrieve the sound information for the Impulse Response input file
+    */
+    FMOD_SOUND_FORMAT irSoundFormat;
+    FMOD_SOUND_TYPE irSoundType;
+    int irSoundBits, irSoundChannels;
+    result = irSound->getFormat(&irSoundType, &irSoundFormat, &irSoundChannels, &irSoundBits);
+    ERRCHECK(result);
+    unsigned int irSoundLength;
+    result = irSound->getLength(&irSoundLength, FMOD_TIMEUNIT_PCM);
+    ERRCHECK(result);
+
+    
+    if (irSoundFormat != FMOD_SOUND_FORMAT_PCM16)
+    {
+        /*
+            For simplicity of the example, if the impulse response is the wrong format just display an error
+        */        
+        Common_Fatal("Impulse Response file is the wrong audio format");
+    }
+
+    /*
+        The reverb unit expects a block of data containing a single 16 bit int containing
+        the number of channels in the impulse response, followed by PCM 16 data
+    */
+    unsigned int irDataLength = sizeof(short) * (irSoundLength * irSoundChannels + 1);
+    short* irData = (short*)malloc(irDataLength);
+    irData[0] = (short)irSoundChannels;
+    unsigned int irDataRead;
+    result = irSound->readData(&irData[1], irDataLength - sizeof(short), &irDataRead);
+    ERRCHECK(result);
+    result = reverbUnit->setParameterData(FMOD_DSP_CONVOLUTION_REVERB_PARAM_IR, irData, irDataLength);
+    ERRCHECK(result);
+
+    /*
+        Don't pass any dry signal from the reverb unit, instead take the dry part
+        of the mix from the main signal path
+    */
+    result = reverbUnit->setParameterFloat(FMOD_DSP_CONVOLUTION_REVERB_PARAM_DRY, -80.0f);    
+    ERRCHECK(result);
+
+    /*
+        We can now free our copy of the IR data and release the sound object, the reverb unit 
+        has created it's internal data
+    */
+    free(irData);
+    result = irSound->release();
+    ERRCHECK(result);
+    
+    /*
+        Load up and play a sample clip recorded in an anechoic chamber
+    */
+    FMOD::Sound* sound;
+    system->createSound(Common_MediaPath("singing.wav"), FMOD_3D | FMOD_LOOP_NORMAL, NULL, &sound);
+    ERRCHECK(result);
+
+    FMOD::Channel* channel;
+    system->playSound(sound, mainGroup, true, &channel);
+    ERRCHECK(result);
+    
+    /*
+        Create a send connection between the channel head and the reverb unit
+    */
+    FMOD::DSP* channelHead;
+    channel->getDSP(FMOD_CHANNELCONTROL_DSP_HEAD, &channelHead);
+    ERRCHECK(result);
+    FMOD::DSPConnection* reverbConnection;
+    result = reverbUnit->addInput(channelHead, &reverbConnection, FMOD_DSPCONNECTION_TYPE_SEND);
+    ERRCHECK(result);
+
+    result = channel->setPaused(false);
+    ERRCHECK(result);
+
+
+    float wetVolume = 1.0;
+    float dryVolume = 1.0;
+
+    /*
+        Main loop
+    */
+    do
+    {
+        Common_Update();
+
+        if (Common_BtnPress(BTN_LEFT))
+        {
+            wetVolume = (wetVolume <= 0.0f) ? wetVolume : wetVolume - 0.05f;
+        }
+        if (Common_BtnPress(BTN_RIGHT))
+        {
+            wetVolume = (wetVolume >= 1.0f) ? wetVolume : wetVolume + 0.05f;
+        }        
+        if (Common_BtnPress(BTN_DOWN))
+        {
+            dryVolume = (dryVolume <= 0.0f) ? dryVolume : dryVolume - 0.05f;
+        }
+        if (Common_BtnPress(BTN_UP))
+        {
+            dryVolume = (dryVolume >= 1.0f) ? dryVolume : dryVolume + 0.05f;
+        }
+        
+
+        result = system->update();
+        ERRCHECK(result);
+
+        result = reverbConnection->setMix(wetVolume);
+        ERRCHECK(result);
+        result = mainGroup->setVolume(dryVolume);
+        ERRCHECK(result);
+
+
+        Common_Draw("==================================================");
+        Common_Draw("Convolution Example.");
+        Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+        Common_Draw("==================================================");
+        Common_Draw("Press %s and %s to change dry mix", Common_BtnStr(BTN_UP), Common_BtnStr(BTN_DOWN));
+        Common_Draw("Press %s and %s to change wet mix", Common_BtnStr(BTN_LEFT), Common_BtnStr(BTN_RIGHT));
+        Common_Draw("wet mix [%.2f] dry mix [%.2f]", wetVolume, dryVolume);
+        Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
+        Common_Draw("");
+
+        Common_Sleep(50);
+    } while (!Common_BtnPress(BTN_QUIT));
+
+    /*
+        Shut down
+    */
+    result = sound->release();
+    ERRCHECK(result);
+    result = mainGroup->release();
+    ERRCHECK(result);
+    result = reverbGroup->removeDSP(reverbUnit);
+    ERRCHECK(result);
+    result = reverbUnit->disconnectAll(true, true);
+    ERRCHECK(result);
+    result = reverbUnit->release();
+    ERRCHECK(result);
+    result = reverbGroup->release();
+    ERRCHECK(result);
+    result = system->close();
+    ERRCHECK(result);
+    result = system->release();
+    ERRCHECK(result);
+
+    Common_Close();
+
+    return 0;
+}

SimpleGame/FMOD/api/core/examples/dsp_custom.cpp

@@ -0,0 +1,362 @@
+/*==============================================================================
+Custom DSP Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to add a user created DSP callback to process audio 
+data. The read callback is executed at runtime, and can be added anywhere in
+the DSP network.
+
+For information on using FMOD example code in your own programs, visit
+https://www.fmod.com/legal
+==============================================================================*/
+#include "fmod.hpp"
+#include "common.h"
+
+typedef struct 
+{
+    float *buffer;
+    float volume_linear;
+    int   length_samples;
+    int   channels;
+} mydsp_data_t;
+
+FMOD_RESULT F_CALL myDSPCallback(FMOD_DSP_STATE *dsp_state, float *inbuffer, float *outbuffer, unsigned int length, int inchannels, int *outchannels) 
+{
+    mydsp_data_t *data = (mydsp_data_t *)dsp_state->plugindata;
+
+    /*
+        This loop assumes inchannels = outchannels, which it will be if the DSP is created with '0' 
+        as the number of channels in FMOD_DSP_DESCRIPTION.  
+        Specifying an actual channel count will mean you have to take care of any number of channels coming in,
+        but outputting the number of channels specified. Generally it is best to keep the channel 
+        count at 0 for maximum compatibility.
+    */
+    for (unsigned int samp = 0; samp < length; samp++) 
+    { 
+        /*
+            Feel free to unroll this.
+        */
+        for (int chan = 0; chan < *outchannels; chan++)
+        {
+            /* 
+                This DSP filter just halves the volume! 
+                Input is modified, and sent to output.
+            */
+            data->buffer[(samp * *outchannels) + chan] = outbuffer[(samp * inchannels) + chan] = inbuffer[(samp * inchannels) + chan] * data->volume_linear;
+        }
+    }
+
+    data->channels = inchannels;
+
+    return FMOD_OK; 
+} 
+
+/*
+    Callback called when DSP is created.   This implementation creates a structure which is attached to the dsp state's 'plugindata' member.
+*/
+FMOD_RESULT F_CALL myDSPCreateCallback(FMOD_DSP_STATE *dsp_state)
+{
+    unsigned int blocksize;
+    FMOD_RESULT result;
+
+    result = dsp_state->functions->getblocksize(dsp_state, &blocksize);
+    ERRCHECK(result);
+
+    mydsp_data_t *data = (mydsp_data_t *)calloc(sizeof(mydsp_data_t), 1);
+    if (!data)
+    {
+        return FMOD_ERR_MEMORY;
+    }
+    dsp_state->plugindata = data;
+    data->volume_linear = 1.0f;
+    data->length_samples = blocksize;
+
+    data->buffer = (float *)malloc(blocksize * 8 * sizeof(float));      // *8 = maximum size allowing room for 7.1.   Could ask dsp_state->functions->getspeakermode for the right speakermode to get real speaker count.
+    if (!data->buffer)
+    {
+        return FMOD_ERR_MEMORY;
+    }
+
+    return FMOD_OK;
+}
+
+/*
+    Callback called when DSP is destroyed.   The memory allocated in the create callback can be freed here.
+*/
+FMOD_RESULT F_CALL myDSPReleaseCallback(FMOD_DSP_STATE *dsp_state)
+{
+    if (dsp_state->plugindata)
+    {
+        mydsp_data_t *data = (mydsp_data_t *)dsp_state->plugindata;
+
+        if (data->buffer)
+        {
+            free(data->buffer);
+        }
+
+        free(data);
+    }
+
+    return FMOD_OK;
+}
+
+/*
+    Callback called when DSP::getParameterData is called.   This returns a pointer to the raw floating point PCM data.
+    We have set up 'parameter 0' to be the data parameter, so it checks to make sure the passed in index is 0, and nothing else.
+*/
+FMOD_RESULT F_CALL myDSPGetParameterDataCallback(FMOD_DSP_STATE *dsp_state, int index, void **data, unsigned int *length, char *)
+{
+    if (index == 0)
+    {
+        unsigned int blocksize;
+        FMOD_RESULT result;
+        mydsp_data_t *mydata = (mydsp_data_t *)dsp_state->plugindata;
+
+        result = dsp_state->functions->getblocksize(dsp_state, &blocksize);
+        ERRCHECK(result);
+
+        *data = (void *)mydata;
+        *length = blocksize * 2 * sizeof(float);
+
+        return FMOD_OK;
+    }
+
+    return FMOD_ERR_INVALID_PARAM;
+}
+
+/*
+    Callback called when DSP::setParameterFloat is called.   This accepts a floating point 0 to 1 volume value, and stores it.
+    We have set up 'parameter 1' to be the volume parameter, so it checks to make sure the passed in index is 1, and nothing else.
+*/
+FMOD_RESULT F_CALL myDSPSetParameterFloatCallback(FMOD_DSP_STATE *dsp_state, int index, float value)
+{
+    if (index == 1)
+    {
+        mydsp_data_t *mydata = (mydsp_data_t *)dsp_state->plugindata;
+
+        mydata->volume_linear = value;
+
+        return FMOD_OK;
+    }
+
+    return FMOD_ERR_INVALID_PARAM;
+}
+
+/*
+    Callback called when DSP::getParameterFloat is called.   This returns a floating point 0 to 1 volume value.
+    We have set up 'parameter 1' to be the volume parameter, so it checks to make sure the passed in index is 1, and nothing else.
+    An alternate way of displaying the data is provided, as a string, so the main app can use it.
+*/
+FMOD_RESULT F_CALL myDSPGetParameterFloatCallback(FMOD_DSP_STATE *dsp_state, int index, float *value, char *valstr)
+{
+    if (index == 1)
+    {
+        mydsp_data_t *mydata = (mydsp_data_t *)dsp_state->plugindata;
+
+        *value = mydata->volume_linear;
+        if (valstr)
+        {
+            snprintf(valstr, FMOD_DSP_GETPARAM_VALUESTR_LENGTH, "%d", (int)((*value * 100.0f)+0.5f));
+        }
+
+        return FMOD_OK;
+    }
+
+    return FMOD_ERR_INVALID_PARAM;
+}
+
+int FMOD_Main()
+{
+    FMOD::System       *system;
+    FMOD::Sound        *sound;
+    FMOD::Channel      *channel;
+    FMOD::DSP          *mydsp;
+    FMOD::ChannelGroup *mastergroup;
+    FMOD_RESULT         result;
+    void               *extradriverdata = 0;
+
+    Common_Init(&extradriverdata);
+
+    /*
+        Create a System object and initialize.
+    */
+    result = FMOD::System_Create(&system);
+    ERRCHECK(result);
+
+    result = system->init(32, FMOD_INIT_NORMAL, extradriverdata);
+    ERRCHECK(result);
+
+    result = system->createSound(Common_MediaPath("stereo.ogg"), FMOD_LOOP_NORMAL, 0, &sound);
+    ERRCHECK(result);
+
+    result = system->playSound(sound, 0, false, &channel);
+    ERRCHECK(result);
+
+    /*
+        Create the DSP effect.
+    */  
+    { 
+        FMOD_DSP_DESCRIPTION dspdesc; 
+        memset(&dspdesc, 0, sizeof(dspdesc));
+        FMOD_DSP_PARAMETER_DESC wavedata_desc;
+        FMOD_DSP_PARAMETER_DESC volume_desc;
+        FMOD_DSP_PARAMETER_DESC *paramdesc[2] = 
+        {
+            &wavedata_desc,
+            &volume_desc
+        };
+
+        FMOD_DSP_INIT_PARAMDESC_DATA(wavedata_desc, "wave data", "", "wave data", FMOD_DSP_PARAMETER_DATA_TYPE_USER);
+        FMOD_DSP_INIT_PARAMDESC_FLOAT(volume_desc, "volume", "%", "linear volume in percent", 0, 1, 1);
+
+        strncpy(dspdesc.name, "My first DSP unit", sizeof(dspdesc.name));
+        dspdesc.version             = 0x00010000;
+        dspdesc.numinputbuffers     = 1;
+        dspdesc.numoutputbuffers    = 1;
+        dspdesc.read                = myDSPCallback; 
+        dspdesc.create              = myDSPCreateCallback;
+        dspdesc.release             = myDSPReleaseCallback;
+        dspdesc.getparameterdata    = myDSPGetParameterDataCallback;
+        dspdesc.setparameterfloat   = myDSPSetParameterFloatCallback;
+        dspdesc.getparameterfloat   = myDSPGetParameterFloatCallback;
+        dspdesc.numparameters       = 2;
+        dspdesc.paramdesc           = paramdesc;
+
+        result = system->createDSP(&dspdesc, &mydsp); 
+        ERRCHECK(result); 
+    } 
+
+    result = system->getMasterChannelGroup(&mastergroup);
+    ERRCHECK(result);
+
+    result = mastergroup->addDSP(0, mydsp);
+    ERRCHECK(result);
+
+    /*
+        Main loop.
+    */
+    do
+    {
+        bool bypass;
+
+        Common_Update();
+
+        result = mydsp->getBypass(&bypass);
+        ERRCHECK(result);
+
+        if (Common_BtnPress(BTN_ACTION1))
+        {
+            bypass = !bypass;
+            
+            result = mydsp->setBypass(bypass);
+            ERRCHECK(result);
+        }        
+        if (Common_BtnPress(BTN_ACTION2))
+        {
+            float vol;
+
+            result = mydsp->getParameterFloat(1, &vol, 0, 0);
+            ERRCHECK(result);
+
+            if (vol > 0.0f)
+            {
+                vol -= 0.1f;
+            }
+
+            result = mydsp->setParameterFloat(1, vol);
+            ERRCHECK(result);
+        }
+        if (Common_BtnPress(BTN_ACTION3))
+        {
+            float vol;
+
+            result = mydsp->getParameterFloat(1, &vol, 0, 0);
+            ERRCHECK(result);
+
+            if (vol < 1.0f)
+            {
+                vol += 0.1f;
+            }
+
+            result = mydsp->setParameterFloat(1, vol);
+            ERRCHECK(result);
+        }
+
+        result = system->update();
+        ERRCHECK(result);
+
+        {
+            char                     volstr[32] = { 0 };
+            FMOD_DSP_PARAMETER_DESC *desc;
+            mydsp_data_t            *data;
+
+            result = mydsp->getParameterInfo(1, &desc);
+            ERRCHECK(result);
+            result = mydsp->getParameterFloat(1, 0, volstr, 32);
+            ERRCHECK(result);
+            result = mydsp->getParameterData(0, (void **)&data, 0, 0, 0);
+            ERRCHECK(result);
+
+            Common_Draw("==================================================");
+            Common_Draw("Custom DSP Example.");
+            Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+            Common_Draw("==================================================");
+            Common_Draw("");
+            Common_Draw("Press %s to toggle filter bypass", Common_BtnStr(BTN_ACTION1));
+            Common_Draw("Press %s to decrease volume 10%%", Common_BtnStr(BTN_ACTION2));
+            Common_Draw("Press %s to increase volume 10%%", Common_BtnStr(BTN_ACTION3));
+            Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
+            Common_Draw("");
+            Common_Draw("Filter is %s", bypass ? "inactive" : "active");
+            Common_Draw("Volume is %s%s", volstr, desc->label);
+
+            if (data->channels)
+            {
+                char display[80] = { 0 };
+                int channel;
+
+                for (channel = 0; channel < data->channels; channel++)
+                {
+                    int count,level;
+                    float max = 0;
+
+                    for (count = 0; count < data->length_samples; count++)
+                    {
+                        if (fabsf(data->buffer[(count * data->channels) + channel]) > max)
+                        {
+                            max = fabsf(data->buffer[(count * data->channels) + channel]);
+                        }
+                    }
+                    level = (int)(max * 40.0f);
+                    
+                    snprintf(display, sizeof(display), "%2d ", channel);
+                    for (count = 0; count < level; count++) display[count + 3] = '=';
+
+                    Common_Draw(display);
+                }
+            }
+        }
+
+        Common_Sleep(50);
+    } while (!Common_BtnPress(BTN_QUIT));
+
+    /*
+        Shut down
+    */
+    result = sound->release();
+    ERRCHECK(result);
+
+    result = mastergroup->removeDSP(mydsp);
+    ERRCHECK(result);
+    result = mydsp->release();
+    ERRCHECK(result);
+
+    result = system->close();
+    ERRCHECK(result);
+    result = system->release();
+    ERRCHECK(result);
+
+    Common_Close();
+
+    return 0;
+}

SimpleGame/FMOD/api/core/examples/dsp_effect_per_speaker.cpp

@@ -0,0 +1,276 @@
+/*==============================================================================
+DSP Effect Per Speaker Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to manipulate a DSP network and as an example, creates 2
+DSP effects, splitting a single sound into 2 audio paths, which it then filters
+seperately.
+
+To only have each audio path come out of one speaker each,
+DSPConnection::setMixMatrix is used just before the 2 branches merge back together
+again.
+
+For more speakers:
+
+ * Use System::setSoftwareFormat
+ * Create more effects, currently 2 for stereo (lowpass and highpass), create one
+   per speaker.
+ * Under the 'Now connect the 2 effects to channeldsp head.' section, connect
+   the extra effects by duplicating the code more times.
+ * Filter each effect to each speaker by calling DSPConnection::setMixMatrix.  
+   Expand the existing code by extending the matrices from 2 in and 2 out, to the 
+   number of speakers you require.
+
+For information on using FMOD example code in your own programs, visit
+https://www.fmod.com/legal
+==============================================================================*/
+#include "fmod.hpp"
+#include "common.h"
+
+int FMOD_Main()
+{
+    FMOD::System        *system;
+    FMOD::Sound         *sound;
+    FMOD::Channel       *channel;
+    FMOD::ChannelGroup  *mastergroup;
+    FMOD::DSP           *dsplowpass, *dsphighpass, *dsphead, *dspchannelmixer;
+    FMOD::DSPConnection *dsplowpassconnection, *dsphighpassconnection;
+    FMOD_RESULT          result;
+    float                pan = 0.0f;
+    void                *extradriverdata = 0;
+
+    Common_Init(&extradriverdata);
+
+    /*
+        Create a System object and initialize.
+    */
+    result = FMOD::System_Create(&system);
+    ERRCHECK(result);
+
+    /*
+        In this special case we want to use stereo output and not worry about varying matrix sizes depending on user speaker mode.
+    */
+    system->setSoftwareFormat(48000, FMOD_SPEAKERMODE_STEREO, 0);
+    ERRCHECK(result);
+
+    /*
+        Initialize FMOD
+    */
+    result = system->init(32, FMOD_INIT_NORMAL, extradriverdata);
+    ERRCHECK(result);
+
+    result = system->createSound(Common_MediaPath("drumloop.wav"), FMOD_LOOP_NORMAL, 0, &sound);
+    ERRCHECK(result);
+
+    result = system->playSound(sound, 0, false, &channel);
+    ERRCHECK(result);
+
+    /*
+        Create the DSP effects.
+    */  
+    result = system->createDSPByType(FMOD_DSP_TYPE_LOWPASS, &dsplowpass);
+    ERRCHECK(result);
+
+    result = dsplowpass->setParameterFloat(FMOD_DSP_LOWPASS_CUTOFF, 1000.0f);
+    ERRCHECK(result);
+    result = dsplowpass->setParameterFloat(FMOD_DSP_LOWPASS_RESONANCE, 4.0f);
+    ERRCHECK(result);
+
+    result = system->createDSPByType(FMOD_DSP_TYPE_HIGHPASS, &dsphighpass);
+    ERRCHECK(result);
+
+    result = dsphighpass->setParameterFloat(FMOD_DSP_HIGHPASS_CUTOFF, 4000.0f);
+    ERRCHECK(result);
+    result = dsphighpass->setParameterFloat(FMOD_DSP_HIGHPASS_RESONANCE, 4.0f);
+    ERRCHECK(result);
+
+    /*
+        Connect up the DSP network
+    */
+
+    /*
+        When a sound is played, a subnetwork is set up in the DSP network which looks like this.
+        Wavetable is the drumloop sound, and it feeds its data from right to left.
+
+        [DSPHEAD]<------------[DSPCHANNELMIXER]<------------[CHANNEL HEAD]<------------[WAVETABLE - DRUMLOOP.WAV]
+    */  
+    result = system->getMasterChannelGroup(&mastergroup);
+    ERRCHECK(result);
+
+    result = mastergroup->getDSP(FMOD_CHANNELCONTROL_DSP_HEAD, &dsphead);
+    ERRCHECK(result);
+
+    result = dsphead->getInput(0, &dspchannelmixer, 0);
+    ERRCHECK(result);
+
+    /*
+        Now disconnect channeldsp head from wavetable to look like this.
+
+        [DSPHEAD]             [DSPCHANNELMIXER]<------------[CHANNEL HEAD]<------------[WAVETABLE - DRUMLOOP.WAV]
+    */
+    result = dsphead->disconnectFrom(dspchannelmixer);
+    ERRCHECK(result);
+
+    /*
+        Now connect the 2 effects to channeldsp head.  
+        Store the 2 connections this makes so we can set their matrix later.
+
+                  [DSPLOWPASS]
+                 /x           
+        [DSPHEAD]             [DSPCHANNELMIXER]<------------[CHANNEL HEAD]<------------[WAVETABLE - DRUMLOOP.WAV]
+                 \y           
+                  [DSPHIGHPASS]
+    */
+    result = dsphead->addInput(dsplowpass, &dsplowpassconnection);      /* x = dsplowpassconnection */
+    ERRCHECK(result);
+    result = dsphead->addInput(dsphighpass, &dsphighpassconnection);    /* y = dsphighpassconnection */
+    ERRCHECK(result);
+    
+    /*
+        Now connect the channelmixer to the 2 effects
+
+                  [DSPLOWPASS]
+                 /x          \
+        [DSPHEAD]             [DSPCHANNELMIXER]<------------[CHANNEL HEAD]<------------[WAVETABLE - DRUMLOOP.WAV]
+                 \y          /
+                  [DSPHIGHPASS]
+    */
+    result = dsplowpass->addInput(dspchannelmixer);     /* Ignore connection - we dont care about it. */
+    ERRCHECK(result);
+
+    result = dsphighpass->addInput(dspchannelmixer);    /* Ignore connection - we dont care about it. */
+    ERRCHECK(result);
+
+    /*
+        Now the drumloop will be twice as loud, because it is being split into 2, then recombined at the end.
+        What we really want is to only feed the dsphead<-dsplowpass through the left speaker for that effect, and 
+        dsphead<-dsphighpass to the right speaker for that effect.
+        We can do that simply by setting the pan, or speaker matrix of the connections.
+
+                  [DSPLOWPASS]
+                 /x=1,0      \
+        [DSPHEAD]             [DSPCHANNELMIXER]<------------[CHANNEL HEAD]<------------[WAVETABLE - DRUMLOOP.WAV]
+                 \y=0,1      /
+                  [DSPHIGHPASS]
+    */    
+    {
+        float lowpassmatrix[2][2]  = { 
+                                        { 1.0f, 0.0f },     // <- output to front left.  Take front left input signal at 1.0.
+                                        { 0.0f, 0.0f }      // <- output to front right.  Silence
+                                     };
+        float highpassmatrix[2][2] = { 
+                                        { 0.0f, 0.0f },     // <- output to front left.  Silence
+                                        { 0.0f, 1.0f }      // <- output to front right.  Take front right input signal at 1.0
+                                     };
+
+        /* 
+            Upgrade the signal coming from the channel mixer from mono to stereo.  Otherwise the lowpass and highpass will get mono signals 
+        */
+        result = dspchannelmixer->setChannelFormat(0, 0, FMOD_SPEAKERMODE_STEREO);
+        ERRCHECK(result);
+
+        /*
+            Now set the above matrices.
+        */
+        result = dsplowpassconnection->setMixMatrix(&lowpassmatrix[0][0], 2, 2);
+        ERRCHECK(result);
+        result = dsphighpassconnection->setMixMatrix(&highpassmatrix[0][0], 2, 2);
+        ERRCHECK(result);
+    }
+
+    result = dsplowpass->setBypass(true);
+    ERRCHECK(result);
+    result = dsphighpass->setBypass(true);
+    ERRCHECK(result);
+
+    result = dsplowpass->setActive(true);
+    ERRCHECK(result);
+    result = dsphighpass->setActive(true);
+    ERRCHECK(result);
+
+    /*
+        Main loop.
+    */
+    do
+    {
+        bool lowpassbypass, highpassbypass;
+
+        Common_Update();
+
+        result = dsplowpass->getBypass(&lowpassbypass);
+        ERRCHECK(result);
+        result = dsphighpass->getBypass(&highpassbypass);
+        ERRCHECK(result);
+
+        if (Common_BtnPress(BTN_ACTION1))
+        {
+            lowpassbypass = !lowpassbypass;
+
+            result = dsplowpass->setBypass(lowpassbypass);
+            ERRCHECK(result);
+        }
+
+        if (Common_BtnPress(BTN_ACTION2))
+        {
+            highpassbypass = !highpassbypass;
+
+            result = dsphighpass->setBypass(highpassbypass);
+            ERRCHECK(result);
+        }
+
+        if (Common_BtnDown(BTN_LEFT))
+        {
+            pan = (pan <= -0.9f) ? -1.0f : pan - 0.1f; 
+            
+            result = channel->setPan(pan);
+            ERRCHECK(result);
+        }
+
+        if (Common_BtnDown(BTN_RIGHT))
+        {
+            pan = (pan >= 0.9f) ? 1.0f : pan + 0.1f; 
+            
+            result = channel->setPan(pan);
+            ERRCHECK(result);
+        }
+
+        result = system->update();
+        ERRCHECK(result);
+
+        Common_Draw("==================================================");
+        Common_Draw("DSP Effect Per Speaker Example.");
+        Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+        Common_Draw("==================================================");
+        Common_Draw("");
+        Common_Draw("Press %s to toggle lowpass (left speaker)", Common_BtnStr(BTN_ACTION1));
+        Common_Draw("Press %s to toggle highpass (right speaker)", Common_BtnStr(BTN_ACTION2));
+        Common_Draw("Press %s or %s to pan sound", Common_BtnStr(BTN_LEFT), Common_BtnStr(BTN_RIGHT));
+        Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
+        Common_Draw("");
+        Common_Draw("Lowpass (left) is %s", lowpassbypass ? "inactive" : "active");
+        Common_Draw("Highpass (right) is %s", highpassbypass ? "inactive" : "active");
+        Common_Draw("Pan is %0.2f", pan);
+
+        Common_Sleep(50);
+    } while (!Common_BtnPress(BTN_QUIT));
+
+    /*
+        Shut down
+    */
+    result = sound->release();
+    ERRCHECK(result);
+
+    result = dsplowpass->release();
+    ERRCHECK(result);
+    result = dsphighpass->release();
+    ERRCHECK(result);
+
+    result = system->close();
+    ERRCHECK(result);
+    result = system->release();
+    ERRCHECK(result);
+
+    Common_Close();
+
+    return 0;
+}

SimpleGame/FMOD/api/core/examples/dsp_inspector.cpp

@@ -0,0 +1,331 @@
+/*==============================================================================
+Plug-in Inspector Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to enumerate loaded plug-ins and their parameters.
+
+For information on using FMOD example code in your own programs, visit
+https://www.fmod.com/legal
+==============================================================================*/
+#include "fmod.hpp"
+#include "common.h"
+
+const int   INTERFACE_UPDATETIME = 50;      // 50ms update for interface
+const int   MAX_PLUGINS_IN_VIEW = 5;
+const int   MAX_PARAMETERS_IN_VIEW = 14;
+
+enum InspectorState
+{
+    PLUGIN_SELECTOR,
+    PARAMETER_VIEWER
+};
+
+struct PluginSelectorState
+{
+    FMOD::System *system;
+    int numplugins;
+    int cursor;
+};
+
+struct ParameterViewerState
+{
+    FMOD::DSP *dsp;
+    int numparams;
+    int scroll;
+};
+
+void drawTitle()
+{
+    Common_Draw("==================================================");
+    Common_Draw("Plug-in Inspector Example.");
+    Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+    Common_Draw("==================================================");
+    Common_Draw("");
+}
+
+bool hasDataParameter(const FMOD_DSP_DESCRIPTION *desc, FMOD_DSP_PARAMETER_DATA_TYPE type)
+{
+    for (int i = 0; i < desc->numparameters; i++)
+    {
+        if (desc->paramdesc[i]->type == FMOD_DSP_PARAMETER_TYPE_DATA && ((type >= 0 && desc->paramdesc[i]->datadesc.datatype >= 0) || desc->paramdesc[i]->datadesc.datatype == type))
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void drawDSPInfo(const FMOD_DSP_DESCRIPTION *desc)
+{
+    Common_Draw("Name (Version) : %s (%x)", desc->name, desc->version);
+    Common_Draw("SDK Version    : %d", desc->pluginsdkversion);
+    Common_Draw("Type           : %s", desc->numinputbuffers ? "Effect" : "Sound Generator");
+    Common_Draw("Parameters     : %d", desc->numparameters);
+    Common_Draw("Audio Callback : %s", desc->process ? "process()" : "read()");
+    Common_Draw("");
+    Common_Draw(" Reset | Side-Chain | 3D | Audibility | User Data");
+    Common_Draw("   %s  |     %s     | %s |     %s     |     %s   ",
+        desc->reset ? "Y " : "--",
+        hasDataParameter(desc, FMOD_DSP_PARAMETER_DATA_TYPE_SIDECHAIN) ? "Y " : "--",
+        hasDataParameter(desc, FMOD_DSP_PARAMETER_DATA_TYPE_3DATTRIBUTES) || hasDataParameter(desc, FMOD_DSP_PARAMETER_DATA_TYPE_3DATTRIBUTES_MULTI) ? "Y " : "--",
+        hasDataParameter(desc, FMOD_DSP_PARAMETER_DATA_TYPE_OVERALLGAIN) ? "Y " : "--",
+        hasDataParameter(desc, FMOD_DSP_PARAMETER_DATA_TYPE_USER) || desc->userdata ? "Y " : "--");
+}
+
+void drawDSPList(PluginSelectorState *state)
+{
+    unsigned int pluginhandle;
+    char         pluginname[256];
+    FMOD_RESULT  result;
+
+    Common_Draw("Press %s to select the next plug-in", Common_BtnStr(BTN_DOWN));
+    Common_Draw("Press %s to select the previous plug-in", Common_BtnStr(BTN_UP));
+    Common_Draw("Press %s to view the plug-in parameters", Common_BtnStr(BTN_RIGHT));
+    Common_Draw("");
+
+    int start = Common_Clamp(0, state->cursor - (MAX_PLUGINS_IN_VIEW - 1) / 2, state->numplugins - MAX_PLUGINS_IN_VIEW);
+    for (int i = start; i < start + MAX_PLUGINS_IN_VIEW; i++)
+    {
+        result = state->system->getPluginHandle(FMOD_PLUGINTYPE_DSP, i, &pluginhandle);
+        ERRCHECK(result);
+
+        result = state->system->getPluginInfo(pluginhandle, 0, pluginname, 256, 0);
+        ERRCHECK(result);
+
+        Common_Draw("%s %s", i == state->cursor ? ">" : " ", pluginname);
+    }
+
+    Common_Draw("");
+    Common_Draw("==================================================");
+    Common_Draw("");
+
+    result = state->system->getPluginHandle(FMOD_PLUGINTYPE_DSP, state->cursor, &pluginhandle);
+    ERRCHECK(result);
+
+    const FMOD_DSP_DESCRIPTION *description;
+    result = state->system->getDSPInfoByPlugin(pluginhandle, &description);
+    ERRCHECK(result);
+
+    drawDSPInfo(description);
+}
+
+void drawDSPParameters(ParameterViewerState *state)
+{
+    FMOD_RESULT              result;
+    FMOD_DSP_PARAMETER_DESC *paramdesc;
+    char                     pluginname[256];
+
+    Common_Draw("Press %s to scroll down", Common_BtnStr(BTN_DOWN));
+    Common_Draw("Press %s to scroll up", Common_BtnStr(BTN_UP));
+    Common_Draw("Press %s to return to the plug-in list", Common_BtnStr(BTN_LEFT));
+    Common_Draw("");
+    
+    result = state->dsp->getInfo(pluginname, 0, 0, 0, 0);
+    ERRCHECK(result);
+
+    Common_Draw("%s Parameters:", pluginname);
+    Common_Draw("--------------------------------------------------");
+
+    for (int i = state->scroll; i < state->numparams; i++)
+    {
+        result = state->dsp->getParameterInfo(i, &paramdesc);
+        ERRCHECK(result);
+        switch (paramdesc->type)
+        {
+            case FMOD_DSP_PARAMETER_TYPE_FLOAT:
+            {
+                char *units = paramdesc->label;
+                Common_Draw("%2d: %-15s [%g, %g] (%.2f%s)", i, paramdesc->name, paramdesc->floatdesc.min, paramdesc->floatdesc.max, paramdesc->floatdesc.defaultval, units);
+                break;
+            }
+
+            case FMOD_DSP_PARAMETER_TYPE_INT:
+            {
+                if (paramdesc->intdesc.valuenames)
+                {
+                    int lengthremaining = 1024;
+                    char enums[1024];
+                    char *s = enums;
+                    for (int j = 0; j < paramdesc->intdesc.max - paramdesc->intdesc.min; ++j)
+                    {
+                        int len =  Common_snprintf(s, lengthremaining, "%s, ", paramdesc->intdesc.valuenames[j]);
+                        if (!len)
+                        {
+                            break;
+                        }
+                        s += len;
+                        lengthremaining -= len;
+                    }
+                    if (lengthremaining)
+                    {
+                        Common_snprintf(s, lengthremaining, "%s", paramdesc->intdesc.valuenames[paramdesc->intdesc.max - paramdesc->intdesc.min]);
+                    }
+                    Common_Draw("%2d: %-15s [%s] (%s)", i, paramdesc->name, enums, paramdesc->intdesc.valuenames[paramdesc->intdesc.defaultval - paramdesc->intdesc.min]);
+                }
+                else
+                {
+                    char *units = paramdesc->label;
+                    Common_Draw("%2d: %-15s [%d, %d] (%d%s)", i, paramdesc->name, paramdesc->intdesc.min, paramdesc->intdesc.max, paramdesc->intdesc.defaultval, units);
+                }
+                break;
+            }
+
+            case FMOD_DSP_PARAMETER_TYPE_BOOL:
+            {
+                if (paramdesc->booldesc.valuenames)
+                {
+                    Common_Draw("%2d: %-15s [%s, %s] (%s)", i, paramdesc->name, paramdesc->booldesc.valuenames[0], paramdesc->booldesc.valuenames[1], paramdesc->booldesc.valuenames[paramdesc->booldesc.defaultval ? 1 : 0]);
+                }
+                else
+                {
+                    Common_Draw("%2d: %-15s [On, Off] (%s)", i, paramdesc->name, paramdesc->booldesc.defaultval ? "On" : "Off");
+                }
+                break;
+            }
+
+            case FMOD_DSP_PARAMETER_TYPE_DATA:
+            {
+                Common_Draw("%2d: %-15s (Data type: %d)", i, paramdesc->name, paramdesc->datadesc.datatype);
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+}
+
+InspectorState pluginSelectorDo(PluginSelectorState *state)
+{
+    if (Common_BtnPress(BTN_UP))
+    {
+        state->cursor = (state->cursor - 1 + state->numplugins) % state->numplugins;
+    }
+
+    if (Common_BtnPress(BTN_DOWN))
+    {
+        state->cursor = (state->cursor + 1) % state->numplugins;
+    }
+
+    if (Common_BtnPress(BTN_RIGHT))
+    {
+        return PARAMETER_VIEWER;
+    }
+
+    drawTitle();
+    drawDSPList(state);
+
+    return PLUGIN_SELECTOR;
+}
+
+InspectorState parameterViewerDo(ParameterViewerState *state)
+{
+    if (state->numparams > MAX_PARAMETERS_IN_VIEW)
+    {
+        if (Common_BtnPress(BTN_UP))
+        {
+            state->scroll--;
+            state->scroll = Common_Max(state->scroll, 0);
+        }
+
+        if (Common_BtnPress(BTN_DOWN))
+        {
+            state->scroll++;
+            state->scroll = Common_Min(state->scroll, state->numparams - MAX_PARAMETERS_IN_VIEW);
+        }
+    }
+
+    if (Common_BtnPress(BTN_LEFT))
+    {
+        return PLUGIN_SELECTOR;
+    }
+
+    drawTitle();
+    drawDSPParameters(state);
+
+    return PARAMETER_VIEWER;
+}
+
+int FMOD_Main()
+{
+    FMOD::System        *system           = 0;
+    FMOD_RESULT          result;
+    void                *extradriverdata  = 0;
+    unsigned int         pluginhandle;
+    InspectorState       state            = PLUGIN_SELECTOR;
+    PluginSelectorState  pluginselector   = { 0 };
+    ParameterViewerState parameterviewer  = { 0 };
+
+    Common_Init(&extradriverdata);
+
+    /*
+        Create a System object and initialize
+    */
+    result = FMOD::System_Create(&system);
+    ERRCHECK(result);
+
+    result = system->init(32, FMOD_INIT_NORMAL, extradriverdata);
+    ERRCHECK(result);
+
+    result = system->getNumPlugins(FMOD_PLUGINTYPE_DSP, &pluginselector.numplugins);
+    ERRCHECK(result);
+
+    pluginselector.system = system;
+
+    do
+    {
+        Common_Update();
+
+        if (state == PLUGIN_SELECTOR)
+        {
+            state = pluginSelectorDo(&pluginselector);
+
+            if (state == PARAMETER_VIEWER)
+            {
+                result = pluginselector.system->getPluginHandle(FMOD_PLUGINTYPE_DSP, pluginselector.cursor, &pluginhandle);
+                ERRCHECK(result);
+
+                result = pluginselector.system->createDSPByPlugin(pluginhandle, &parameterviewer.dsp);
+                ERRCHECK(result);
+
+                FMOD_RESULT result = parameterviewer.dsp->getNumParameters(&parameterviewer.numparams);
+                ERRCHECK(result);
+
+                parameterviewer.scroll = 0;
+            }
+        }
+        else if (state == PARAMETER_VIEWER)
+        {
+            state = parameterViewerDo(&parameterviewer);
+
+            if (state == PLUGIN_SELECTOR)
+            {
+                result = parameterviewer.dsp->release();
+                ERRCHECK(result);
+
+                parameterviewer.dsp = 0;
+            }
+        }
+
+        result = system->update();
+        ERRCHECK(result);
+
+        Common_Sleep(INTERFACE_UPDATETIME - 1);
+    } while (!Common_BtnPress(BTN_QUIT));
+
+    if (parameterviewer.dsp)
+    {
+        result = parameterviewer.dsp->release();
+        ERRCHECK(result);
+    }
+
+    result = system->close();
+    ERRCHECK(result);
+    result = system->release();
+    ERRCHECK(result);
+
+    Common_Close();
+
+    return 0;
+}

SimpleGame/FMOD/api/core/examples/effects.cpp

@@ -0,0 +1,237 @@
+/*==============================================================================
+Effects Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to apply some of the built in software effects to sounds
+by applying them to the master channel group. All software sounds played here
+would be filtered in the same way. To filter per channel, and not have other
+channels affected, simply apply the same functions to the FMOD::Channel instead
+of the FMOD::ChannelGroup.
+
+For information on using FMOD example code in your own programs, visit
+https://www.fmod.com/legal
+==============================================================================*/
+#include "fmod.hpp"
+#include "common.h"
+
+int FMOD_Main()
+{
+    FMOD::System       *system        = 0;
+    FMOD::Sound        *sound         = 0;
+    FMOD::Channel      *channel       = 0;
+    FMOD::ChannelGroup *mastergroup   = 0; 
+    FMOD::DSP          *dsplowpass    = 0;
+    FMOD::DSP          *dsphighpass   = 0;
+    FMOD::DSP          *dspecho       = 0;
+    FMOD::DSP          *dspflange     = 0;
+    FMOD_RESULT         result;
+    void               *extradriverdata = 0;
+
+    Common_Init(&extradriverdata);
+
+    /*
+        Create a System object and initialize
+    */
+    result = FMOD::System_Create(&system);
+    ERRCHECK(result);
+
+    result = system->init(32, FMOD_INIT_NORMAL, extradriverdata);
+    ERRCHECK(result);
+
+    result = system->getMasterChannelGroup(&mastergroup);
+    ERRCHECK(result);
+
+    result = system->createSound(Common_MediaPath("drumloop.wav"), FMOD_DEFAULT, 0, &sound);
+    ERRCHECK(result);
+
+    result = system->playSound(sound, 0, false, &channel);
+    ERRCHECK(result);
+
+    /*
+        Create some effects to play with
+    */
+    result = system->createDSPByType(FMOD_DSP_TYPE_LOWPASS, &dsplowpass);
+    ERRCHECK(result);
+    result = system->createDSPByType(FMOD_DSP_TYPE_HIGHPASS, &dsphighpass);
+    ERRCHECK(result);
+    result = system->createDSPByType(FMOD_DSP_TYPE_ECHO, &dspecho);
+    ERRCHECK(result);
+    result = system->createDSPByType(FMOD_DSP_TYPE_FLANGE, &dspflange);
+    ERRCHECK(result);
+
+    /*
+        Add them to the master channel group.  Each time an effect is added (to position 0) it pushes the others down the list.
+    */
+    result = mastergroup->addDSP(0, dsplowpass);
+    ERRCHECK(result);
+    result = mastergroup->addDSP(0, dsphighpass);
+    ERRCHECK(result);
+    result = mastergroup->addDSP(0, dspecho);
+    ERRCHECK(result);
+    result = mastergroup->addDSP(0, dspflange);
+    ERRCHECK(result);
+
+    /*
+        By default, bypass all effects.  This means let the original signal go through without processing.
+        It will sound 'dry' until effects are enabled by the user.
+    */
+    result = dsplowpass->setBypass(true);
+    ERRCHECK(result);
+    result = dsphighpass->setBypass(true);
+    ERRCHECK(result);
+    result = dspecho->setBypass(true);
+    ERRCHECK(result);
+    result = dspflange->setBypass(true);
+    ERRCHECK(result);
+
+    /*
+        Main loop
+    */
+    do
+    {
+        Common_Update();
+
+        if (Common_BtnPress(BTN_MORE))
+        {
+            bool paused;
+
+            result = channel->getPaused(&paused);
+            ERRCHECK(result);
+
+            paused = !paused;
+
+            result = channel->setPaused(paused);
+            ERRCHECK(result);
+        }
+
+        if (Common_BtnPress(BTN_ACTION1))
+        {
+            bool bypass;
+
+            result = dsplowpass->getBypass(&bypass);
+            ERRCHECK(result);
+
+            bypass = !bypass;
+
+            result = dsplowpass->setBypass(bypass);
+            ERRCHECK(result);
+        }
+
+        if (Common_BtnPress(BTN_ACTION2))
+        {
+            bool bypass;
+
+            result = dsphighpass->getBypass(&bypass);
+            ERRCHECK(result);
+
+            bypass = !bypass;
+
+            result = dsphighpass->setBypass(bypass);
+            ERRCHECK(result);
+        }
+
+        if (Common_BtnPress(BTN_ACTION3))
+        {
+            bool bypass;
+
+            result = dspecho->getBypass(&bypass);
+            ERRCHECK(result);
+
+            bypass = !bypass;
+
+            result = dspecho->setBypass(bypass);
+            ERRCHECK(result);
+        }
+
+        if (Common_BtnPress(BTN_ACTION4))
+        {
+            bool bypass;
+
+            result = dspflange->getBypass(&bypass);
+            ERRCHECK(result);
+
+            bypass = !bypass;
+
+            result = dspflange->setBypass(bypass);
+            ERRCHECK(result);
+        }
+
+        result = system->update();
+        ERRCHECK(result);
+
+        {
+            bool paused = 0;
+            bool dsplowpass_bypass;
+            bool dsphighpass_bypass;
+            bool dspecho_bypass;
+            bool dspflange_bypass;
+
+            dsplowpass   ->getBypass(&dsplowpass_bypass);
+            dsphighpass  ->getBypass(&dsphighpass_bypass);
+            dspecho      ->getBypass(&dspecho_bypass);
+            dspflange    ->getBypass(&dspflange_bypass);
+
+            if (channel)
+            {
+                result = channel->getPaused(&paused);
+                if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
+                {
+                    ERRCHECK(result);
+                }
+            }
+
+            Common_Draw("==================================================");
+            Common_Draw("Effects Example.");
+            Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+            Common_Draw("==================================================");
+            Common_Draw("");
+            Common_Draw("Press %s to pause/unpause sound", Common_BtnStr(BTN_MORE));
+            Common_Draw("Press %s to toggle dsplowpass effect", Common_BtnStr(BTN_ACTION1));
+            Common_Draw("Press %s to toggle dsphighpass effect", Common_BtnStr(BTN_ACTION2));
+            Common_Draw("Press %s to toggle dspecho effect", Common_BtnStr(BTN_ACTION3));
+            Common_Draw("Press %s to toggle dspflange effect", Common_BtnStr(BTN_ACTION4));
+            Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
+            Common_Draw("");
+            Common_Draw("%s : lowpass[%c] highpass[%c] echo[%c] flange[%c]", 
+                    paused              ? "Paused " : "Playing",
+                    dsplowpass_bypass   ? ' ' : 'x',
+                    dsphighpass_bypass  ? ' ' : 'x',
+                    dspecho_bypass      ? ' ' : 'x',
+                    dspflange_bypass    ? ' ' : 'x');
+        }
+
+        Common_Sleep(50);
+    } while (!Common_BtnPress(BTN_QUIT));
+
+    /*
+        Shut down
+    */
+    result = mastergroup->removeDSP(dsplowpass);
+    ERRCHECK(result);
+    result = mastergroup->removeDSP(dsphighpass);
+    ERRCHECK(result);
+    result = mastergroup->removeDSP(dspecho);
+    ERRCHECK(result);
+    result = mastergroup->removeDSP(dspflange);
+    ERRCHECK(result);
+    
+    result = dsplowpass->release();
+    ERRCHECK(result);
+    result = dsphighpass->release();
+    ERRCHECK(result);
+    result = dspecho->release();
+    ERRCHECK(result);
+    result = dspflange->release();
+    ERRCHECK(result);
+
+    result = sound->release();
+    ERRCHECK(result);
+    result = system->close();
+    ERRCHECK(result);
+    result = system->release();
+    ERRCHECK(result);
+
+    Common_Close();
+
+    return 0;
+}

SimpleGame/FMOD/api/core/examples/gapless_playback.cpp

@@ -0,0 +1,269 @@
+/*==============================================================================
+Gapless Playback Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to schedule channel playback into the future with sample
+accuracy.  Use several scheduled channels to synchronize 2 or more sounds.
+
+For information on using FMOD example code in your own programs, visit
+https://www.fmod.com/legal
+==============================================================================*/
+#include "fmod.hpp"
+#include "common.h"
+
+enum NOTE
+{
+    NOTE_C,
+    NOTE_D,
+    NOTE_E,
+};
+
+NOTE note[] = 
+{
+    NOTE_E,   /* Ma-    */
+    NOTE_D,   /* ry     */
+    NOTE_C,   /* had    */
+    NOTE_D,   /* a      */
+    NOTE_E,   /* lit-   */
+    NOTE_E,   /* tle    */
+    NOTE_E,   /* lamb,  */
+    NOTE_E,   /* .....  */
+    NOTE_D,   /* lit-   */
+    NOTE_D,   /* tle    */
+    NOTE_D,   /* lamb,  */
+    NOTE_D,   /* .....  */
+    NOTE_E,   /* lit-   */
+    NOTE_E,   /* tle    */
+    NOTE_E,   /* lamb,  */
+    NOTE_E,   /* .....  */
+
+    NOTE_E,   /* Ma-    */
+    NOTE_D,   /* ry     */
+    NOTE_C,   /* had    */
+    NOTE_D,   /* a      */
+    NOTE_E,   /* lit-   */
+    NOTE_E,   /* tle    */
+    NOTE_E,   /* lamb,  */
+    NOTE_E,   /* its    */
+    NOTE_D,   /* fleece */
+    NOTE_D,   /* was    */
+    NOTE_E,   /* white  */
+    NOTE_D,   /* as     */
+    NOTE_C,   /* snow.  */
+    NOTE_C,   /* .....  */
+    NOTE_C,   /* .....  */
+    NOTE_C,   /* .....  */
+};
+
+int FMOD_Main()
+{
+    FMOD::System           *system;
+    FMOD::Sound            *sound[3];
+    FMOD::Channel          *channel = 0;
+    FMOD::ChannelGroup     *channelgroup = 0;
+    FMOD_RESULT             result;
+    unsigned int            dsp_block_len, count;
+    int                     outputrate = 0;
+    void                   *extradriverdata = 0;
+    
+    Common_Init(&extradriverdata);
+
+    /*
+        Create a System object and initialize.
+    */
+    result = FMOD::System_Create(&system);
+    ERRCHECK(result);
+    
+    result = system->init(100, FMOD_INIT_NORMAL, extradriverdata);
+    ERRCHECK(result);
+
+    /*
+        Get information needed later for scheduling.  The mixer block size, and the output rate of the mixer.
+    */
+    result = system->getDSPBufferSize(&dsp_block_len, 0);
+    ERRCHECK(result);
+
+    result = system->getSoftwareFormat(&outputrate, 0, 0);
+    ERRCHECK(result);
+
+    /*
+        Load 3 sounds - these are just sine wave tones at different frequencies.  C, D and E on the musical scale.
+    */
+    result = system->createSound(Common_MediaPath("c.ogg"), FMOD_DEFAULT, 0, &sound[NOTE_C]);
+    ERRCHECK(result);
+    result = system->createSound(Common_MediaPath("d.ogg"), FMOD_DEFAULT, 0, &sound[NOTE_D]);
+    ERRCHECK(result);
+    result = system->createSound(Common_MediaPath("e.ogg"), FMOD_DEFAULT, 0, &sound[NOTE_E]);
+    ERRCHECK(result);
+
+    /* 
+        Create a channelgroup that the channels will play on.  We can use this channelgroup as our clock reference. 
+        It also means we can pause and pitch bend the channelgroup, without affecting the offsets of the delays, because the channelgroup clock
+        which the channels feed off, will be pausing and speeding up/slowing down and still keeping the children in sync.
+    */
+    result = system->createChannelGroup("Parent", &channelgroup);
+    ERRCHECK(result);
+
+    unsigned int numsounds = sizeof(note) / sizeof(note[0]);
+
+    /*
+        Play all the sounds at once! Space them apart with set delay though so that they sound like they play in order.
+    */
+    for (count = 0; count < numsounds; count++)
+    {
+        static unsigned long long clock_start = 0;
+        unsigned int slen;
+        FMOD::Sound *s = sound[note[count]];                            /* Pick a note from our tune. */
+
+        result = system->playSound(s, channelgroup, true, &channel);    /* Play the sound on the channelgroup we want to use as the parent clock reference (for setDelay further down) */
+        ERRCHECK(result);
+
+        if (!clock_start)
+        {
+            result = channel->getDSPClock(0, &clock_start);
+            ERRCHECK(result);
+
+            clock_start += (dsp_block_len * 2);                         /* Start the sound into the future, by 2 mixer blocks worth. */
+                                                                        /* Should be enough to avoid the mixer catching up and hitting the clock value before we've finished setting up everything. */
+                                                                        /* Alternatively the channelgroup we're basing the clock on could be paused to stop it ticking. */
+        }
+        else
+        {
+            float freq;
+
+            result = s->getLength(&slen, FMOD_TIMEUNIT_PCM);            /* Get the length of the sound in samples. */
+            ERRCHECK(result);
+
+            result = s->getDefaults(&freq, 0);                          /* Get the default frequency that the sound was recorded at. */
+            ERRCHECK(result);
+
+            slen = (unsigned int)((float)slen / freq * outputrate);     /* Convert the length of the sound to 'output samples' for the output timeline. */
+            
+            clock_start += slen;                                        /* Place the sound clock start time to this value after the last one. */
+        }
+
+        result = channel->setDelay(clock_start, 0, false);              /* Schedule the channel to start in the future at the newly calculated channelgroup clock value. */
+        ERRCHECK(result);
+
+        result = channel->setPaused(false);                             /* Unpause the sound.  Note that you won't hear the sounds, they are scheduled into the future. */
+        ERRCHECK(result);
+    }
+
+    /*
+        Main loop.
+    */
+    do
+    {
+        Common_Update();
+
+        if (Common_BtnPress(BTN_ACTION1))                               /* Pausing the channelgroup as the clock parent, will pause any scheduled sounds from continuing */
+        {                                                               /* If you paused the channel, this would not stop the clock it is delayed against from ticking,  */
+            bool paused;                                                /* and you'd have to recalculate the delay for the channel into the future again before it was unpaused. */
+            result = channelgroup->getPaused(&paused);
+            ERRCHECK(result);
+            result = channelgroup->setPaused(!paused);
+            ERRCHECK(result);
+        }
+        if (Common_BtnPress(BTN_ACTION2)) 
+        {                                 
+            for (count = 0; count < 50; count++)
+            {
+                float pitch;
+                result = channelgroup->getPitch(&pitch);
+                ERRCHECK(result);
+                pitch += 0.01f;
+                result = channelgroup->setPitch(pitch);
+                ERRCHECK(result);
+
+                result = system->update();
+                ERRCHECK(result);
+
+                Common_Sleep(10);
+            }
+        }
+        if (Common_BtnPress(BTN_ACTION3)) 
+        {                                 
+            for (count = 0; count < 50; count++)
+            {
+                float pitch;
+                result = channelgroup->getPitch(&pitch);
+                ERRCHECK(result);
+
+                if (pitch > 0.1f)
+                {
+                    pitch -= 0.01f;
+                }
+                result = channelgroup->setPitch(pitch);
+                ERRCHECK(result);
+                
+                result = system->update();
+                ERRCHECK(result);
+
+                Common_Sleep(10);
+            }
+        }
+
+        result = system->update();
+        ERRCHECK(result);
+
+        /*
+            Print some information
+        */
+        {
+            bool    playing = false;
+            bool    paused = false;
+            int     chansplaying;
+
+            if (channelgroup)
+            {
+                result = channelgroup->isPlaying(&playing);
+                if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE))
+                {
+                    ERRCHECK(result);
+                }
+
+                result = channelgroup->getPaused(&paused);
+                if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE))
+                {
+                    ERRCHECK(result);
+                }
+            }
+
+            result = system->getChannelsPlaying(&chansplaying, NULL);
+            ERRCHECK(result);
+
+            Common_Draw("==================================================");
+            Common_Draw("Gapless Playback example.");
+            Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+            Common_Draw("==================================================");
+            Common_Draw("");
+            Common_Draw("Press %s to toggle pause", Common_BtnStr(BTN_ACTION1));
+            Common_Draw("Press %s to increase pitch", Common_BtnStr(BTN_ACTION2));
+            Common_Draw("Press %s to decrease pitch", Common_BtnStr(BTN_ACTION3));
+            Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
+            Common_Draw("");
+            Common_Draw("Channels Playing %d : %s", chansplaying, paused ? "Paused " : playing ? "Playing" : "Stopped");
+        }
+
+        Common_Sleep(50);
+    } while (!Common_BtnPress(BTN_QUIT));
+
+    /*
+        Shut down
+    */
+    result = sound[NOTE_C]->release();
+    ERRCHECK(result);
+    result = sound[NOTE_D]->release();
+    ERRCHECK(result);
+    result = sound[NOTE_E]->release();
+    ERRCHECK(result);
+
+    result = system->close();
+    ERRCHECK(result);
+    result = system->release();
+    ERRCHECK(result);
+
+    Common_Close();
+
+    return 0;
+}

SimpleGame/FMOD/api/core/examples/generate_tone.cpp

@@ -0,0 +1,213 @@
+/*==============================================================================
+Generate Tone Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to play generated tones using System::playDSP
+instead of manually connecting and disconnecting DSP units.
+
+For information on using FMOD example code in your own programs, visit
+https://www.fmod.com/legal
+==============================================================================*/
+#include "fmod.hpp"
+#include "common.h"
+
+int FMOD_Main()
+{
+    FMOD::System    *system;
+    FMOD::Channel   *channel = 0;
+    FMOD::DSP       *dsp;
+    FMOD_RESULT      result;
+    void            *extradriverdata = 0;
+
+    Common_Init(&extradriverdata);
+    
+    /*
+        Create a System object and initialize.
+    */
+    result = FMOD::System_Create(&system);
+    ERRCHECK(result);
+
+    result = system->init(32, FMOD_INIT_NORMAL, extradriverdata);
+    ERRCHECK(result);
+
+    /*
+        Create an oscillator DSP units for the tone.
+    */
+    result = system->createDSPByType(FMOD_DSP_TYPE_OSCILLATOR, &dsp);
+    ERRCHECK(result);
+    result = dsp->setParameterFloat(FMOD_DSP_OSCILLATOR_RATE, 440.0f); /* Musical note 'A' */
+    ERRCHECK(result);
+
+    /*
+        Main loop
+    */
+    do
+    {
+        Common_Update();
+
+        if (Common_BtnPress(BTN_ACTION1))
+        {
+            if (channel)
+            {
+                result = channel->stop();
+                ERRCHECK(result);
+            }
+
+            result = system->playDSP(dsp, 0, true, &channel);
+            ERRCHECK(result);
+            result = channel->setVolume(0.5f);
+            ERRCHECK(result);
+            result = dsp->setParameterInt(FMOD_DSP_OSCILLATOR_TYPE, 0);
+            ERRCHECK(result);
+            result = channel->setPaused(false);
+            ERRCHECK(result);
+        }
+
+        if (Common_BtnPress(BTN_ACTION2))
+        {
+            if (channel)
+            {
+                result = channel->stop();
+                ERRCHECK(result);
+            }
+
+            result = system->playDSP(dsp, 0, true, &channel);
+            ERRCHECK(result);
+            result = channel->setVolume(0.125f);
+            ERRCHECK(result);
+            result = dsp->setParameterInt(FMOD_DSP_OSCILLATOR_TYPE, 1);
+            ERRCHECK(result);
+            result = channel->setPaused(false);
+            ERRCHECK(result);
+        }
+
+        if (Common_BtnPress(BTN_ACTION3))
+        {
+            if (channel)
+            {
+                result = channel->stop();
+                ERRCHECK(result);
+            }
+
+            result = system->playDSP(dsp, 0, true, &channel);
+            ERRCHECK(result);
+            result = channel->setVolume(0.125f);
+            ERRCHECK(result);
+            result = dsp->setParameterInt(FMOD_DSP_OSCILLATOR_TYPE, 2);
+            ERRCHECK(result);
+            result = channel->setPaused(false);
+            ERRCHECK(result);
+        }
+
+        if (Common_BtnPress(BTN_ACTION4))
+        {
+            if (channel)
+            {
+                result = channel->stop();
+                ERRCHECK(result);
+            }
+
+            result = system->playDSP(dsp, 0, true, &channel);
+            ERRCHECK(result);
+            result = channel->setVolume(0.5f);
+            ERRCHECK(result);
+            result = dsp->setParameterInt(FMOD_DSP_OSCILLATOR_TYPE, 4);
+            ERRCHECK(result);
+            result = channel->setPaused(false);
+            ERRCHECK(result);
+        }
+
+        if (Common_BtnPress(BTN_MORE))
+        {
+            if (channel)
+            {
+                result = channel->stop();
+                ERRCHECK(result);
+                channel = 0;
+            }
+        }
+
+        if (channel)
+        {
+            if (Common_BtnDown(BTN_UP) || Common_BtnDown(BTN_DOWN))
+            {
+                float volume;
+            
+                result = channel->getVolume(&volume);
+                ERRCHECK(result);
+            
+                volume += (Common_BtnDown(BTN_UP) ? +0.1f : -0.1f);
+                volume = (volume > 1.0f) ? 1.0f : volume;
+                volume = (volume < 0.0f) ? 0.0f : volume;
+           
+                result = channel->setVolume(volume);
+                ERRCHECK(result);
+            }
+
+            if (Common_BtnDown(BTN_LEFT) || Common_BtnDown(BTN_RIGHT))
+            {
+                float frequency;
+            
+                result = channel->getFrequency(&frequency);
+                ERRCHECK(result);
+            
+                frequency += (Common_BtnDown(BTN_RIGHT) ? +500.0f : -500.0f);
+            
+                result = channel->setFrequency(frequency);
+                ERRCHECK(result);
+            }
+        }
+
+        result = system->update();
+        ERRCHECK(result);
+
+        {
+            float frequency = 0.0f, volume = 0.0f;
+            bool playing = false;
+
+            if (channel)
+            {
+                result = channel->getFrequency(&frequency);
+                ERRCHECK(result);
+                result = channel->getVolume(&volume);
+                ERRCHECK(result);
+                result = channel->isPlaying(&playing);
+                ERRCHECK(result);
+            }
+
+            Common_Draw("==================================================");
+            Common_Draw("Generate Tone Example.");
+            Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+            Common_Draw("==================================================");
+            Common_Draw("");
+            Common_Draw("Press %s to play a sine wave", Common_BtnStr(BTN_ACTION1));
+            Common_Draw("Press %s to play a square wave", Common_BtnStr(BTN_ACTION2));
+            Common_Draw("Press %s to play a saw wave", Common_BtnStr(BTN_ACTION3));
+            Common_Draw("Press %s to play a triangle wave", Common_BtnStr(BTN_ACTION4));
+            Common_Draw("Press %s to stop the channel", Common_BtnStr(BTN_MORE));
+            Common_Draw("Press %s and %s to change volume", Common_BtnStr(BTN_UP), Common_BtnStr(BTN_DOWN));
+            Common_Draw("Press %s and %s to change frequency", Common_BtnStr(BTN_LEFT), Common_BtnStr(BTN_RIGHT));
+            Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
+            Common_Draw("");
+            Common_Draw("Channel is %s", playing ? "playing" : "stopped");
+            Common_Draw("Volume %0.2f", volume);
+            Common_Draw("Frequency %0.2f", frequency);
+        }
+
+        Common_Sleep(50);
+    } while (!Common_BtnPress(BTN_QUIT));
+
+    /*
+        Shut down
+    */
+    result = dsp->release();
+    ERRCHECK(result);
+    result = system->close();
+    ERRCHECK(result);
+    result = system->release();
+    ERRCHECK(result);
+
+    Common_Close();
+
+    return 0;
+}

SimpleGame/FMOD/api/core/examples/granular_synth.cpp

@@ -0,0 +1,278 @@
+/*==============================================================================
+Granular Synthesis Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how you can play a string of sounds together without gaps,
+using the setDelay command, to produce a granular synthesis style truck engine 
+effect.
+
+The basic operation is:
+
+ * Play 2 sounds initially at the same time, the first sound immediately, and
+   the 2nd sound with a delay calculated by the length of the first sound.
+ * Call setDelay to initiate the delayed playback. setDelay is sample accurate
+   and uses -output- samples as the time frame, not source samples. These
+   samples are a fixed amount per second regardless of the source sound format,
+   for example, 48000 samples per second if FMOD is initialized to 48khz output.
+ * Output samples are calculated from source samples with a simple
+   source->output sample rate conversion. i.e.
+        sound_length *= output_rate
+        sound_length /= sound_frequency
+ * When the first sound finishes, the second one should have automatically
+   started. This is a good oppurtunity to queue up the next sound. Repeat
+   step 2.
+ * Make sure the framerate is high enough to queue up a new sound before the
+   other one finishes otherwise you will get gaps.
+
+These sounds are not limited by format, channel count or bit depth like the 
+realtimestitching example is, and can also be modified to allow for overlap,
+by reducing the delay from the first sound playing to the second by the overlap
+amount.
+
+    #define USE_STREAMS = Use 2 stream instances, created while they play.
+    #define USE_STREAMS = Use 6 static wavs, all loaded into memory.
+
+For information on using FMOD example code in your own programs, visit
+https://www.fmod.com/legal
+==============================================================================*/
+#include "fmod.hpp"
+#include "common.h"
+
+//#define USE_STREAMS
+
+FMOD::System *gSystem;
+
+#ifdef USE_STREAMS
+#define NUMSOUNDS 3               /* Use some longer sounds, free and load them on the fly. */
+FMOD::Sound *sound[2] = { 0, 0 }; /* 2 streams active, double buffer them. */
+const char  *soundname[NUMSOUNDS] = { Common_MediaPath("c.ogg"),
+                                      Common_MediaPath("d.ogg"),
+                                      Common_MediaPath("e.ogg") };
+#else
+#define NUMSOUNDS 6                                     /* These sounds will be loaded into memory statically. */
+FMOD::Sound *sound[NUMSOUNDS] = { 0, 0, 0, 0, 0, 0 };   /* 6 sounds active, one for each wav. */
+const char  *soundname[NUMSOUNDS] = { Common_MediaPath("granular/truck_idle_off_01.wav"),
+                                      Common_MediaPath("granular/truck_idle_off_02.wav"),
+                                      Common_MediaPath("granular/truck_idle_off_03.wav"),
+                                      Common_MediaPath("granular/truck_idle_off_04.wav"),
+                                      Common_MediaPath("granular/truck_idle_off_05.wav"),
+                                      Common_MediaPath("granular/truck_idle_off_06.wav") };
+#endif
+
+FMOD::Channel *queue_next_sound(int outputrate, FMOD::Channel *playingchannel, int newindex, int slot)
+{
+    FMOD_RESULT result;
+    FMOD::Channel *newchannel;
+    FMOD::Sound *newsound;
+    
+#ifdef USE_STREAMS  /* Create a new stream */
+    FMOD_CREATESOUNDEXINFO info;
+    memset(&info, 0, sizeof(FMOD_CREATESOUNDEXINFO));
+    info.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
+    info.suggestedsoundtype = FMOD_SOUND_TYPE_OGGVORBIS;
+    result = gSystem->createStream(soundname[newindex], FMOD_IGNORETAGS | FMOD_LOWMEM, &info, &sound[slot]);
+    ERRCHECK(result);
+    newsound = sound[slot];
+#else   /* Use an existing sound that was passed into us */
+    (void)slot;
+    newsound = sound[newindex];
+#endif
+    
+    result = gSystem->playSound(newsound, 0, true, &newchannel);
+    ERRCHECK(result);
+      
+    if (playingchannel)
+    {    
+        unsigned long long startdelay = 0;
+        unsigned int soundlength = 0;
+        float soundfrequency;
+        FMOD::Sound *playingsound;
+        
+        /*
+            Get the start time of the playing channel.
+        */
+        result = playingchannel->getDelay(&startdelay, 0);
+        ERRCHECK(result);
+        
+        /*
+            Grab the length of the playing sound, and its frequency, so we can caluate where to place the new sound on the time line.
+        */
+        result = playingchannel->getCurrentSound(&playingsound);
+        ERRCHECK(result);
+        result = playingsound->getLength(&soundlength, FMOD_TIMEUNIT_PCM);
+        ERRCHECK(result);
+        result = playingchannel->getFrequency(&soundfrequency);
+        ERRCHECK(result);
+        
+        /* 
+            Now calculate the length of the sound in 'output samples'.  
+            Ie if a 44khz sound is 22050 samples long, and the output rate is 48khz, then we want to delay by 24000 output samples.
+        */
+        soundlength *= outputrate;   
+        soundlength /= (int)soundfrequency;
+        
+        startdelay += soundlength; /* Add output rate adjusted sound length, to the clock value of the sound that is currently playing */
+
+        result = newchannel->setDelay(startdelay, 0); /* Set the delay of the new sound to the end of the old sound */
+        ERRCHECK(result);
+    }
+    else
+    {
+        unsigned int bufferlength;
+        unsigned long long startdelay;
+
+        result = gSystem->getDSPBufferSize(&bufferlength, 0);
+        ERRCHECK(result);
+
+        result = newchannel->getDSPClock(0, &startdelay);
+        ERRCHECK(result);
+
+        startdelay += (2 * bufferlength);
+        result = newchannel->setDelay(startdelay, 0);
+        ERRCHECK(result);
+    }
+    
+    {
+        float val, variation;
+        
+        /*
+            Randomize pitch/volume to make it sound more realistic / random.
+        */
+        result = newchannel->getFrequency(&val);
+        ERRCHECK(result);
+        variation = (((float)(rand()%10000) / 5000.0f) - 1.0f); /* -1.0 to +1.0 */
+        val *= (1.0f + (variation * 0.02f));                    /* @22khz, range fluctuates from 21509 to 22491 */
+        result = newchannel->setFrequency(val);
+        ERRCHECK(result);
+
+        result = newchannel->getVolume(&val);
+        ERRCHECK(result);
+        variation = ((float)(rand()%10000) / 10000.0f);         /*  0.0 to 1.0 */
+        val *= (1.0f - (variation * 0.2f));                     /*  0.8 to 1.0 */
+        result = newchannel->setVolume(val);
+        ERRCHECK(result);
+    }   
+        
+    result = newchannel->setPaused(false);
+    ERRCHECK(result);
+       
+    return newchannel;
+}
+
+int FMOD_Main()
+{
+    FMOD::Channel    *channel[2] = { 0,0 };
+    FMOD_RESULT       result;
+    int               outputrate, slot = 0;
+    void             *extradriverdata = 0;
+    bool              paused = false;
+
+    Common_Init(&extradriverdata);
+    
+    result = FMOD::System_Create(&gSystem);
+    ERRCHECK(result);
+    
+    result = gSystem->init(100, FMOD_INIT_NORMAL, extradriverdata);
+    ERRCHECK(result);
+       
+    result = gSystem->getSoftwareFormat(&outputrate, 0, 0);
+    ERRCHECK(result);   
+   
+#if !defined(USE_STREAMS)
+    for (unsigned int count = 0; count < NUMSOUNDS; count++)
+    {
+        result = gSystem->createSound(soundname[count], FMOD_IGNORETAGS, 0, &sound[count]);
+        ERRCHECK(result);
+    }
+#endif
+
+    /*
+        Kick off the first 2 sounds.  First one is immediate, second one will be triggered to start after the first one.
+    */
+    channel[slot] = queue_next_sound(outputrate, channel[1-slot], rand()%NUMSOUNDS, slot);
+    slot = 1-slot;  /* flip */
+    channel[slot] = queue_next_sound(outputrate, channel[1-slot], rand()%NUMSOUNDS, slot);
+    slot = 1-slot;  /* flip */
+
+    do
+    {
+        bool isplaying = false;
+
+        Common_Update();
+
+        if (Common_BtnPress(BTN_ACTION1))
+        {
+            FMOD::ChannelGroup *mastergroup;
+
+            paused = !paused;
+
+            result = gSystem->getMasterChannelGroup(&mastergroup);
+            ERRCHECK(result);
+            result = mastergroup->setPaused(paused);
+            ERRCHECK(result);
+        }
+
+        result = gSystem->update();
+        ERRCHECK(result);
+
+        /*
+            Replace the sound that just finished with a new sound, to create endless seamless stitching!
+        */
+        result = channel[slot]->isPlaying(&isplaying);
+        if (result != FMOD_ERR_INVALID_HANDLE)
+        {
+            ERRCHECK(result);
+        }
+
+        if (!isplaying && !paused)
+        {
+#ifdef USE_STREAMS
+            /* 
+                Release the sound that isn't playing any more. 
+            */
+            result = sound[slot]->release();       
+            ERRCHECK(result);
+            sound[slot] = 0;
+#endif
+
+            /*
+                Replace sound that just ended with a new sound, queued up to trigger exactly after the other sound ends.
+            */
+            channel[slot] = queue_next_sound(outputrate, channel[1-slot], rand()%NUMSOUNDS, slot);
+            slot = 1-slot;  /* flip */
+        }
+
+        Common_Draw("==================================================");
+        Common_Draw("Granular Synthesis SetDelay Example.");
+        Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+        Common_Draw("==================================================");
+        Common_Draw("");
+        Common_Draw("Toggle #define USE_STREAM on/off in code to switch between streams and static samples.");
+        Common_Draw("");
+        Common_Draw("Press %s to pause", Common_BtnStr(BTN_ACTION1));
+        Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
+        Common_Draw("");
+        Common_Draw("Channels are %s", paused ? "paused" : "playing");
+
+        Common_Sleep(10);   /* If you wait too long, ie longer than the length of the shortest sound, you will get gaps. */
+    } while (!Common_BtnPress(BTN_QUIT));
+
+    /*
+        Shut down
+    */
+    for (unsigned int count = 0; count < sizeof(sound) / sizeof(sound[0]); count++)
+    {
+        if (sound[count])
+        {
+            result = sound[count]->release();
+            ERRCHECK(result);
+        }
+    }
+    
+    result = gSystem->release();
+    ERRCHECK(result);
+
+    Common_Close();
+
+    return 0;
+}

SimpleGame/FMOD/api/core/examples/load_from_memory.cpp

@@ -0,0 +1,168 @@
+/*==============================================================================
+Load From Memory Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example is simply a variant of the [Play Sound Example](play_sound.html), 
+but it loads the data into memory then uses the 'load from memory' feature of 
+System::createSound.
+
+For information on using FMOD example code in your own programs, visit
+https://www.fmod.com/legal
+==============================================================================*/
+#include "fmod.hpp"
+#include "common.h"
+
+int FMOD_Main()
+{
+    FMOD::System     *system;
+    FMOD::Sound      *sound1, *sound2, *sound3;
+    FMOD::Channel    *channel = 0;
+    FMOD_RESULT       result;
+    void             *extradriverdata = 0;
+    void             *buff = 0;
+    int               length = 0;
+    FMOD_CREATESOUNDEXINFO exinfo;
+    
+    Common_Init(&extradriverdata);
+
+    /*
+        Create a System object and initialize
+    */
+    result = FMOD::System_Create(&system);
+    ERRCHECK(result);
+
+    result = system->init(32, FMOD_INIT_NORMAL, extradriverdata);
+    ERRCHECK(result);
+    
+    Common_LoadFileMemory(Common_MediaPath("drumloop.wav"), &buff, &length);
+    memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
+    exinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
+    exinfo.length = length;
+
+    result = system->createSound((const char *)buff, FMOD_OPENMEMORY | FMOD_LOOP_OFF, &exinfo, &sound1);
+    ERRCHECK(result);
+    Common_UnloadFileMemory(buff); // don't need the original memory any more.  Note!  If loading as a stream, the memory must stay active so do not free it!
+
+    Common_LoadFileMemory(Common_MediaPath("jaguar.wav"), &buff, &length);
+    memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
+    exinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
+    exinfo.length = length;    
+   
+    result = system->createSound((const char *)buff, FMOD_OPENMEMORY, &exinfo, &sound2);
+    ERRCHECK(result);
+    Common_UnloadFileMemory(buff); // don't need the original memory any more.  Note!  If loading as a stream, the memory must stay active so do not free it!
+    
+    Common_LoadFileMemory(Common_MediaPath("swish.wav"), &buff, &length);
+    memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
+    exinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
+    exinfo.length = length;    
+
+    result = system->createSound((const char *)buff, FMOD_OPENMEMORY, &exinfo, &sound3);
+    ERRCHECK(result);
+    Common_UnloadFileMemory(buff); // don't need the original memory any more.  Note!  If loading as a stream, the memory must stay active so do not free it!
+
+    /*
+        Main loop
+    */
+    do
+    {
+        Common_Update();
+
+        if (Common_BtnPress(BTN_ACTION1))
+        {
+            result = system->playSound(sound1, 0, false, &channel);
+            ERRCHECK(result);
+        }
+
+        if (Common_BtnPress(BTN_ACTION2))
+        {
+            result = system->playSound(sound2, 0, false, &channel);
+            ERRCHECK(result);
+        }
+
+        if (Common_BtnPress(BTN_ACTION3))
+        {
+            result = system->playSound(sound3, 0, false, &channel);
+            ERRCHECK(result);
+        }
+
+        result = system->update();
+        ERRCHECK(result);
+
+        {
+            unsigned int ms = 0;
+            unsigned int lenms = 0;
+            bool         playing = 0;
+            bool         paused = 0;
+            int          channelsplaying = 0;
+
+            if (channel)
+            {
+                FMOD::Sound *currentsound = 0;
+
+                result = channel->isPlaying(&playing);
+                if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
+                {
+                    ERRCHECK(result);
+                }
+
+                result = channel->getPaused(&paused);
+                if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
+                {
+                    ERRCHECK(result);
+                }
+
+                result = channel->getPosition(&ms, FMOD_TIMEUNIT_MS);
+                if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
+                {
+                    ERRCHECK(result);
+                }
+               
+                channel->getCurrentSound(&currentsound);
+                if (currentsound)
+                {
+                    result = currentsound->getLength(&lenms, FMOD_TIMEUNIT_MS);
+                    if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
+                    {
+                        ERRCHECK(result);
+                    }
+                }
+            }
+
+            system->getChannelsPlaying(&channelsplaying, NULL);
+
+            Common_Draw("==================================================");
+            Common_Draw("Load From Memory Example.");
+            Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+            Common_Draw("==================================================");
+            Common_Draw("");
+            Common_Draw("Press %s to play a mono sound (drumloop)", Common_BtnStr(BTN_ACTION1));
+            Common_Draw("Press %s to play a mono sound (jaguar)", Common_BtnStr(BTN_ACTION2));
+            Common_Draw("Press %s to play a stereo sound (swish)", Common_BtnStr(BTN_ACTION3));
+            Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
+            Common_Draw("");
+            Common_Draw("Time %02d:%02d:%02d/%02d:%02d:%02d : %s", ms / 1000 / 60, ms / 1000 % 60, ms / 10 % 100, lenms / 1000 / 60, lenms / 1000 % 60, lenms / 10 % 100, paused ? "Paused " : playing ? "Playing" : "Stopped");
+            Common_Draw("Channels Playing %2d", channelsplaying);
+        }
+
+        Common_Sleep(50);
+    } while (!Common_BtnPress(BTN_QUIT));
+
+    /*
+        Shut down
+    */
+    result = sound1->release();
+    ERRCHECK(result);
+    result = sound2->release();
+    ERRCHECK(result);
+    result = sound3->release();
+    ERRCHECK(result);
+    result = system->close();
+    ERRCHECK(result);
+    result = system->release();
+    ERRCHECK(result);
+
+    Common_Close();
+
+    return 0;
+}

SimpleGame/FMOD/api/core/examples/multiple_speaker.cpp

@@ -0,0 +1,292 @@
+/*==============================================================================
+Multiple Speaker Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to play sounds in multiple speakers, and also how to even
+assign sound subchannels, such as those in a stereo sound to different
+individual speakers.
+
+For information on using FMOD example code in your own programs, visit
+https://www.fmod.com/legal
+==============================================================================*/
+#include "fmod.hpp"
+#include "common.h"
+
+const char *SPEAKERMODE_STRING[] = { "default", "raw", "mono", "stereo", "quad", "surround", "5.1", "7.1" };
+const char *SELECTION_STRING[] = { "Mono from front left speaker",
+                                   "Mono from front right speaker",
+                                   "Mono from center speaker",
+                                   "Mono from surround left speaker",
+                                   "Mono from surround right speaker",
+                                   "Mono from rear left speaker",
+                                   "Mono from rear right speaker",
+                                   "Stereo from front speakers",
+                                   "Stereo from front speakers (channel swapped)",
+                                   "Stereo (right only) from center speaker" };
+const unsigned int SELECTION_COUNT = sizeof(SELECTION_STRING) / sizeof(char *);
+
+bool isSelectionAvailable(FMOD_SPEAKERMODE mode, unsigned int selection)
+{
+    if (mode == FMOD_SPEAKERMODE_MONO || mode == FMOD_SPEAKERMODE_STEREO)
+    {
+        if (selection == 2 || selection == 3 || selection == 4 || selection == 5 || selection == 6 || selection == 9) return false;
+    }
+    else if (mode == FMOD_SPEAKERMODE_QUAD)
+    {
+        if (selection == 2 || selection == 5 || selection == 6 || selection == 9) return false;
+    }
+    else if (mode == FMOD_SPEAKERMODE_SURROUND || mode == FMOD_SPEAKERMODE_5POINT1)
+    {
+        if (selection == 5 || selection == 6) return false;
+    }
+
+    return true;
+}
+
+int FMOD_Main()
+{
+    FMOD::System     *system;
+    FMOD::Sound      *sound1, *sound2;
+    FMOD::Channel    *channel = 0;
+    FMOD_RESULT       result;
+    int               selection = 0;
+    void             *extradriverdata = 0;
+    FMOD_SPEAKERMODE  speakermode = FMOD_SPEAKERMODE_STEREO;
+    
+    Common_Init(&extradriverdata);
+
+    /*
+        Create a System object and initialize.
+    */
+    result = FMOD::System_Create(&system);
+    ERRCHECK(result);
+
+    result = system->init(32, FMOD_INIT_NORMAL, extradriverdata);
+    ERRCHECK(result);
+
+    result = system->getSoftwareFormat(0, &speakermode, 0);
+    ERRCHECK(result);
+
+    result = system->createSound(Common_MediaPath("drumloop.wav"), FMOD_2D | FMOD_LOOP_OFF, 0, &sound1);
+    ERRCHECK(result);
+
+    result = system->createSound(Common_MediaPath("stereo.ogg"), FMOD_2D | FMOD_LOOP_OFF,  0, &sound2);
+    ERRCHECK(result);
+
+    /*
+        Main loop.
+    */
+    do
+    {
+        Common_Update();
+
+        if (Common_BtnPress(BTN_UP) && (selection != 0))
+        {
+            selection--;
+        }
+        
+        if (Common_BtnPress(BTN_DOWN) && (selection != (SELECTION_COUNT - 1)))
+        {
+            selection++;
+        }
+
+        if (Common_BtnPress(BTN_ACTION1) && isSelectionAvailable(speakermode, selection))
+        {
+            if (selection == 0) /* Mono front left */
+            {
+                result = system->playSound(sound1, 0, true, &channel);
+                ERRCHECK(result);
+
+                result = channel->setMixLevelsOutput(1.0f, 0, 0, 0, 0, 0, 0, 0);
+                ERRCHECK(result);
+
+                result = channel->setPaused(false);
+                ERRCHECK(result);
+            }
+            else if (selection == 1) /* Mono front right */
+            {
+                result = system->playSound(sound1, 0, true, &channel);
+                ERRCHECK(result);
+
+                result = channel->setMixLevelsOutput(0, 1.0f, 0, 0, 0, 0, 0, 0);
+                ERRCHECK(result);
+
+                result = channel->setPaused(false);
+                ERRCHECK(result);
+            }
+            else if (selection == 2) /* Mono center */
+            {
+                result = system->playSound(sound1, 0, true, &channel);
+                ERRCHECK(result);
+
+                result = channel->setMixLevelsOutput(0, 0, 1.0f, 0, 0, 0, 0, 0);
+                ERRCHECK(result);
+
+                result = channel->setPaused(false);
+                ERRCHECK(result);
+            }
+            else if (selection == 3) /* Mono surround left */
+            {
+                result = system->playSound(sound1, 0, true, &channel);
+                ERRCHECK(result);
+
+                result = channel->setMixLevelsOutput(0, 0, 0, 0, 1.0f, 0, 0, 0);
+                ERRCHECK(result);
+
+                result = channel->setPaused(false);
+                ERRCHECK(result);
+            }
+            else if (selection == 4) /* Mono surround right */
+            {
+                result = system->playSound(sound1, 0, true, &channel);
+                ERRCHECK(result);
+
+                result = channel->setMixLevelsOutput(0, 0, 0, 0, 0, 1.0f, 0, 0);
+                ERRCHECK(result);
+
+                result = channel->setPaused(false);
+                ERRCHECK(result);
+            }
+            else if (selection == 5) /* Mono rear left */
+            {
+                result = system->playSound(sound1, 0, true, &channel);
+                ERRCHECK(result);
+
+                result = channel->setMixLevelsOutput(0, 0, 0, 0, 0, 0, 1.0f, 0);
+                ERRCHECK(result);
+
+                result = channel->setPaused(false);
+                ERRCHECK(result);
+            }
+            else if (selection == 6) /* Mono rear right */
+            {
+                result = system->playSound(sound1, 0, true, &channel);
+                ERRCHECK(result);
+
+                result = channel->setMixLevelsOutput(0, 0, 0, 0, 0, 0, 0, 1.0f);
+                ERRCHECK(result);
+
+                result = channel->setPaused(false);
+                ERRCHECK(result);
+            }
+            else if (selection == 7) /* Stereo front */
+            {
+                result = system->playSound(sound2, 0, false, &channel);
+                ERRCHECK(result);
+            }
+            else if (selection == 8) /* Stereo front channel swapped */
+            {
+                float matrix[] = { 0.0f, 1.0f,
+                                   1.0f, 0.0f };
+
+                result = system->playSound(sound2, 0, true, &channel);
+                ERRCHECK(result);
+
+                result = channel->setMixMatrix(matrix, 2, 2);
+                ERRCHECK(result);
+
+                result = channel->setPaused(false);
+                ERRCHECK(result);
+            }
+            else if (selection == 9) /* Stereo (right only) center */
+            {
+                float matrix[] = { 0.0f, 0.0f,
+                                   0.0f, 0.0f,
+                                   0.0f, 1.0f };
+
+                result = system->playSound(sound2, 0, true, &channel);
+                ERRCHECK(result);
+
+                result = channel->setMixMatrix(matrix, 3, 2);
+                ERRCHECK(result);
+
+                result = channel->setPaused(false);
+                ERRCHECK(result);
+            }
+        }
+
+        result = system->update();
+        ERRCHECK(result);
+
+        {
+            unsigned int ms = 0;
+            unsigned int lenms = 0;
+            bool         playing = false;
+            bool         paused = false;
+            int          channelsplaying = 0;
+
+            if (channel)
+            {
+                FMOD::Sound *currentsound = 0;
+
+                result = channel->isPlaying(&playing);
+                if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
+                {
+                    ERRCHECK(result);
+                }
+
+                result = channel->getPaused(&paused);
+                if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
+                {
+                    ERRCHECK(result);
+                }
+
+                result = channel->getPosition(&ms, FMOD_TIMEUNIT_MS);
+                if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
+                {
+                    ERRCHECK(result);
+                }
+               
+                channel->getCurrentSound(&currentsound);
+                if (currentsound)
+                {
+                    result = currentsound->getLength(&lenms, FMOD_TIMEUNIT_MS);
+                    if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
+                    {
+                        ERRCHECK(result);
+                    }
+                }
+            }
+
+            result = system->getChannelsPlaying(&channelsplaying, NULL);
+            ERRCHECK(result);
+
+            Common_Draw("==================================================");
+            Common_Draw("Multiple Speaker Example.");
+            Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+            Common_Draw("==================================================");
+            Common_Draw("");
+            Common_Draw("Speaker mode is set to %s%s", SPEAKERMODE_STRING[speakermode], speakermode < FMOD_SPEAKERMODE_7POINT1 ? " causing some speaker options to be unavailable" : "");
+            Common_Draw("");
+            Common_Draw("Press %s or %s to select mode", Common_BtnStr(BTN_UP), Common_BtnStr(BTN_DOWN));
+            Common_Draw("Press %s to play the sound", Common_BtnStr(BTN_ACTION1));
+            for (int i = 0; i < SELECTION_COUNT; i++)
+            {
+                bool disabled = !isSelectionAvailable(speakermode, i);
+                Common_Draw("[%c] %s%s", (selection == i) ? (disabled ? '-' : 'X') : ' ', disabled ? "[N/A] " : "", SELECTION_STRING[i]);
+            }
+            Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
+            Common_Draw("");
+            Common_Draw("Time %02d:%02d:%02d/%02d:%02d:%02d : %s", ms / 1000 / 60, ms / 1000 % 60, ms / 10 % 100, lenms / 1000 / 60, lenms / 1000 % 60, lenms / 10 % 100, paused ? "Paused " : playing ? "Playing" : "Stopped");
+            Common_Draw("Channels playing: %d", channelsplaying);
+        }
+
+        Common_Sleep(50);
+    } while (!Common_BtnPress(BTN_QUIT));
+
+    /*
+        Shut down
+    */
+    result = sound1->release();
+    ERRCHECK(result);
+    result = sound2->release();
+    ERRCHECK(result);
+    result = system->close();
+    ERRCHECK(result);
+    result = system->release();
+    ERRCHECK(result);
+
+    Common_Close();
+
+    return 0;
+}

SimpleGame/FMOD/api/core/examples/multiple_system.cpp

@@ -0,0 +1,193 @@
+/*==============================================================================
+Multiple System Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to play sounds on two different output devices from the
+same application. It creates two FMOD::System objects, selects a different sound
+device for each, then allows the user to play one sound on each device.
+
+Note that sounds created on device A cannot be played on device B and vice
+versa.
+
+For information on using FMOD example code in your own programs, visit
+https://www.fmod.com/legal
+==============================================================================*/
+#include "fmod.hpp"
+#include "common.h"
+
+FMOD_RESULT fetchDriver(FMOD::System *system, int *driver)
+{
+    FMOD_RESULT result;
+    int numdrivers;
+    int selectedindex = 0;
+
+    result = system->getNumDrivers(&numdrivers);
+    ERRCHECK(result);
+
+    if (numdrivers == 0)
+    {
+        result = system->setOutput(FMOD_OUTPUTTYPE_NOSOUND);
+        ERRCHECK(result);
+    }
+
+    do
+    {
+        Common_Update();
+
+        if (Common_BtnPress(BTN_UP) && (selectedindex != 0))
+        {
+            selectedindex--;
+        }
+        if (Common_BtnPress(BTN_DOWN) && (selectedindex != (numdrivers - 1)))
+        {
+            selectedindex++;
+        }
+
+        Common_Draw("==================================================");
+        Common_Draw("Multiple System Example.");
+        Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+        Common_Draw("==================================================");
+        Common_Draw("");
+        Common_Draw("Choose a device for system: 0x%p", system);
+        Common_Draw("");
+        Common_Draw("Use %s and %s to select.", Common_BtnStr(BTN_UP), Common_BtnStr(BTN_DOWN));
+        Common_Draw("Press %s to confirm.", Common_BtnStr(BTN_ACTION1));
+        Common_Draw("");
+        for (int i = 0; i < numdrivers; i++)
+        {
+            char name[256];
+
+            result = system->getDriverInfo(i, name, sizeof(name), 0, 0, 0, 0);
+            ERRCHECK(result);
+
+            Common_Draw("[%c] - %d. %s", selectedindex == i ? 'X' : ' ', i, name);
+        }
+
+        Common_Sleep(50);
+    } while (!Common_BtnPress(BTN_ACTION1) && !Common_BtnPress(BTN_QUIT));
+
+    *driver = selectedindex;
+
+    return FMOD_OK;
+}
+
+int FMOD_Main()
+{
+    FMOD::System     *systemA, *systemB;
+    FMOD::Sound      *soundA, *soundB;
+    FMOD::Channel    *channelA = 0, *channelB = 0;
+    FMOD_RESULT       result;
+    int               driver;
+    void             *extradriverdata = 0;
+    
+    Common_Init(&extradriverdata);
+
+    /*
+        Create Sound Card A
+    */
+    result = FMOD::System_Create(&systemA);
+    ERRCHECK(result);
+
+    result = fetchDriver(systemA, &driver);
+    ERRCHECK(result);
+
+    result = systemA->setDriver(driver);
+    ERRCHECK(result);
+
+    result = systemA->init(32, FMOD_INIT_NORMAL, extradriverdata);
+    ERRCHECK(result);
+
+    /*
+        Create Sound Card B
+    */
+    result = FMOD::System_Create(&systemB);
+    ERRCHECK(result);
+
+    result = fetchDriver(systemB, &driver);
+    ERRCHECK(result);
+
+    result = systemB->setDriver(driver);
+    ERRCHECK(result);
+
+    result = systemB->init(32, FMOD_INIT_NORMAL, extradriverdata);
+    ERRCHECK(result);
+
+    /*
+        Load 1 sample into each soundcard.
+    */
+    result = systemA->createSound(Common_MediaPath("drumloop.wav"), FMOD_LOOP_OFF, 0, &soundA);
+    ERRCHECK(result);
+
+    result = systemB->createSound(Common_MediaPath("jaguar.wav"), FMOD_DEFAULT, 0, &soundB);
+    ERRCHECK(result);
+
+    /*
+        Main loop
+    */
+    do
+    {
+        Common_Update();
+        
+        if (Common_BtnPress(BTN_ACTION1))
+        {
+            result = systemA->playSound(soundA, 0, 0, &channelA);
+            ERRCHECK(result);
+        }
+
+        if (Common_BtnPress(BTN_ACTION2))
+        {
+            result = systemB->playSound(soundB, 0, 0, &channelB);
+            ERRCHECK(result);
+        }
+
+        result = systemA->update();
+        ERRCHECK(result);
+        result = systemB->update();
+        ERRCHECK(result);
+
+        {
+            int channelsplayingA = 0;
+            int channelsplayingB = 0;
+
+            result = systemA->getChannelsPlaying(&channelsplayingA, NULL);
+            ERRCHECK(result);
+            result = systemB->getChannelsPlaying(&channelsplayingB, NULL);
+            ERRCHECK(result);
+
+            Common_Draw("==================================================");
+            Common_Draw("Multiple System Example.");
+            Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+            Common_Draw("==================================================");
+            Common_Draw("");
+            Common_Draw("Press %s to play a sound on device A", Common_BtnStr(BTN_ACTION1));
+            Common_Draw("Press %s to play a sound on device B", Common_BtnStr(BTN_ACTION2));
+            Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
+            Common_Draw("");
+            Common_Draw("Channels playing on A: %d", channelsplayingA);
+            Common_Draw("Channels playing on B: %d", channelsplayingB);
+        }
+        
+        Common_Sleep(50);
+    } while (!Common_BtnPress(BTN_QUIT));
+
+    /*
+        Shut down
+    */
+    result = soundA->release();
+    ERRCHECK(result);
+    result = systemA->close();
+    ERRCHECK(result);
+    result = systemA->release();
+    ERRCHECK(result);
+
+    result = soundB->release();
+    ERRCHECK(result);
+    result = systemB->close();
+    ERRCHECK(result);
+    result = systemB->release();
+    ERRCHECK(result);
+
+    Common_Close();
+
+    return 0;
+}

SimpleGame/FMOD/api/core/examples/net_stream.cpp

@@ -0,0 +1,218 @@
+/*==============================================================================
+Net Stream Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to play streaming audio from an Internet source
+
+For information on using FMOD example code in your own programs, visit
+https://www.fmod.com/legal
+==============================================================================*/
+#include "fmod.hpp"
+#include "common.h"
+
+int FMOD_Main()
+{
+    FMOD::System    *system = 0;
+    FMOD::Sound     *sound = 0;
+    FMOD::Channel   *channel = 0;
+    FMOD_RESULT      result = FMOD_OK;
+    FMOD_OPENSTATE   openstate = FMOD_OPENSTATE_READY;
+    void            *extradriverdata = 0;
+    const int        tagcount = 4;
+    int              tagindex = 0;
+    char             tagstring[tagcount][128] = { };
+    
+    Common_Init(&extradriverdata);
+    
+    /*
+        Create a System object and initialize.
+    */
+    result = FMOD::System_Create(&system);
+    ERRCHECK(result);
+
+    result = system->init(1, FMOD_INIT_NORMAL, extradriverdata);
+    ERRCHECK(result);
+
+    /* Increase the file buffer size a little bit to account for Internet lag. */
+    result = system->setStreamBufferSize(64*1024, FMOD_TIMEUNIT_RAWBYTES);
+    ERRCHECK(result);
+
+    FMOD_CREATESOUNDEXINFO exinfo;
+    memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
+    exinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
+    exinfo.filebuffersize = 1024*16;        /* Increase the default file chunk size to handle seeking inside large playlist files that may be over 2kb. */
+
+    result = system->createSound("http://live-radio01.mediahubaustralia.com/2TJW/mp3/", FMOD_CREATESTREAM | FMOD_NONBLOCKING, &exinfo, &sound);
+    ERRCHECK(result);
+
+    /*
+        Main loop
+    */
+    do
+    {
+        unsigned int    pos = 0;
+        unsigned int    percent = 0;
+        bool            playing = false;
+        bool            paused = false;
+        bool            starving = false;
+        const char     *state = "Stopped";
+        
+        Common_Update();
+
+        if (Common_BtnPress(BTN_ACTION1))
+        {
+            if (channel)
+            {
+                bool paused = false;
+                
+                result = channel->getPaused(&paused);
+                ERRCHECK(result);
+                result = channel->setPaused(!paused);
+                ERRCHECK(result);
+            }
+        }
+        
+        result = system->update();
+        ERRCHECK(result);
+        
+        result = sound->getOpenState(&openstate, &percent, &starving, 0);
+        ERRCHECK(result);
+        
+        {
+            FMOD_TAG tag;
+        
+            /*
+                Read any tags that have arrived, this could happen if a radio station switches
+                to a new song.
+            */
+            while (sound->getTag(0, -1, &tag) == FMOD_OK)
+            {
+                if (tag.datatype == FMOD_TAGDATATYPE_STRING)
+                {
+                    snprintf(tagstring[tagindex], 128, "%s = '%s' (%d bytes)", tag.name, (char *)tag.data, tag.datalen);
+                    tagindex = (tagindex + 1) % tagcount;
+
+                    if (tag.type == FMOD_TAGTYPE_PLAYLIST && !strcmp(tag.name, "FILE"))
+                    {
+                        char url[256] = {};
+
+                        strncpy(url, (const char *)tag.data, 255);  /* data point to sound owned memory, copy it before the sound is released. */
+
+                        result = sound->release();
+                        ERRCHECK(result);
+
+                        result = system->createSound(url, FMOD_CREATESTREAM | FMOD_NONBLOCKING, &exinfo, &sound);    
+                        ERRCHECK(result);
+                    }
+
+                }
+                else if (tag.type == FMOD_TAGTYPE_FMOD)
+                {
+                    /* When a song changes, the sample rate may also change, so compensate here. */
+                    if (!strcmp(tag.name, "Sample Rate Change") && channel)
+                    {
+                        float frequency = *((float *)tag.data);
+                        
+                        result = channel->setFrequency(frequency);
+                        ERRCHECK(result);
+                    }
+                }
+            }
+        }
+            
+        if (channel)
+        {
+            result = channel->getPaused(&paused);
+            ERRCHECK(result);
+            
+            result = channel->isPlaying(&playing);
+            ERRCHECK(result);
+            
+            result = channel->getPosition(&pos, FMOD_TIMEUNIT_MS);
+            ERRCHECK(result);
+            
+            /* Silence the stream until we have sufficient data for smooth playback. */
+            result = channel->setMute(starving);
+            ERRCHECK(result);
+        }
+        else
+        {
+             /* This may fail if the stream isn't ready yet, so don't check the error code. */
+            system->playSound(sound, 0, false, &channel);
+        }
+        
+        if (openstate == FMOD_OPENSTATE_BUFFERING)
+        {
+            state = "Buffering...";
+        }
+        else if (openstate == FMOD_OPENSTATE_CONNECTING)
+        {
+            state = "Connecting...";
+        }
+        else if (paused)
+        {
+            state = "Paused";
+        }
+        else if (playing)
+        {
+            state = "Playing";
+        }
+
+        Common_Draw("==================================================");
+        Common_Draw("Net Stream Example.");
+        Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+        Common_Draw("==================================================");
+        Common_Draw("");
+        Common_Draw("Press %s to toggle pause", Common_BtnStr(BTN_ACTION1));
+        Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
+        Common_Draw("");
+        Common_Draw("Time = %02d:%02d:%02d", pos / 1000 / 60, pos / 1000 % 60, pos / 10 % 100);
+        Common_Draw("State = %s %s", state, starving ? "(STARVING)" : "");
+        Common_Draw("Buffer Percentage = %d", percent);
+        Common_Draw("");
+        Common_Draw("Tags:");
+        for (int i = tagindex; i < (tagindex + tagcount); i++)
+        {
+            Common_Draw("%s", tagstring[i % tagcount]);
+            Common_Draw("");
+        }
+
+        Common_Sleep(50);
+    } while (!Common_BtnPress(BTN_QUIT));
+
+    /*
+        Stop the channel, then wait for it to finish opening before we release it.
+    */    
+    if (channel)
+    {
+        result = channel->stop();
+        ERRCHECK(result);
+    }
+
+    do
+    {
+        Common_Update();
+        Common_Draw("Waiting for sound to finish opening before trying to release it....", Common_BtnStr(BTN_ACTION1));
+        Common_Sleep(50);
+        
+        result = system->update();
+        ERRCHECK(result);
+
+        result = sound->getOpenState(&openstate, 0, 0, 0);
+        ERRCHECK(result);
+    } while (openstate != FMOD_OPENSTATE_READY);
+
+    /*
+        Shut down
+    */
+    result = sound->release();
+    ERRCHECK(result);
+    result = system->close();
+    ERRCHECK(result);
+    result = system->release();
+    ERRCHECK(result);
+
+    Common_Close();
+    
+    return 0;
+}

SimpleGame/FMOD/api/core/examples/play_sound.cpp

@@ -0,0 +1,152 @@
+/*==============================================================================
+Play Sound Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to simply load and play multiple sounds, the simplest 
+usage of FMOD. By default FMOD will decode the entire file into memory when it
+loads. If the sounds are big and possibly take up a lot of RAM it would be
+better to use the FMOD_CREATESTREAM flag, this will stream the file in realtime
+as it plays.
+
+For information on using FMOD example code in your own programs, visit
+https://www.fmod.com/legal
+==============================================================================*/
+#include "fmod.hpp"
+#include "common.h"
+
+int FMOD_Main()
+{
+    FMOD::System     *system;
+    FMOD::Sound      *sound1, *sound2, *sound3;
+    FMOD::Channel    *channel = 0;
+    FMOD_RESULT       result;
+    void             *extradriverdata = 0;
+    
+    Common_Init(&extradriverdata);
+
+    /*
+        Create a System object and initialize
+    */
+    result = FMOD::System_Create(&system);
+    ERRCHECK(result);
+
+    result = system->init(32, FMOD_INIT_NORMAL, extradriverdata);
+    ERRCHECK(result);
+
+    result = system->createSound(Common_MediaPath("drumloop.wav"), FMOD_DEFAULT, 0, &sound1);
+    ERRCHECK(result);
+
+    result = sound1->setMode(FMOD_LOOP_OFF);    /* drumloop.wav has embedded loop points which automatically makes looping turn on, */
+    ERRCHECK(result);                           /* so turn it off here.  We could have also just put FMOD_LOOP_OFF in the above CreateSound call. */
+
+    result = system->createSound(Common_MediaPath("jaguar.wav"), FMOD_DEFAULT, 0, &sound2);
+    ERRCHECK(result);
+
+    result = system->createSound(Common_MediaPath("swish.wav"), FMOD_DEFAULT, 0, &sound3);
+    ERRCHECK(result);
+
+    /*
+        Main loop
+    */
+    do
+    {
+        Common_Update();
+
+        if (Common_BtnPress(BTN_ACTION1))
+        {
+            result = system->playSound(sound1, 0, false, &channel);
+            ERRCHECK(result);
+        }
+
+        if (Common_BtnPress(BTN_ACTION2))
+        {
+            result = system->playSound(sound2, 0, false, &channel);
+            ERRCHECK(result);
+        }
+
+        if (Common_BtnPress(BTN_ACTION3))
+        {
+            result = system->playSound(sound3, 0, false, &channel);
+            ERRCHECK(result);
+        }
+
+        result = system->update();
+        ERRCHECK(result);
+
+        {
+            unsigned int ms = 0;
+            unsigned int lenms = 0;
+            bool         playing = 0;
+            bool         paused = 0;
+            int          channelsplaying = 0;
+
+            if (channel)
+            {
+                FMOD::Sound *currentsound = 0;
+
+                result = channel->isPlaying(&playing);
+                if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
+                {
+                    ERRCHECK(result);
+                }
+
+                result = channel->getPaused(&paused);
+                if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
+                {
+                    ERRCHECK(result);
+                }
+
+                result = channel->getPosition(&ms, FMOD_TIMEUNIT_MS);
+                if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
+                {
+                    ERRCHECK(result);
+                }
+               
+                channel->getCurrentSound(&currentsound);
+                if (currentsound)
+                {
+                    result = currentsound->getLength(&lenms, FMOD_TIMEUNIT_MS);
+                    if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
+                    {
+                        ERRCHECK(result);
+                    }
+                }
+            }
+
+            system->getChannelsPlaying(&channelsplaying, NULL);
+
+            Common_Draw("==================================================");
+            Common_Draw("Play Sound Example.");
+            Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+            Common_Draw("==================================================");
+            Common_Draw("");
+            Common_Draw("Press %s to play a mono sound (drumloop)", Common_BtnStr(BTN_ACTION1));
+            Common_Draw("Press %s to play a mono sound (jaguar)", Common_BtnStr(BTN_ACTION2));
+            Common_Draw("Press %s to play a stereo sound (swish)", Common_BtnStr(BTN_ACTION3));
+            Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
+            Common_Draw("");
+            Common_Draw("Time %02d:%02d:%02d/%02d:%02d:%02d : %s", ms / 1000 / 60, ms / 1000 % 60, ms / 10 % 100, lenms / 1000 / 60, lenms / 1000 % 60, lenms / 10 % 100, paused ? "Paused " : playing ? "Playing" : "Stopped");
+            Common_Draw("Channels Playing %d", channelsplaying);
+        }
+
+        Common_Sleep(50);
+    } while (!Common_BtnPress(BTN_QUIT));
+
+    /*
+        Shut down
+    */
+    result = sound1->release();
+    ERRCHECK(result);
+    result = sound2->release();
+    ERRCHECK(result);
+    result = sound3->release();
+    ERRCHECK(result);
+    result = system->close();
+    ERRCHECK(result);
+    result = system->release();
+    ERRCHECK(result);
+
+    Common_Close();
+
+    return 0;
+}

SimpleGame/FMOD/api/core/examples/play_stream.cpp

@@ -0,0 +1,143 @@
+/*==============================================================================
+Play Stream Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to simply play a stream such as an MP3 or WAV. The stream
+behaviour is achieved by specifying FMOD_CREATESTREAM in the call to 
+System::createSound. This makes FMOD decode the file in realtime as it plays,
+instead of loading it all at once which uses far less memory in exchange for a
+small runtime CPU hit.
+
+For information on using FMOD example code in your own programs, visit
+https://www.fmod.com/legal
+==============================================================================*/
+#include "fmod.hpp"
+#include "common.h"
+
+int FMOD_Main()
+{
+    FMOD::System     *system;
+    FMOD::Sound      *sound, *sound_to_play;
+    FMOD::Channel    *channel = 0;
+    FMOD_RESULT       result;
+    void             *extradriverdata = 0;
+    int               numsubsounds;
+    
+    Common_Init(&extradriverdata);
+
+    /*
+        Create a System object and initialize.
+    */
+    result = FMOD::System_Create(&system);
+    ERRCHECK(result);
+
+    result = system->init(32, FMOD_INIT_NORMAL, extradriverdata);
+    ERRCHECK(result);
+
+    /*
+        This example uses an FSB file, which is a preferred pack format for fmod containing multiple sounds.
+        This could just as easily be exchanged with a wav/mp3/ogg file for example, but in this case you wouldnt need to call getSubSound.
+        Because getNumSubSounds is called here the example would work with both types of sound file (packed vs single).
+    */
+    result = system->createStream(Common_MediaPath("wave_vorbis.fsb"), FMOD_LOOP_NORMAL | FMOD_2D, 0, &sound);
+    ERRCHECK(result);
+
+    result = sound->getNumSubSounds(&numsubsounds);
+    ERRCHECK(result);
+
+    if (numsubsounds)
+    {
+        sound->getSubSound(0, &sound_to_play);
+        ERRCHECK(result);
+    }
+    else
+    {
+        sound_to_play = sound;
+    }
+
+    /*
+        Play the sound.
+    */
+    result = system->playSound(sound_to_play, 0, false, &channel);
+    ERRCHECK(result);
+
+    /*
+        Main loop.
+    */
+    do
+    {
+        Common_Update();
+
+        if (Common_BtnPress(BTN_ACTION1))
+        {
+            bool paused;
+            result = channel->getPaused(&paused);
+            ERRCHECK(result);
+            result = channel->setPaused(!paused);
+            ERRCHECK(result);
+        }
+
+        result = system->update();
+        ERRCHECK(result);
+
+        {
+            unsigned int ms = 0;
+            unsigned int lenms = 0;
+            bool         playing = false;
+            bool         paused = false;
+
+            if (channel)
+            {
+                result = channel->isPlaying(&playing);
+                if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE))
+                {
+                    ERRCHECK(result);
+                }
+
+                result = channel->getPaused(&paused);
+                if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE))
+                {
+                    ERRCHECK(result);
+                }
+
+                result = channel->getPosition(&ms, FMOD_TIMEUNIT_MS);
+                if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE))
+                {
+                    ERRCHECK(result);
+                }
+               
+                result = sound_to_play->getLength(&lenms, FMOD_TIMEUNIT_MS);
+                if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE))
+                {
+                    ERRCHECK(result);
+                }
+            }
+
+            Common_Draw("==================================================");
+            Common_Draw("Play Stream Example.");
+            Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+            Common_Draw("==================================================");
+            Common_Draw("");
+            Common_Draw("Press %s to toggle pause", Common_BtnStr(BTN_ACTION1));
+            Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
+            Common_Draw("");
+            Common_Draw("Time %02d:%02d:%02d/%02d:%02d:%02d : %s", ms / 1000 / 60, ms / 1000 % 60, ms / 10 % 100, lenms / 1000 / 60, lenms / 1000 % 60, lenms / 10 % 100, paused ? "Paused " : playing ? "Playing" : "Stopped");
+        }
+
+        Common_Sleep(50);
+    } while (!Common_BtnPress(BTN_QUIT));
+
+    /*
+        Shut down
+    */
+    result = sound->release();  /* Release the parent, not the sound that was retrieved with getSubSound. */
+    ERRCHECK(result);
+    result = system->close();
+    ERRCHECK(result);
+    result = system->release();
+    ERRCHECK(result);
+
+    Common_Close();
+
+    return 0;
+}

SimpleGame/FMOD/api/core/examples/plugins/BladeMP3EncDLL.h

@@ -0,0 +1,278 @@
+/*
+ * Blade Type of DLL Interface for Lame encoder
+ *
+ * Copyright (c) 1999-2002 A.L. Faber
+ * Based on bladedll.h version 1.0 written by Jukka Poikolainen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA  02111-1307, USA.
+ */
+
+#pragma once
+
+#ifdef __GNUC__
+#define ATTRIBUTE_PACKED	__attribute__((packed))
+#else
+#define ATTRIBUTE_PACKED
+#pragma pack(push)
+#pragma pack(1)
+#endif
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/* encoding formats */
+
+#define		BE_CONFIG_MP3			0										
+#define		BE_CONFIG_LAME			256		
+
+/* type definitions */
+
+typedef		void*			HBE_STREAM;
+typedef		HBE_STREAM				*PHBE_STREAM;
+typedef		unsigned long			BE_ERR;
+
+/* error codes */
+
+#define		BE_ERR_SUCCESSFUL					0x00000000
+#define		BE_ERR_INVALID_FORMAT				0x00000001
+#define		BE_ERR_INVALID_FORMAT_PARAMETERS	0x00000002
+#define		BE_ERR_NO_MORE_HANDLES				0x00000003
+#define		BE_ERR_INVALID_HANDLE				0x00000004
+#define		BE_ERR_BUFFER_TOO_SMALL				0x00000005
+
+/* other constants */
+
+#define		BE_MAX_HOMEPAGE			128
+
+/* format specific variables */
+
+#define		BE_MP3_MODE_STEREO		0
+#define		BE_MP3_MODE_JSTEREO		1
+#define		BE_MP3_MODE_DUALCHANNEL	2
+#define		BE_MP3_MODE_MONO		3
+
+
+
+#define		MPEG1	1
+#define		MPEG2	0
+
+#ifdef _BLADEDLL
+#undef FLOAT
+	#include <Windows.h>
+#endif
+
+#define CURRENT_STRUCT_VERSION 1
+#define CURRENT_STRUCT_SIZE sizeof(BE_CONFIG)	// is currently 331 bytes
+
+
+typedef enum
+{
+	VBR_METHOD_NONE			= -1,
+	VBR_METHOD_DEFAULT		=  0,
+	VBR_METHOD_OLD			=  1,
+	VBR_METHOD_NEW			=  2,
+	VBR_METHOD_MTRH			=  3,
+	VBR_METHOD_ABR			=  4
+} VBRMETHOD;
+
+typedef enum 
+{
+	LQP_NOPRESET			=-1,
+
+	// QUALITY PRESETS
+	LQP_NORMAL_QUALITY		= 0,
+	LQP_LOW_QUALITY			= 1,
+	LQP_HIGH_QUALITY		= 2,
+	LQP_VOICE_QUALITY		= 3,
+	LQP_R3MIX				= 4,
+	LQP_VERYHIGH_QUALITY	= 5,
+	LQP_STANDARD			= 6,
+	LQP_FAST_STANDARD		= 7,
+	LQP_EXTREME				= 8,
+	LQP_FAST_EXTREME		= 9,
+	LQP_INSANE				= 10,
+	LQP_ABR					= 11,
+	LQP_CBR					= 12,
+	LQP_MEDIUM				= 13,
+	LQP_FAST_MEDIUM			= 14,
+
+	// NEW PRESET VALUES
+	LQP_PHONE	=1000,
+	LQP_SW		=2000,
+	LQP_AM		=3000,
+	LQP_FM		=4000,
+	LQP_VOICE	=5000,
+	LQP_RADIO	=6000,
+	LQP_TAPE	=7000,
+	LQP_HIFI	=8000,
+	LQP_CD		=9000,
+	LQP_STUDIO	=10000
+
+} LAME_QUALITY_PRESET;
+
+
+
+typedef struct	{
+	DWORD	dwConfig;			// BE_CONFIG_XXXXX
+								// Currently only BE_CONFIG_MP3 is supported
+	union	{
+
+		struct	{
+
+			DWORD	dwSampleRate;		// 48000, 44100 and 32000 allowed
+			BYTE	byMode;			// BE_MP3_MODE_STEREO, BE_MP3_MODE_DUALCHANNEL, BE_MP3_MODE_MONO
+			WORD	wBitrate;		// 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256 and 320 allowed
+			BOOL	bPrivate;		
+			BOOL	bCRC;
+			BOOL	bCopyright;
+			BOOL	bOriginal;
+
+			} mp3;					// BE_CONFIG_MP3
+
+			struct
+			{
+			// STRUCTURE INFORMATION
+			DWORD			dwStructVersion;	
+			DWORD			dwStructSize;
+
+			// BASIC ENCODER SETTINGS
+			DWORD			dwSampleRate;		// SAMPLERATE OF INPUT FILE
+			DWORD			dwReSampleRate;		// DOWNSAMPLERATE, 0=ENCODER DECIDES  
+			LONG			nMode;				// BE_MP3_MODE_STEREO, BE_MP3_MODE_DUALCHANNEL, BE_MP3_MODE_MONO
+			DWORD			dwBitrate;			// CBR bitrate, VBR min bitrate
+			DWORD			dwMaxBitrate;		// CBR ignored, VBR Max bitrate
+			LONG			nPreset;			// Quality preset, use one of the settings of the LAME_QUALITY_PRESET enum
+			DWORD			dwMpegVersion;		// FUTURE USE, MPEG-1 OR MPEG-2
+			DWORD			dwPsyModel;			// FUTURE USE, SET TO 0
+			DWORD			dwEmphasis;			// FUTURE USE, SET TO 0
+
+			// BIT STREAM SETTINGS
+			BOOL			bPrivate;			// Set Private Bit (TRUE/FALSE)
+			BOOL			bCRC;				// Insert CRC (TRUE/FALSE)
+			BOOL			bCopyright;			// Set Copyright Bit (TRUE/FALSE)
+			BOOL			bOriginal;			// Set Original Bit (TRUE/FALSE)
+			
+			// VBR STUFF
+			BOOL			bWriteVBRHeader;	// WRITE XING VBR HEADER (TRUE/FALSE)
+			BOOL			bEnableVBR;			// USE VBR ENCODING (TRUE/FALSE)
+			INT				nVBRQuality;		// VBR QUALITY 0..9
+			DWORD			dwVbrAbr_bps;		// Use ABR in stead of nVBRQuality
+			VBRMETHOD		nVbrMethod;
+			BOOL			bNoRes;				// Disable Bit resorvoir (TRUE/FALSE)
+
+			// MISC SETTINGS
+			BOOL			bStrictIso;			// Use strict ISO encoding rules (TRUE/FALSE)
+			WORD			nQuality;			// Quality Setting, HIGH BYTE should be NOT LOW byte, otherwhise quality=5
+
+			// FUTURE USE, SET TO 0, align strucutre to 331 bytes
+			BYTE			btReserved[255-4*sizeof(DWORD) - sizeof( WORD )];
+
+			} LHV1;					// LAME header version 1
+
+		struct	{
+
+			DWORD	dwSampleRate;
+			BYTE	byMode;
+			WORD	wBitrate;
+			BYTE	byEncodingMethod;
+
+		} aac;
+
+	} format;
+		
+} BE_CONFIG, *PBE_CONFIG ATTRIBUTE_PACKED;
+
+
+typedef struct	{
+
+	// BladeEnc DLL Version number
+
+	BYTE	byDLLMajorVersion;
+	BYTE	byDLLMinorVersion;
+
+	// BladeEnc Engine Version Number
+
+	BYTE	byMajorVersion;
+	BYTE	byMinorVersion;
+
+	// DLL Release date
+
+	BYTE	byDay;
+	BYTE	byMonth;
+	WORD	wYear;
+
+	// BladeEnc	Homepage URL
+
+	CHAR	zHomepage[BE_MAX_HOMEPAGE + 1];	
+
+	BYTE	byAlphaLevel;
+	BYTE	byBetaLevel;
+	BYTE	byMMXEnabled;
+
+	BYTE	btReserved[125];
+
+
+} BE_VERSION, *PBE_VERSION ATTRIBUTE_PACKED;
+
+#ifndef _BLADEDLL
+
+typedef BE_ERR	(*BEINITSTREAM)			(PBE_CONFIG, PDWORD, PDWORD, PHBE_STREAM);
+typedef BE_ERR	(*BEENCODECHUNK)		(HBE_STREAM, DWORD, PSHORT, PBYTE, PDWORD);
+
+// added for floating point audio  -- DSPguru, jd
+typedef BE_ERR	(*BEENCODECHUNKFLOATS16NI)	(HBE_STREAM, DWORD, PFLOAT, PFLOAT, PBYTE, PDWORD);
+typedef BE_ERR	(*BEDEINITSTREAM)			(HBE_STREAM, PBYTE, PDWORD);
+typedef BE_ERR	(*BECLOSESTREAM)			(HBE_STREAM);
+typedef VOID	(*BEVERSION)				(PBE_VERSION);
+typedef BE_ERR	(*BEWRITEVBRHEADER)			(LPCSTR);
+typedef BE_ERR	(*BEWRITEINFOTAG)			(HBE_STREAM, LPCSTR );
+
+#define	TEXT_BEINITSTREAM				"beInitStream"
+#define	TEXT_BEENCODECHUNK				"beEncodeChunk"
+#define	TEXT_BEENCODECHUNKFLOATS16NI	"beEncodeChunkFloatS16NI"
+#define	TEXT_BEDEINITSTREAM				"beDeinitStream"
+#define	TEXT_BECLOSESTREAM				"beCloseStream"
+#define	TEXT_BEVERSION					"beVersion"
+#define	TEXT_BEWRITEVBRHEADER			"beWriteVBRHeader"
+#define	TEXT_BEFLUSHNOGAP				"beFlushNoGap"
+#define	TEXT_BEWRITEINFOTAG				"beWriteInfoTag"
+
+
+#else
+
+__declspec(dllexport) BE_ERR	beInitStream(PBE_CONFIG pbeConfig, PDWORD dwSamples, PDWORD dwBufferSize, PHBE_STREAM phbeStream);
+__declspec(dllexport) BE_ERR	beEncodeChunk(HBE_STREAM hbeStream, DWORD nSamples, PSHORT pSamples, PBYTE pOutput, PDWORD pdwOutput);
+
+// added for floating point audio  -- DSPguru, jd
+__declspec(dllexport) BE_ERR	beEncodeChunkFloatS16NI(HBE_STREAM hbeStream, DWORD nSamples, PFLOAT buffer_l, PFLOAT buffer_r, PBYTE pOutput, PDWORD pdwOutput);
+__declspec(dllexport) BE_ERR	beDeinitStream(HBE_STREAM hbeStream, PBYTE pOutput, PDWORD pdwOutput);
+__declspec(dllexport) BE_ERR	beCloseStream(HBE_STREAM hbeStream);
+__declspec(dllexport) VOID	beVersion(PBE_VERSION pbeVersion);
+__declspec(dllexport) BE_ERR	beWriteVBRHeader(LPCSTR lpszFileName);
+__declspec(dllexport) BE_ERR	beFlushNoGap(HBE_STREAM hbeStream, PBYTE pOutput, PDWORD pdwOutput);
+__declspec(dllexport) BE_ERR	beWriteInfoTag( HBE_STREAM hbeStream, LPCSTR lpszFileName );
+
+#endif
+
+#ifdef	__cplusplus
+}
+#endif
+
+#ifndef __GNUC__
+#pragma pack(pop)
+#endif
+

SimpleGame/FMOD/api/core/examples/plugins/fmod_codec_raw.cpp

@@ -0,0 +1,133 @@
+/*===============================================================================================
+Raw Codec Plugin Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to create a codec that reads raw PCM data.
+
+1. The codec can be compiled as a DLL, using the reserved function name 'FMODGetCodecDescription' 
+   as the only export symbol, and at runtime, the dll can be loaded in with System::loadPlugin.
+
+2. Alternatively a codec of this type can be compiled directly into the program that uses it, and 
+   you just register the codec into FMOD with System::registerCodec.   This puts the codec into 
+   the FMOD system, just the same way System::loadPlugin would if it was an external file.
+
+3. The 'open' callback is the first thing called, and FMOD already has a file handle open for it.
+   In the open callback you can use FMOD_CODEC_STATE::fileread / FMOD_CODEC_STATE::fileseek to parse 
+   your own file format, and return FMOD_ERR_FORMAT if it is not the format you support.  Return 
+   FMOD_OK if it succeeds your format test.
+
+4. When an FMOD user calls System::createSound or System::createStream, the 'open' callback is called
+   once after FMOD tries to open it as many other types of file.   If you want to override FMOD's 
+   internal codecs then use the 'priority' parameter of System::loadPlugin or System::registerCodec.
+
+5. In the open callback, tell FMOD what sort of PCM format the sound will produce with the 
+   FMOD_CODEC_STATE::waveformat member.
+
+6. The 'close' callback is called when Sound::release is called by the FMOD user.
+
+7. The 'read' callback is called when System::createSound or System::createStream wants to receive 
+   PCM data, in the format that you specified with FMOD_CODEC_STATE::waveformat.  Data is 
+   interleaved as decribed in the terminology section of the FMOD API documentation.
+   When a stream is being used, the read callback will be called repeatedly, using a size value 
+   determined by the decode buffer size of the stream.  See FMOD_CREATESOUNDEXINFO or 
+   FMOD_ADVANCEDSETTINGS.
+
+8. The 'seek' callback is called when Channel::setPosition is called, or when looping a sound 
+   when it is a stream.
+
+===============================================================================================*/
+
+#include <stdio.h>
+
+#include "fmod.h"
+
+FMOD_RESULT F_CALL rawopen(FMOD_CODEC_STATE *codec, FMOD_MODE usermode, FMOD_CREATESOUNDEXINFO *userexinfo);
+FMOD_RESULT F_CALL rawclose(FMOD_CODEC_STATE *codec);
+FMOD_RESULT F_CALL rawread(FMOD_CODEC_STATE *codec, void *buffer, unsigned int size, unsigned int *read);
+FMOD_RESULT F_CALL rawsetposition(FMOD_CODEC_STATE *codec, int subsound, unsigned int position, FMOD_TIMEUNIT postype);
+
+FMOD_CODEC_DESCRIPTION rawcodec =
+{
+    FMOD_CODEC_PLUGIN_VERSION,          // Plugin version.
+    "FMOD Raw player plugin example",   // Name.
+    0x00010000,                         // Version 0xAAAABBBB   A = major, B = minor.
+    0,                                  // Don't force everything using this codec to be a stream
+    FMOD_TIMEUNIT_PCMBYTES,             // The time format we would like to accept into setposition/getposition.
+    &rawopen,                           // Open callback.
+    &rawclose,                          // Close callback.
+    &rawread,                           // Read callback.
+    0,                                  // Getlength callback.  (If not specified FMOD return the length in FMOD_TIMEUNIT_PCM, FMOD_TIMEUNIT_MS or FMOD_TIMEUNIT_PCMBYTES units based on the lengthpcm member of the FMOD_CODEC structure).
+    &rawsetposition,                    // Setposition callback.
+    0,                                  // Getposition callback. (only used for timeunit types that are not FMOD_TIMEUNIT_PCM, FMOD_TIMEUNIT_MS and FMOD_TIMEUNIT_PCMBYTES).
+    0                                   // Sound create callback (don't need it)
+};
+
+
+/*
+    FMODGetCodecDescription is mandatory for every fmod plugin.  This is the symbol the registerplugin function searches for.
+    Must be declared with F_CALL to make it export as stdcall.
+    MUST BE EXTERN'ED AS C!  C++ functions will be mangled incorrectly and not load in fmod.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+F_EXPORT FMOD_CODEC_DESCRIPTION * F_CALL FMODGetCodecDescription()
+{
+    return &rawcodec;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+
+static FMOD_CODEC_WAVEFORMAT    rawwaveformat;
+
+/*
+    The actual codec code.
+
+    Note that the callbacks uses FMOD's supplied file system callbacks.
+
+    This is important as even though you might want to open the file yourself, you would lose the following benefits.
+    1. Automatic support of memory files, CDDA based files, and HTTP/TCPIP based files.
+    2. "fileoffset" / "length" support when user calls System::createSound with FMOD_CREATESOUNDEXINFO structure.
+    3. Buffered file access.
+    FMOD files are high level abstracts that support all sorts of 'file', they are not just disk file handles.
+    If you want FMOD to use your own filesystem (and potentially lose the above benefits) use System::setFileSystem.
+*/
+
+FMOD_RESULT F_CALL rawopen(FMOD_CODEC_STATE *codec, FMOD_MODE /*usermode*/, FMOD_CREATESOUNDEXINFO * /*userexinfo*/)
+{          
+    rawwaveformat.channels     = 2;
+    rawwaveformat.format       = FMOD_SOUND_FORMAT_PCM16;
+    rawwaveformat.frequency    = 44100;
+    rawwaveformat.pcmblocksize = 0;
+    unsigned int size;
+    FMOD_CODEC_FILE_SIZE(codec, &size);
+    rawwaveformat.lengthpcm    = size / (rawwaveformat.channels * sizeof(short));   /* bytes converted to PCM samples */;
+
+    codec->numsubsounds      = 0;                    /* number of 'subsounds' in this sound.  For most codecs this is 0, only multi sound codecs such as FSB or CDDA have subsounds. */
+    codec->waveformat        = &rawwaveformat;
+    codec->plugindata        = 0;                    /* user data value */
+        
+    /* If your file format needs to read data to determine the format and load metadata, do so here with codec->fileread/fileseek function pointers.  This will handle reading from disk/memory or internet. */
+    
+    return FMOD_OK;
+}
+
+FMOD_RESULT F_CALL rawclose(FMOD_CODEC_STATE * /*codec*/)
+{
+    return FMOD_OK;
+}
+
+FMOD_RESULT F_CALL rawread(FMOD_CODEC_STATE *codec, void *buffer, unsigned int size, unsigned int *read)
+{
+    return FMOD_CODEC_FILE_READ(codec, buffer, size, read);
+}
+
+FMOD_RESULT F_CALL rawsetposition(FMOD_CODEC_STATE *codec, int /*subsound*/, unsigned int position, FMOD_TIMEUNIT /*postype*/)
+{
+    return FMOD_CODEC_FILE_SEEK(codec, position, 0);
+}
+

SimpleGame/FMOD/api/core/examples/plugins/fmod_distance_filter.cpp

@@ -0,0 +1,466 @@
+/*==============================================================================
+Distance Filter DSP Plugin Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to create a distance filter DSP effect.
+==============================================================================*/
+
+#ifdef WIN32
+    #define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "fmod.hpp"
+
+extern "C" 
+{
+    F_EXPORT FMOD_DSP_DESCRIPTION* F_CALL FMODGetDSPDescription();
+}
+
+const float FMOD_DISTANCE_FILTER_PARAM_MAX_DISTANCE_MIN     = 0.0f;
+const float FMOD_DISTANCE_FILTER_PARAM_MAX_DISTANCE_MAX     = 10000.0f;
+const float FMOD_DISTANCE_FILTER_PARAM_MAX_DISTANCE_DEFAULT = 20.0f;
+const float FMOD_DISTANCE_FILTER_PARAM_BANDPASS_FREQUENCY_MIN     = 10.0f;
+const float FMOD_DISTANCE_FILTER_PARAM_BANDPASS_FREQUENCY_MAX     = 22000.0f;
+const float FMOD_DISTANCE_FILTER_PARAM_BANDPASS_FREQUENCY_DEFAULT = 1500.0f;
+
+enum
+{
+    FMOD_DISTANCE_FILTER_MAX_DISTANCE,
+    FMOD_DISTANCE_FILTER_BANDPASS_FREQUENCY,
+    FMOD_DISTANCE_FILTER_3D_ATTRIBUTES,
+    FMOD_DISTANCE_FILTER_NUM_PARAMETERS
+};
+
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dspcreate       (FMOD_DSP_STATE *dsp_state);
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dsprelease      (FMOD_DSP_STATE *dsp_state);
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dspreset        (FMOD_DSP_STATE *dsp_state);
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dspread         (FMOD_DSP_STATE *dsp_state, float *inbuffer, float *outbuffer, unsigned int length, int inchannels, int *outchannels);
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dspprocess      (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);
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dspsetparamfloat(FMOD_DSP_STATE *dsp_state, int index, float value);
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dspsetparamint  (FMOD_DSP_STATE *dsp_state, int index, int value);
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dspsetparambool (FMOD_DSP_STATE *dsp_state, int index, FMOD_BOOL value);
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dspsetparamdata (FMOD_DSP_STATE *dsp_state, int index, void *data, unsigned int length);
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dspgetparamfloat(FMOD_DSP_STATE *dsp_state, int index, float *value, char *valuestr);
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dspgetparamint  (FMOD_DSP_STATE *dsp_state, int index, int *value, char *valuestr);
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dspgetparambool (FMOD_DSP_STATE *dsp_state, int index, FMOD_BOOL *value, char *valuestr);
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dspgetparamdata (FMOD_DSP_STATE *dsp_state, int index, void **value, unsigned int *length, char *valuestr);
+FMOD_RESULT F_CALL FMOD_DistanceFilter_shouldiprocess  (FMOD_DSP_STATE *dsp_state, FMOD_BOOL inputsidle, unsigned int length, FMOD_CHANNELMASK inmask, int inchannels, FMOD_SPEAKERMODE speakermode);
+
+static FMOD_DSP_PARAMETER_DESC p_max_distance;
+static FMOD_DSP_PARAMETER_DESC p_bandpass_frequency;
+static FMOD_DSP_PARAMETER_DESC p_3d_attributes;
+
+FMOD_DSP_PARAMETER_DESC *FMOD_DistanceFilter_dspparam[FMOD_DISTANCE_FILTER_NUM_PARAMETERS] =
+{
+    &p_max_distance,
+    &p_bandpass_frequency,
+    &p_3d_attributes
+};
+
+FMOD_DSP_DESCRIPTION FMOD_DistanceFilter_Desc =
+{
+    FMOD_PLUGIN_SDK_VERSION,
+    "FMOD Distance Filter",                 // name
+    0x00010000,                             // plugin version
+    1,                                      // number of input buffers to process
+    1,                                      // number of output buffers to process
+    FMOD_DistanceFilter_dspcreate,
+    FMOD_DistanceFilter_dsprelease,
+    FMOD_DistanceFilter_dspreset,
+    FMOD_DistanceFilter_dspread,
+    0,  // FMOD_DistanceFilter_dspprocess,  // *** declare this callback instead of FMOD_DistanceFilter_dspread if the plugin sets the output channel count ***
+    0,
+    FMOD_DISTANCE_FILTER_NUM_PARAMETERS,
+    FMOD_DistanceFilter_dspparam,
+    FMOD_DistanceFilter_dspsetparamfloat,
+    0, // FMOD_DistanceFilter_dspsetparamint,
+    0, // FMOD_DistanceFilter_dspsetparambool,
+    FMOD_DistanceFilter_dspsetparamdata,
+    FMOD_DistanceFilter_dspgetparamfloat,
+    0, // FMOD_DistanceFilter_dspgetparamint,
+    0, // FMOD_DistanceFilter_dspgetparambool,
+    FMOD_DistanceFilter_dspgetparamdata,
+    FMOD_DistanceFilter_shouldiprocess,
+    0,                                      // userdata
+    0,                                      // sys_register
+    0,                                      // sys_deregister
+    0                                       // sys_mix
+};
+
+extern "C"
+{
+    F_EXPORT FMOD_DSP_DESCRIPTION* F_CALL FMODGetDSPDescription()
+    {
+	    static float distance_mapping_values[] = { 0, 1, 5, 20, 100, 500, 10000 };
+	    static float distance_mapping_scale[] = { 0, 1, 2, 3, 4, 4.5, 5 };
+
+        FMOD_DSP_INIT_PARAMDESC_FLOAT_WITH_MAPPING(p_max_distance,       "Max Dist",      "",    "Distance at which bandpass stops narrowing. 0 to 1000000000. Default = 100", FMOD_DISTANCE_FILTER_PARAM_MAX_DISTANCE_DEFAULT, distance_mapping_values, distance_mapping_scale);
+        FMOD_DSP_INIT_PARAMDESC_FLOAT(p_bandpass_frequency, "Frequency",     "Hz",  "Bandpass target frequency. 100 to 10,000Hz. Default = 2000Hz",               FMOD_DISTANCE_FILTER_PARAM_BANDPASS_FREQUENCY_MIN, FMOD_DISTANCE_FILTER_PARAM_BANDPASS_FREQUENCY_MAX, FMOD_DISTANCE_FILTER_PARAM_BANDPASS_FREQUENCY_DEFAULT);
+        FMOD_DSP_INIT_PARAMDESC_DATA(p_3d_attributes,       "3D Attributes", "",    "",                                                                           FMOD_DSP_PARAMETER_DATA_TYPE_3DATTRIBUTES);
+
+        return &FMOD_DistanceFilter_Desc;
+    }
+}
+
+class FMODDistanceFilterState
+{
+  public:
+    FMODDistanceFilterState() { }
+
+    void        init                (FMOD_DSP_STATE *dsp_state);
+    void        release             (FMOD_DSP_STATE *dsp_state);
+    FMOD_RESULT process             (float *inbuffer, float *outbuffer, unsigned int length, int channels);
+    FMOD_RESULT process             (unsigned int length, const FMOD_DSP_BUFFER_ARRAY *inbufferarray, FMOD_DSP_BUFFER_ARRAY *outbufferarray, FMOD_BOOL inputsidle, FMOD_DSP_PROCESS_OPERATION op);
+    void        reset               ();
+    void        setMaxDistance      (float);
+    void        setBandpassFrequency(float);
+    void        setDistance         (float);
+    float       maxDistance         () const { return m_max_distance; }
+    float       bandpassFrequency   () const { return m_bandpass_frequency; }
+
+  private:
+    void        updateTimeConstants ();
+
+    float       m_max_distance;
+    float       m_bandpass_frequency;
+    float       m_distance;
+    float       m_target_highpass_time_const;
+    float       m_current_highpass_time_const;
+    float       m_target_lowpass_time_const;
+    float       m_current_lowpass_time_const;
+    int         m_ramp_samples_left;
+    float      *m_previous_lp1_out;
+    float      *m_previous_lp2_out;
+    float      *m_previous_hp_out;
+    int         m_sample_rate;
+    int         m_max_channels;
+};
+
+void FMODDistanceFilterState::init(FMOD_DSP_STATE *dsp_state)
+{
+    FMOD_DSP_GETSAMPLERATE(dsp_state, &m_sample_rate);
+
+    m_max_channels = 8;
+    m_max_distance = FMOD_DISTANCE_FILTER_PARAM_MAX_DISTANCE_DEFAULT;
+    m_bandpass_frequency = FMOD_DISTANCE_FILTER_PARAM_BANDPASS_FREQUENCY_DEFAULT;
+    m_distance = 0;
+
+    m_previous_lp1_out = (float*)FMOD_DSP_ALLOC(dsp_state, m_max_channels * sizeof(float));
+    m_previous_lp2_out = (float*)FMOD_DSP_ALLOC(dsp_state, m_max_channels * sizeof(float));
+    m_previous_hp_out = (float*)FMOD_DSP_ALLOC(dsp_state, m_max_channels * sizeof(float));
+
+    updateTimeConstants();
+    reset();
+}
+
+void FMODDistanceFilterState::release(FMOD_DSP_STATE *dsp_state)
+{
+    FMOD_DSP_FREE(dsp_state, m_previous_lp1_out);
+    FMOD_DSP_FREE(dsp_state, m_previous_lp2_out);
+    FMOD_DSP_FREE(dsp_state, m_previous_hp_out);
+}
+
+FMOD_RESULT FMODDistanceFilterState::process(float *inbuffer, float *outbuffer, unsigned int length, int channels)
+{
+    if(channels > m_max_channels)
+    {
+        return FMOD_ERR_INVALID_PARAM;
+    }
+
+    // Note: buffers are interleaved
+    static float jitter = (float)1E-20;
+    float lp1_out, lp2_out;
+    int ch;
+
+    float lp_tc = m_current_lowpass_time_const;
+    float hp_tc = m_current_highpass_time_const;
+
+    if (m_ramp_samples_left)
+    {
+        float lp_delta = (m_target_lowpass_time_const - m_current_lowpass_time_const) / m_ramp_samples_left;
+        float hp_delta = (m_target_highpass_time_const - m_current_highpass_time_const) / m_ramp_samples_left;
+        while (length)
+        {
+            if (--m_ramp_samples_left)
+            {
+                lp_tc += lp_delta;
+                hp_tc += hp_delta;
+                for (ch = 0; ch < channels; ++ch)
+                {
+                    lp1_out = m_previous_lp1_out[ch] + lp_tc * (*inbuffer++ + jitter - m_previous_lp1_out[ch]);
+                    lp2_out = m_previous_lp2_out[ch] + lp_tc * (lp1_out - m_previous_lp2_out[ch]);
+                    *outbuffer = hp_tc * (m_previous_hp_out[ch] + lp2_out - m_previous_lp2_out[ch]);
+
+                    m_previous_lp1_out[ch] = lp1_out;
+                    m_previous_lp2_out[ch] = lp2_out;
+                    m_previous_hp_out[ch] = *outbuffer++;
+                }
+                jitter = -jitter;
+            }
+            else
+            {
+                lp_tc = m_target_lowpass_time_const;
+                hp_tc = m_target_highpass_time_const;
+                break;
+            }
+            --length;
+        }
+    }
+
+    while (length--)
+    {
+        for (ch = 0; ch < channels; ++ch)
+        {
+            lp1_out = m_previous_lp1_out[ch] + lp_tc * (*inbuffer++ + jitter - m_previous_lp1_out[ch]);
+            lp2_out = m_previous_lp2_out[ch] + lp_tc * (lp1_out - m_previous_lp2_out[ch]);
+            *outbuffer = hp_tc * (m_previous_hp_out[ch] + lp2_out - m_previous_lp2_out[ch]);
+
+            m_previous_lp1_out[ch] = lp1_out;
+            m_previous_lp2_out[ch] = lp2_out;
+            m_previous_hp_out[ch] = *outbuffer++;
+        }
+        jitter = -jitter;
+    }
+
+    m_current_lowpass_time_const = lp_tc;
+    m_current_highpass_time_const = hp_tc;
+
+    return FMOD_OK;
+}
+
+FMOD_RESULT FMODDistanceFilterState::process(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)
+    {
+        FMOD_SPEAKERMODE outmode;
+        int outchannels;
+
+        #if 1 // For stereo output
+        {
+            outmode = FMOD_SPEAKERMODE_STEREO;
+            outchannels = 2;
+        }
+        #else // For 5.1 output
+        {
+            outmode = FMOD_SPEAKERMODE_5POINT1;
+            outchannels = 6;
+        }
+        #endif
+
+        if (outbufferarray)
+        {
+            outbufferarray->speakermode = outmode;
+            outbufferarray->buffernumchannels[0] = outchannels;
+        }
+
+        if (inputsidle)
+        {
+            return FMOD_ERR_DSP_DONTPROCESS;
+        }
+
+        return FMOD_OK;
+    }
+
+    // Do processing here
+    float *inbuffer    = inbufferarray->buffers[0];
+    float *outbuffer   = outbufferarray->buffers[0];
+    int    inchannels  = inbufferarray->buffernumchannels[0];
+    int    outchannels = outbufferarray->buffernumchannels[0];
+    
+    while(length--)
+    {
+        // MAIN DSP LOOP...
+    }
+
+    return FMOD_OK;
+}
+
+void FMODDistanceFilterState::reset()
+{
+    m_current_lowpass_time_const = m_target_lowpass_time_const;
+    m_current_highpass_time_const = m_target_highpass_time_const;
+    m_ramp_samples_left = 0;
+
+    memset(m_previous_lp1_out, 0, m_max_channels * sizeof(float));
+    memset(m_previous_lp2_out, 0, m_max_channels * sizeof(float));
+    memset(m_previous_hp_out, 0, m_max_channels * sizeof(float));
+}
+
+void FMODDistanceFilterState::setMaxDistance(float distance)
+{
+    m_max_distance = distance;
+    updateTimeConstants();
+}
+
+void FMODDistanceFilterState::setBandpassFrequency(float frequency)
+{
+    m_bandpass_frequency = frequency;
+    updateTimeConstants();
+}
+
+void FMODDistanceFilterState::setDistance(float distance)
+{
+    m_distance = distance;
+    updateTimeConstants();
+}
+
+void FMODDistanceFilterState::updateTimeConstants()
+{
+    #define PI (3.14159265358979323846f)
+    #define MIN_CUTOFF (10.0f)
+    #define MAX_CUTOFF (22000.0f)
+
+    float dist_factor = m_distance >= m_max_distance ? 1.0f : m_distance / m_max_distance;
+    float lp_cutoff = m_bandpass_frequency + (1.0f - dist_factor) * (1.0f - dist_factor) * (MAX_CUTOFF - m_bandpass_frequency);
+    float hp_cutoff = MIN_CUTOFF + dist_factor * dist_factor * (m_bandpass_frequency - MIN_CUTOFF);
+
+    float dt = 1.0f / m_sample_rate;
+    float threshold = m_sample_rate / PI;
+
+    if (lp_cutoff >= MAX_CUTOFF)
+    {
+        m_target_lowpass_time_const = 1.0f;
+    }
+    else if (lp_cutoff <= threshold)
+    {
+        float RC = 1.0f / (2.0f * PI * lp_cutoff);
+        m_target_lowpass_time_const = dt / (RC + dt);
+    }
+    else
+    {
+        m_target_lowpass_time_const = 0.666666667f + (lp_cutoff - threshold) / (3.0f * (MAX_CUTOFF - threshold));
+    }
+
+    if (hp_cutoff >= MAX_CUTOFF)
+    {
+        m_target_highpass_time_const = 0.0f;
+    }
+    else if (hp_cutoff <= threshold)
+    {
+        float RC = 1.0f / (2.0f * PI * hp_cutoff);
+        m_target_highpass_time_const = RC / (RC + dt);
+    }
+    else
+    {
+        m_target_highpass_time_const = (MAX_CUTOFF - hp_cutoff) / (3.0f * (MAX_CUTOFF - threshold));
+    }
+
+    m_ramp_samples_left = 256;
+}
+
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dspcreate(FMOD_DSP_STATE *dsp_state)
+{
+    FMODDistanceFilterState* state = (FMODDistanceFilterState *)FMOD_DSP_ALLOC(dsp_state, sizeof(FMODDistanceFilterState));
+    state->init(dsp_state);
+    dsp_state->plugindata = state;
+    if (!state)
+    {
+        return FMOD_ERR_MEMORY;
+    }
+    return FMOD_OK;
+}
+
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dsprelease(FMOD_DSP_STATE *dsp_state)
+{
+    FMODDistanceFilterState *state = (FMODDistanceFilterState *)dsp_state->plugindata;
+    state->release(dsp_state);
+    FMOD_DSP_FREE(dsp_state, state);
+    return FMOD_OK;
+}
+
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dspread(FMOD_DSP_STATE *dsp_state, float *inbuffer, float *outbuffer, unsigned int length, int inchannels, int * /*outchannels*/)
+{
+    FMODDistanceFilterState *state = (FMODDistanceFilterState *)dsp_state->plugindata;
+    return state->process(inbuffer, outbuffer, length, inchannels); // input and output channels count match for this effect
+}
+
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dspprocess(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)
+{
+    FMODDistanceFilterState *state = (FMODDistanceFilterState *)dsp_state->plugindata;
+    return state->process(length, inbufferarray, outbufferarray, inputsidle, op); // as an example for plugins which set the output channel count
+}
+
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dspreset(FMOD_DSP_STATE *dsp_state)
+{
+    FMODDistanceFilterState *state = (FMODDistanceFilterState *)dsp_state->plugindata;
+    state->reset();
+    return FMOD_OK;
+}
+
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dspsetparamfloat(FMOD_DSP_STATE *dsp_state, int index, float value)
+{
+    FMODDistanceFilterState *state = (FMODDistanceFilterState *)dsp_state->plugindata;
+
+    switch (index)
+    {
+    case FMOD_DISTANCE_FILTER_MAX_DISTANCE:
+        state->setMaxDistance(value);
+        return FMOD_OK;
+
+    case FMOD_DISTANCE_FILTER_BANDPASS_FREQUENCY:
+        state->setBandpassFrequency(value);
+        return FMOD_OK;
+    }
+
+    return FMOD_ERR_INVALID_PARAM;
+}
+
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dspgetparamfloat(FMOD_DSP_STATE *dsp_state, int index, float *value, char *valuestr)
+{
+    FMODDistanceFilterState *state = (FMODDistanceFilterState *)dsp_state->plugindata;
+
+    switch (index)
+    {
+    case FMOD_DISTANCE_FILTER_MAX_DISTANCE:
+        *value = state->maxDistance();
+        if (valuestr) snprintf(valuestr, FMOD_DSP_GETPARAM_VALUESTR_LENGTH, "%.1f", state->maxDistance());
+        return FMOD_OK;
+
+    case FMOD_DISTANCE_FILTER_BANDPASS_FREQUENCY:
+        *value = state->bandpassFrequency();
+        if (valuestr) snprintf(valuestr, FMOD_DSP_GETPARAM_VALUESTR_LENGTH, "%.1f Hz", state->bandpassFrequency());
+        return FMOD_OK;
+    }
+
+    return FMOD_ERR_INVALID_PARAM;
+}
+
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dspsetparamdata(FMOD_DSP_STATE *dsp_state, int index, void *data, unsigned int /*length*/)
+{
+    FMODDistanceFilterState *state = (FMODDistanceFilterState *)dsp_state->plugindata;
+
+    switch (index)
+    {
+    case FMOD_DISTANCE_FILTER_3D_ATTRIBUTES:
+        FMOD_DSP_PARAMETER_3DATTRIBUTES* param = (FMOD_DSP_PARAMETER_3DATTRIBUTES*)data;
+        state->setDistance(sqrtf(param->relative.position.x * param->relative.position.x + param->relative.position.y * param->relative.position.y + param->relative.position.z * param->relative.position.z));
+        return FMOD_OK;
+    }
+
+    return FMOD_ERR_INVALID_PARAM;
+}
+
+FMOD_RESULT F_CALL FMOD_DistanceFilter_dspgetparamdata(FMOD_DSP_STATE * /*dsp_state*/, int index, void ** /*value*/, unsigned int * /*length*/, char * /*valuestr*/)
+{
+    switch (index)
+    {
+      case FMOD_DISTANCE_FILTER_3D_ATTRIBUTES:
+        return FMOD_ERR_INVALID_PARAM;
+    }
+
+    return FMOD_ERR_INVALID_PARAM;
+}
+
+FMOD_RESULT F_CALL FMOD_DistanceFilter_shouldiprocess(FMOD_DSP_STATE * /*dsp_state*/, FMOD_BOOL inputsidle, unsigned int /*length*/, FMOD_CHANNELMASK /*inmask*/, int /*inchannels*/, FMOD_SPEAKERMODE /*speakermode*/)
+{
+    if (inputsidle)
+    {
+        return FMOD_ERR_DSP_DONTPROCESS;
+    }
+
+    return FMOD_OK;
+}

SimpleGame/FMOD/api/core/examples/plugins/fmod_gain.cpp

@@ -0,0 +1,360 @@
+/*==============================================================================
+Gain DSP Plugin Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to create a simple gain DSP effect.
+==============================================================================*/
+
+#ifdef WIN32
+    #define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "fmod.hpp"
+
+#define FMOD_GAIN_USEPROCESSCALLBACK            /* FMOD plugins have 2 methods of processing data.  
+                                                    1. via a 'read' callback which is compatible with FMOD Ex but limited in functionality, or 
+                                                    2. via a 'process' callback which exposes more functionality, like masks and query before process early out logic. */
+
+extern "C" {
+    F_EXPORT FMOD_DSP_DESCRIPTION* F_CALL FMODGetDSPDescription();
+}
+
+const float FMOD_GAIN_PARAM_GAIN_MIN     = -80.0f;
+const float FMOD_GAIN_PARAM_GAIN_MAX     = 10.0f;
+const float FMOD_GAIN_PARAM_GAIN_DEFAULT = 0.0f;
+#define FMOD_GAIN_RAMPCOUNT 256
+
+enum
+{
+    FMOD_GAIN_PARAM_GAIN = 0,
+    FMOD_GAIN_PARAM_INVERT,
+    FMOD_GAIN_NUM_PARAMETERS
+};
+
+#define DECIBELS_TO_LINEAR(__dbval__)  ((__dbval__ <= FMOD_GAIN_PARAM_GAIN_MIN) ? 0.0f : powf(10.0f, __dbval__ / 20.0f))
+#define LINEAR_TO_DECIBELS(__linval__) ((__linval__ <= 0.0f) ? FMOD_GAIN_PARAM_GAIN_MIN : 20.0f * log10f((float)__linval__))
+
+FMOD_RESULT F_CALL FMOD_Gain_dspcreate       (FMOD_DSP_STATE *dsp_state);
+FMOD_RESULT F_CALL FMOD_Gain_dsprelease      (FMOD_DSP_STATE *dsp_state);
+FMOD_RESULT F_CALL FMOD_Gain_dspreset        (FMOD_DSP_STATE *dsp_state);
+#ifdef FMOD_GAIN_USEPROCESSCALLBACK
+FMOD_RESULT F_CALL FMOD_Gain_dspprocess      (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);
+#else
+FMOD_RESULT F_CALL FMOD_Gain_dspread         (FMOD_DSP_STATE *dsp_state, float *inbuffer, float *outbuffer, unsigned int length, int inchannels, int *outchannels);
+#endif
+FMOD_RESULT F_CALL FMOD_Gain_dspsetparamfloat(FMOD_DSP_STATE *dsp_state, int index, float value);
+FMOD_RESULT F_CALL FMOD_Gain_dspsetparamint  (FMOD_DSP_STATE *dsp_state, int index, int value);
+FMOD_RESULT F_CALL FMOD_Gain_dspsetparambool (FMOD_DSP_STATE *dsp_state, int index, FMOD_BOOL value);
+FMOD_RESULT F_CALL FMOD_Gain_dspsetparamdata (FMOD_DSP_STATE *dsp_state, int index, void *data, unsigned int length);
+FMOD_RESULT F_CALL FMOD_Gain_dspgetparamfloat(FMOD_DSP_STATE *dsp_state, int index, float *value, char *valuestr);
+FMOD_RESULT F_CALL FMOD_Gain_dspgetparamint  (FMOD_DSP_STATE *dsp_state, int index, int *value, char *valuestr);
+FMOD_RESULT F_CALL FMOD_Gain_dspgetparambool (FMOD_DSP_STATE *dsp_state, int index, FMOD_BOOL *value, char *valuestr);
+FMOD_RESULT F_CALL FMOD_Gain_dspgetparamdata (FMOD_DSP_STATE *dsp_state, int index, void **value, unsigned int *length, char *valuestr);
+FMOD_RESULT F_CALL FMOD_Gain_shouldiprocess  (FMOD_DSP_STATE *dsp_state, FMOD_BOOL inputsidle, unsigned int length, FMOD_CHANNELMASK inmask, int inchannels, FMOD_SPEAKERMODE speakermode);
+FMOD_RESULT F_CALL FMOD_Gain_sys_register    (FMOD_DSP_STATE *dsp_state);
+FMOD_RESULT F_CALL FMOD_Gain_sys_deregister  (FMOD_DSP_STATE *dsp_state);
+FMOD_RESULT F_CALL FMOD_Gain_sys_mix         (FMOD_DSP_STATE *dsp_state, int stage);
+
+static bool                    FMOD_Gain_Running = false;
+static FMOD_DSP_PARAMETER_DESC p_gain;
+static FMOD_DSP_PARAMETER_DESC p_invert;
+    
+FMOD_DSP_PARAMETER_DESC *FMOD_Gain_dspparam[FMOD_GAIN_NUM_PARAMETERS] =
+{
+    &p_gain,
+    &p_invert
+};
+
+FMOD_DSP_DESCRIPTION FMOD_Gain_Desc =
+{
+    FMOD_PLUGIN_SDK_VERSION,
+    "FMOD Gain",    // name
+    0x00010000,     // plug-in version
+    1,              // number of input buffers to process
+    1,              // number of output buffers to process
+    FMOD_Gain_dspcreate,
+    FMOD_Gain_dsprelease,
+    FMOD_Gain_dspreset,
+#ifndef FMOD_GAIN_USEPROCESSCALLBACK
+    FMOD_Gain_dspread,
+#else
+    0,
+#endif
+#ifdef FMOD_GAIN_USEPROCESSCALLBACK
+    FMOD_Gain_dspprocess,
+#else
+    0,
+#endif
+    0,
+    FMOD_GAIN_NUM_PARAMETERS,
+    FMOD_Gain_dspparam,
+    FMOD_Gain_dspsetparamfloat,
+    0, // FMOD_Gain_dspsetparamint,
+    FMOD_Gain_dspsetparambool,
+    0, // FMOD_Gain_dspsetparamdata,
+    FMOD_Gain_dspgetparamfloat,
+    0, // FMOD_Gain_dspgetparamint,
+    FMOD_Gain_dspgetparambool,
+    0, // FMOD_Gain_dspgetparamdata,
+    FMOD_Gain_shouldiprocess,
+    0,                                      // userdata
+    FMOD_Gain_sys_register,
+    FMOD_Gain_sys_deregister,
+    FMOD_Gain_sys_mix
+};
+
+extern "C"
+{
+
+F_EXPORT FMOD_DSP_DESCRIPTION* F_CALL FMODGetDSPDescription()
+{
+	static float gain_mapping_values[] = { -80, -50, -30, -10, 10 };
+	static float gain_mapping_scale[] = { 0, 2, 4, 7, 11 };
+
+    FMOD_DSP_INIT_PARAMDESC_FLOAT_WITH_MAPPING(p_gain, "Gain", "dB", "Gain in dB. -80 to 10. Default = 0", FMOD_GAIN_PARAM_GAIN_DEFAULT, gain_mapping_values, gain_mapping_scale);
+    FMOD_DSP_INIT_PARAMDESC_BOOL(p_invert, "Invert", "", "Invert signal. Default = off", false, 0);
+    return &FMOD_Gain_Desc;
+}
+
+}
+
+class FMODGainState
+{
+public:
+    FMODGainState();
+
+    void read(float *inbuffer, float *outbuffer, unsigned int length, int channels);
+    void reset();
+    void setGain(float);
+    void setInvert(bool);
+    float gain() const { return LINEAR_TO_DECIBELS(m_invert ? -m_target_gain : m_target_gain); }
+    FMOD_BOOL invert() const { return m_invert; }
+
+private:
+    float m_target_gain;
+    float m_current_gain;
+    int   m_ramp_samples_left;
+    bool  m_invert;
+};
+
+FMODGainState::FMODGainState()
+{
+    m_target_gain = DECIBELS_TO_LINEAR(FMOD_GAIN_PARAM_GAIN_DEFAULT);
+    m_invert = 0;
+    reset();
+}
+
+void FMODGainState::read(float *inbuffer, float *outbuffer, unsigned int length, int channels)
+{
+    // Note: buffers are interleaved
+    float gain = m_current_gain;
+
+    if (m_ramp_samples_left)
+    {
+        float target = m_target_gain;
+        float delta = (target - gain) / m_ramp_samples_left;
+        while (length)
+        {
+            if (--m_ramp_samples_left)
+            {
+                gain += delta;
+                for (int i = 0; i < channels; ++i)
+                {
+                    *outbuffer++ = *inbuffer++ * gain;
+                }
+            }
+            else
+            {
+                gain = target;
+                break;
+            }
+            --length;
+        }
+    }
+
+    unsigned int samples = length * channels;
+    while (samples--)
+    {
+        *outbuffer++ = *inbuffer++ * gain;
+    }
+
+    m_current_gain = gain;
+}
+
+void FMODGainState::reset()
+{
+    m_current_gain = m_target_gain;
+    m_ramp_samples_left = 0;
+}
+
+void FMODGainState::setGain(float gain)
+{
+    m_target_gain = m_invert ? -DECIBELS_TO_LINEAR(gain) : DECIBELS_TO_LINEAR(gain);
+    m_ramp_samples_left = FMOD_GAIN_RAMPCOUNT;
+}
+
+void FMODGainState::setInvert(bool invert)
+{
+    if (invert != m_invert)
+    {
+        m_target_gain = -m_target_gain;
+        m_ramp_samples_left = FMOD_GAIN_RAMPCOUNT;
+    }
+    m_invert = invert;
+}
+
+FMOD_RESULT F_CALL FMOD_Gain_dspcreate(FMOD_DSP_STATE *dsp_state)
+{
+    dsp_state->plugindata = (FMODGainState *)FMOD_DSP_ALLOC(dsp_state, sizeof(FMODGainState));
+    if (!dsp_state->plugindata)
+    {
+        return FMOD_ERR_MEMORY;
+    }
+    return FMOD_OK;
+}
+
+FMOD_RESULT F_CALL FMOD_Gain_dsprelease(FMOD_DSP_STATE *dsp_state)
+{
+    FMODGainState *state = (FMODGainState *)dsp_state->plugindata;
+    FMOD_DSP_FREE(dsp_state, state);
+    return FMOD_OK;
+}
+
+#ifdef FMOD_GAIN_USEPROCESSCALLBACK
+
+FMOD_RESULT F_CALL FMOD_Gain_dspprocess(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)
+{
+    FMODGainState *state = (FMODGainState *)dsp_state->plugindata;
+
+    if (op == FMOD_DSP_PROCESS_QUERY)
+    {
+        if (outbufferarray && inbufferarray)
+        {
+            outbufferarray[0].buffernumchannels[0] = inbufferarray[0].buffernumchannels[0];
+            outbufferarray[0].speakermode       = inbufferarray[0].speakermode;
+        }
+
+        if (inputsidle)
+        {
+            return FMOD_ERR_DSP_DONTPROCESS;
+        }
+    }
+    else
+    {
+        state->read(inbufferarray[0].buffers[0], outbufferarray[0].buffers[0], length, inbufferarray[0].buffernumchannels[0]); // input and output channels count match for this effect
+    }
+
+    return FMOD_OK;
+}
+
+#else
+
+FMOD_RESULT F_CALL FMOD_Gain_dspread(FMOD_DSP_STATE *dsp_state, float *inbuffer, float *outbuffer, unsigned int length, int inchannels, int * /*outchannels*/)
+{
+    FMODGainState *state = (FMODGainState *)dsp_state->plugindata;
+    state->read(inbuffer, outbuffer, length, inchannels); // input and output channels count match for this effect
+    return FMOD_OK;
+}
+
+#endif
+
+FMOD_RESULT F_CALL FMOD_Gain_dspreset(FMOD_DSP_STATE *dsp_state)
+{
+    FMODGainState *state = (FMODGainState *)dsp_state->plugindata;
+    state->reset();
+    return FMOD_OK;
+}
+
+FMOD_RESULT F_CALL FMOD_Gain_dspsetparamfloat(FMOD_DSP_STATE *dsp_state, int index, float value)
+{
+    FMODGainState *state = (FMODGainState *)dsp_state->plugindata;
+
+    switch (index)
+    {
+    case FMOD_GAIN_PARAM_GAIN:
+        state->setGain(value);
+        return FMOD_OK;
+    }
+
+    return FMOD_ERR_INVALID_PARAM;
+}
+
+FMOD_RESULT F_CALL FMOD_Gain_dspgetparamfloat(FMOD_DSP_STATE *dsp_state, int index, float *value, char *valuestr)
+{
+    FMODGainState *state = (FMODGainState *)dsp_state->plugindata;
+
+    switch (index)
+    {
+    case FMOD_GAIN_PARAM_GAIN:
+        *value = state->gain();
+        if (valuestr) snprintf(valuestr, FMOD_DSP_GETPARAM_VALUESTR_LENGTH, "%.1f dB", state->gain());
+        return FMOD_OK;
+    }
+
+    return FMOD_ERR_INVALID_PARAM;
+}
+
+FMOD_RESULT F_CALL FMOD_Gain_dspsetparambool(FMOD_DSP_STATE *dsp_state, int index, FMOD_BOOL value)
+{
+    FMODGainState *state = (FMODGainState *)dsp_state->plugindata;
+
+    switch (index)
+    {
+      case FMOD_GAIN_PARAM_INVERT:
+        state->setInvert(value ? true : false);
+        return FMOD_OK;
+    }
+
+    return FMOD_ERR_INVALID_PARAM;
+}
+
+FMOD_RESULT F_CALL FMOD_Gain_dspgetparambool(FMOD_DSP_STATE *dsp_state, int index, FMOD_BOOL *value, char *valuestr)
+{
+    FMODGainState *state = (FMODGainState *)dsp_state->plugindata;
+
+    switch (index)
+    {
+    case FMOD_GAIN_PARAM_INVERT:
+        *value = state->invert();
+        if (valuestr) snprintf(valuestr, FMOD_DSP_GETPARAM_VALUESTR_LENGTH, state->invert() ? "Inverted" : "Off" );
+        return FMOD_OK;
+    }
+
+    return FMOD_ERR_INVALID_PARAM;
+}
+
+FMOD_RESULT F_CALL FMOD_Gain_shouldiprocess(FMOD_DSP_STATE * /*dsp_state*/, FMOD_BOOL inputsidle, unsigned int /*length*/, FMOD_CHANNELMASK /*inmask*/, int /*inchannels*/, FMOD_SPEAKERMODE /*speakermode*/)
+{
+    if (inputsidle)
+    {
+        return FMOD_ERR_DSP_DONTPROCESS;
+    }
+
+    return FMOD_OK;
+}
+
+
+FMOD_RESULT F_CALL FMOD_Gain_sys_register(FMOD_DSP_STATE * /*dsp_state*/)
+{
+    FMOD_Gain_Running = true;
+    // called once for this type of dsp being loaded or registered (it is not per instance)
+    return FMOD_OK;
+}
+
+FMOD_RESULT F_CALL FMOD_Gain_sys_deregister(FMOD_DSP_STATE * /*dsp_state*/)
+{
+    FMOD_Gain_Running = false;
+    // called once for this type of dsp being unloaded or de-registered (it is not per instance)
+    return FMOD_OK;
+}
+
+FMOD_RESULT F_CALL FMOD_Gain_sys_mix(FMOD_DSP_STATE * /*dsp_state*/, int /*stage*/)
+{
+    // stage == 0 , before all dsps are processed/mixed, this callback is called once for this type.
+    // stage == 1 , after all dsps are processed/mixed, this callback is called once for this type.
+    return FMOD_OK;
+}

SimpleGame/FMOD/api/core/examples/plugins/fmod_noise.cpp

@@ -0,0 +1,302 @@
+/*==============================================================================
+Plugin Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to created a plugin effect.
+==============================================================================*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "fmod.hpp"
+
+extern "C" {
+    F_EXPORT FMOD_DSP_DESCRIPTION* F_CALL FMODGetDSPDescription();
+}
+
+const float FMOD_NOISE_PARAM_GAIN_MIN     = -80.0f;
+const float FMOD_NOISE_PARAM_GAIN_MAX     = 10.0f;
+const float FMOD_NOISE_PARAM_GAIN_DEFAULT = 0.0f;
+
+#define FMOD_NOISE_RAMPCOUNT 256
+
+enum
+{
+    FMOD_NOISE_PARAM_LEVEL = 0,
+    FMOD_NOISE_PARAM_FORMAT,
+    FMOD_NOISE_NUM_PARAMETERS
+};
+
+enum FMOD_NOISE_FORMAT
+{
+    FMOD_NOISE_FORMAT_MONO = 0,
+    FMOD_NOISE_FORMAT_STEREO,
+    FMOD_NOISE_FORMAT_5POINT1
+};
+
+#define DECIBELS_TO_LINEAR(__dbval__)  ((__dbval__ <= FMOD_NOISE_PARAM_GAIN_MIN) ? 0.0f : powf(10.0f, __dbval__ / 20.0f))
+#define LINEAR_TO_DECIBELS(__linval__) ((__linval__ <= 0.0f) ? FMOD_NOISE_PARAM_GAIN_MIN : 20.0f * log10f((float)__linval__))
+
+FMOD_RESULT F_CALL FMOD_Noise_dspcreate       (FMOD_DSP_STATE *dsp);
+FMOD_RESULT F_CALL FMOD_Noise_dsprelease      (FMOD_DSP_STATE *dsp);
+FMOD_RESULT F_CALL FMOD_Noise_dspreset        (FMOD_DSP_STATE *dsp);
+FMOD_RESULT F_CALL FMOD_Noise_dspprocess      (FMOD_DSP_STATE *dsp, unsigned int length, const FMOD_DSP_BUFFER_ARRAY *inbufferarray, FMOD_DSP_BUFFER_ARRAY *outbufferarray, FMOD_BOOL inputsidle, FMOD_DSP_PROCESS_OPERATION op);
+FMOD_RESULT F_CALL FMOD_Noise_dspsetparamfloat(FMOD_DSP_STATE *dsp, int index, float value);
+FMOD_RESULT F_CALL FMOD_Noise_dspsetparamint  (FMOD_DSP_STATE *dsp, int index, int value);
+FMOD_RESULT F_CALL FMOD_Noise_dspsetparambool (FMOD_DSP_STATE *dsp, int index, bool value);
+FMOD_RESULT F_CALL FMOD_Noise_dspsetparamdata (FMOD_DSP_STATE *dsp, int index, void *data, unsigned int length);
+FMOD_RESULT F_CALL FMOD_Noise_dspgetparamfloat(FMOD_DSP_STATE *dsp, int index, float *value, char *valuestr);
+FMOD_RESULT F_CALL FMOD_Noise_dspgetparamint  (FMOD_DSP_STATE *dsp, int index, int *value, char *valuestr);
+FMOD_RESULT F_CALL FMOD_Noise_dspgetparambool (FMOD_DSP_STATE *dsp, int index, bool *value, char *valuestr);
+FMOD_RESULT F_CALL FMOD_Noise_dspgetparamdata (FMOD_DSP_STATE *dsp, int index, void **value, unsigned int *length, char *valuestr);
+
+static FMOD_DSP_PARAMETER_DESC p_level;
+static FMOD_DSP_PARAMETER_DESC p_format;
+
+FMOD_DSP_PARAMETER_DESC *FMOD_Noise_dspparam[FMOD_NOISE_NUM_PARAMETERS] =
+{
+    &p_level,
+    &p_format
+};
+
+const char* FMOD_Noise_Format_Names[3] = {"Mono", "Stereo", "5.1"};
+
+FMOD_DSP_DESCRIPTION FMOD_Noise_Desc =
+{
+    FMOD_PLUGIN_SDK_VERSION,
+    "FMOD Noise",   // name
+    0x00010000,     // plug-in version
+    0,              // number of input buffers to process
+    1,              // number of output buffers to process
+    FMOD_Noise_dspcreate,
+    FMOD_Noise_dsprelease,
+    FMOD_Noise_dspreset,
+    0,
+    FMOD_Noise_dspprocess,
+    0,
+    FMOD_NOISE_NUM_PARAMETERS,
+    FMOD_Noise_dspparam,
+    FMOD_Noise_dspsetparamfloat,
+    FMOD_Noise_dspsetparamint,
+    0,
+    0,
+    FMOD_Noise_dspgetparamfloat,
+    FMOD_Noise_dspgetparamint,
+    0,
+    0,
+    0,
+    0,                                      // userdata
+    0,                                      // Register
+    0,                                      // Deregister
+    0                                       // Mix
+};
+
+extern "C"
+{
+
+F_EXPORT FMOD_DSP_DESCRIPTION* F_CALL FMODGetDSPDescription()
+{
+    FMOD_DSP_INIT_PARAMDESC_FLOAT(p_level, "Level", "dB", "Gain in dB. -80 to 10. Default = 0", FMOD_NOISE_PARAM_GAIN_MIN, FMOD_NOISE_PARAM_GAIN_MAX, FMOD_NOISE_PARAM_GAIN_DEFAULT);
+    FMOD_DSP_INIT_PARAMDESC_INT(p_format, "Format", "", "Mono, stereo or 5.1. Default = 0 (mono)", FMOD_NOISE_FORMAT_MONO, FMOD_NOISE_FORMAT_5POINT1, FMOD_NOISE_FORMAT_MONO, false, FMOD_Noise_Format_Names);
+    return &FMOD_Noise_Desc;
+}
+
+}
+
+class FMODNoiseState
+{
+public:
+    FMODNoiseState();
+
+    void generate(float *outbuffer, unsigned int length, int channels);
+    void reset();
+    void setLevel(float);
+    void setFormat(FMOD_NOISE_FORMAT format) { m_format = format; }
+    float level() const { return LINEAR_TO_DECIBELS(m_target_level); }
+    FMOD_NOISE_FORMAT format() const { return m_format; }
+
+private:
+    float m_target_level;
+    float m_current_level;
+    int m_ramp_samples_left;
+    FMOD_NOISE_FORMAT m_format;
+};
+
+FMODNoiseState::FMODNoiseState()
+{
+    m_target_level = DECIBELS_TO_LINEAR(FMOD_NOISE_PARAM_GAIN_DEFAULT);
+    m_format = FMOD_NOISE_FORMAT_MONO;
+    reset();
+}
+
+void FMODNoiseState::generate(float *outbuffer, unsigned int length, int channels)
+{
+    // Note: buffers are interleaved
+    float gain = m_current_level;
+
+    if (m_ramp_samples_left)
+    {
+        float target = m_target_level;
+        float delta = (target - gain) / m_ramp_samples_left;
+        while (length)
+        {
+            if (--m_ramp_samples_left)
+            {
+                gain += delta;
+                for (int i = 0; i < channels; ++i)
+                {
+                    *outbuffer++ = (((float)(rand()%32768) / 16384.0f) - 1.0f) * gain;
+                }
+            }
+            else
+            {
+                gain = target;
+                break;
+            }
+            --length;
+        }
+    }
+
+    unsigned int samples = length * channels;
+    while (samples--)
+    {
+        *outbuffer++ = (((float)(rand()%32768) / 16384.0f) - 1.0f) * gain;
+    }
+
+    m_current_level = gain;
+}
+
+void FMODNoiseState::reset()
+{
+    m_current_level = m_target_level;
+    m_ramp_samples_left = 0;
+}
+
+void FMODNoiseState::setLevel(float level)
+{
+    m_target_level = DECIBELS_TO_LINEAR(level);
+    m_ramp_samples_left = FMOD_NOISE_RAMPCOUNT;
+}
+
+FMOD_RESULT F_CALL FMOD_Noise_dspcreate(FMOD_DSP_STATE *dsp)
+{
+    dsp->plugindata = (FMODNoiseState *)FMOD_DSP_ALLOC(dsp, sizeof(FMODNoiseState));
+    if (!dsp->plugindata)
+    {
+        return FMOD_ERR_MEMORY;
+    }
+    return FMOD_OK;
+}
+
+FMOD_RESULT F_CALL FMOD_Noise_dsprelease(FMOD_DSP_STATE *dsp)
+{
+    FMODNoiseState *state = (FMODNoiseState *)dsp->plugindata;
+    FMOD_DSP_FREE(dsp, state);
+    return FMOD_OK;
+}
+
+FMOD_RESULT F_CALL FMOD_Noise_dspprocess(FMOD_DSP_STATE *dsp, unsigned int length, const FMOD_DSP_BUFFER_ARRAY * /*inbufferarray*/, FMOD_DSP_BUFFER_ARRAY *outbufferarray, FMOD_BOOL /*inputsidle*/, FMOD_DSP_PROCESS_OPERATION op)
+{
+    FMODNoiseState *state = (FMODNoiseState *)dsp->plugindata;
+
+    if (op == FMOD_DSP_PROCESS_QUERY)
+    {
+        FMOD_SPEAKERMODE outmode = FMOD_SPEAKERMODE_DEFAULT;
+        int outchannels = 0;
+
+        switch(state->format())
+        {
+        case FMOD_NOISE_FORMAT_MONO:
+            outmode = FMOD_SPEAKERMODE_MONO;
+            outchannels = 1;
+            break;
+
+        case FMOD_NOISE_FORMAT_STEREO:
+            outmode = FMOD_SPEAKERMODE_STEREO;
+            outchannels = 2;
+            break;
+
+        case FMOD_NOISE_FORMAT_5POINT1:
+            outmode = FMOD_SPEAKERMODE_5POINT1;
+            outchannels = 6;
+        }
+
+        if (outbufferarray)
+        {
+            outbufferarray->speakermode = outmode;
+            outbufferarray->buffernumchannels[0] = outchannels;
+        }
+        
+        return FMOD_OK;
+    }
+
+    state->generate(outbufferarray->buffers[0], length, outbufferarray->buffernumchannels[0]);
+    return FMOD_OK;
+}
+
+FMOD_RESULT F_CALL FMOD_Noise_dspreset(FMOD_DSP_STATE *dsp)
+{
+    FMODNoiseState *state = (FMODNoiseState *)dsp->plugindata;
+    state->reset();
+    return FMOD_OK;
+}
+
+FMOD_RESULT F_CALL FMOD_Noise_dspsetparamfloat(FMOD_DSP_STATE *dsp, int index, float value)
+{
+    FMODNoiseState *state = (FMODNoiseState *)dsp->plugindata;
+
+    switch (index)
+    {
+    case FMOD_NOISE_PARAM_LEVEL:
+        state->setLevel(value);
+        return FMOD_OK;
+    }
+
+    return FMOD_ERR_INVALID_PARAM;
+}
+
+FMOD_RESULT F_CALL FMOD_Noise_dspgetparamfloat(FMOD_DSP_STATE *dsp, int index, float *value, char *valuestr)
+{
+    FMODNoiseState *state = (FMODNoiseState *)dsp->plugindata;
+
+    switch (index)
+    {
+    case FMOD_NOISE_PARAM_LEVEL:
+        *value = state->level();
+        if (valuestr) snprintf(valuestr, FMOD_DSP_GETPARAM_VALUESTR_LENGTH, "%.1f dB", state->level());
+        return FMOD_OK;
+    }
+
+    return FMOD_ERR_INVALID_PARAM;
+}
+
+FMOD_RESULT F_CALL FMOD_Noise_dspsetparamint(FMOD_DSP_STATE *dsp, int index, int value)
+{
+    FMODNoiseState *state = (FMODNoiseState *)dsp->plugindata;
+
+    switch (index)
+    {
+    case FMOD_NOISE_PARAM_FORMAT:
+        state->setFormat((FMOD_NOISE_FORMAT)value);
+        return FMOD_OK;
+    }
+
+    return FMOD_ERR_INVALID_PARAM;
+}
+
+FMOD_RESULT F_CALL FMOD_Noise_dspgetparamint(FMOD_DSP_STATE *dsp, int index, int *value, char *valuestr)
+{
+    FMODNoiseState *state = (FMODNoiseState *)dsp->plugindata;
+
+    switch (index)
+    {
+    case FMOD_NOISE_PARAM_FORMAT:
+        *value = state->format();
+        if (valuestr) snprintf(valuestr, FMOD_DSP_GETPARAM_VALUESTR_LENGTH, "%s", FMOD_Noise_Format_Names[state->format()]);
+        return FMOD_OK;
+    }
+
+    return FMOD_ERR_INVALID_PARAM;
+}

SimpleGame/FMOD/api/core/examples/plugins/fmod_rnbo.cpp

@@ -0,0 +1,184 @@
+/*==============================================================================
+RNBO DSP Plugin Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to integrate RNBO C++ source code into an FMOD effect.
+1. Add the rnbo and rnbo/common directories to your include paths.
+2. Add the generated RNBO source .cpp file and rnbo/RNBO.cpp files to your list
+   of source files.
+3. Build and copy the generated library into your FMOD Studio script directory:
+   https://fmod.com/docs/2.02/studio/plugin-reference.html#loading-plug-ins
+==============================================================================*/
+#if __has_include("RNBO.h")
+#include "RNBO.h"
+
+#include <math.h>
+#include <stdio.h>
+#include <atomic>
+#include <string.h>
+
+#include "fmod.hpp"
+
+static FMOD_DSP_PARAMETER_DESC** params = nullptr;
+static int numParams;
+static int numInputs;
+static int numOutputs;
+static std::atomic<int> gSysCount = 0;
+
+static FMOD_RESULT F_CALL FMOD_RNBO_Create(FMOD_DSP_STATE *dsp_state)
+{
+    dsp_state->plugindata = FMOD_DSP_ALLOC(dsp_state, sizeof(RNBO::CoreObject));
+    if (!dsp_state->plugindata)
+    {
+        return FMOD_ERR_MEMORY;
+    }
+
+    RNBO::CoreObject *rnboObject = (RNBO::CoreObject *)dsp_state->plugindata;
+
+    int sampleRate;
+    unsigned int blockSize;
+
+    FMOD_DSP_GETSAMPLERATE(dsp_state, &sampleRate);
+    FMOD_DSP_GETBLOCKSIZE(dsp_state, &blockSize);
+
+    new (rnboObject) RNBO::CoreObject();
+
+    rnboObject->prepareToProcess(sampleRate, blockSize);
+
+    return FMOD_OK;
+}
+
+static FMOD_RESULT F_CALL FMOD_RNBO_Release(FMOD_DSP_STATE *dsp_state)
+{
+    RNBO::CoreObject *rnboObject = (RNBO::CoreObject *)dsp_state->plugindata;
+    rnboObject->~CoreObject();
+
+    FMOD_DSP_FREE(dsp_state, rnboObject);
+
+    return FMOD_OK;
+}
+
+static FMOD_RESULT F_CALL FMOD_RNBO_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)
+{
+    RNBO::CoreObject *rnboObject = (RNBO::CoreObject *)dsp_state->plugindata;
+
+    if (op == FMOD_DSP_PROCESS_QUERY)
+    {
+        if (numInputs > 0)
+        {
+            if (inputsidle)
+            {
+                return FMOD_ERR_DSP_SILENCE;
+            }
+        }
+        else
+        {
+            if (outbufferarray && outbufferarray[0].buffernumchannels)
+            {
+                outbufferarray[0].buffernumchannels[0] = numOutputs;
+            }
+        }
+    }
+    else
+    {
+        rnboObject->process(inbufferarray[0].buffers[0], inbufferarray[0].buffernumchannels[0],
+            outbufferarray[0].buffers[0], outbufferarray[0].buffernumchannels[0], length);
+    }
+
+    return FMOD_OK;
+}
+
+static FMOD_RESULT F_CALL FMOD_RNBO_SetParamFloat(FMOD_DSP_STATE *dsp_state, int index, float value)
+{
+    RNBO::CoreObject *rnboObject = (RNBO::CoreObject *)dsp_state->plugindata;
+
+    rnboObject->setParameterValue(index, value);
+    return FMOD_OK;
+}
+
+static FMOD_RESULT F_CALL FMOD_RNBO_GetParamFloat(FMOD_DSP_STATE *dsp_state, int index, float *value, char *valuestr)
+{
+    RNBO::CoreObject *rnboObject = (RNBO::CoreObject *)dsp_state->plugindata;
+
+    *value = (float)rnboObject->getParameterValue(index);
+    if (valuestr) snprintf(valuestr, FMOD_DSP_GETPARAM_VALUESTR_LENGTH, "%s", rnboObject->getParameterName(index));
+
+    return FMOD_OK;
+}
+
+static FMOD_RESULT F_CALL FMOD_RNBO_SysRegister(FMOD_DSP_STATE* dsp_state)
+{
+    RNBO::CoreObject* rnboObject = (RNBO::CoreObject*)dsp_state->plugindata;
+
+    gSysCount++;
+
+    return FMOD_OK;
+}
+
+static FMOD_RESULT F_CALL FMOD_RNBO_SysDeregister(FMOD_DSP_STATE* dsp_state)
+{
+    RNBO::CoreObject* rnboObject = (RNBO::CoreObject*)dsp_state->plugindata;
+
+    gSysCount--;
+    if (gSysCount == 0)
+    {
+        for (int i = 0; i < numParams; ++i)
+        {
+            free(params[i]);
+        }
+        free(params);
+
+        params = nullptr;
+    }
+
+    return FMOD_OK;
+}
+
+extern "C" F_EXPORT FMOD_DSP_DESCRIPTION *F_CALL FMODGetDSPDescription()
+{
+    static FMOD_DSP_DESCRIPTION desc = { FMOD_PLUGIN_SDK_VERSION, "FMOD RNBO", 0x00010000 };
+    desc.create = FMOD_RNBO_Create;
+    desc.release = FMOD_RNBO_Release;
+    desc.process = FMOD_RNBO_Process;
+    desc.setparameterfloat = FMOD_RNBO_SetParamFloat;
+    desc.getparameterfloat = FMOD_RNBO_GetParamFloat;
+    desc.sys_register = FMOD_RNBO_SysRegister;
+    desc.sys_deregister = FMOD_RNBO_SysDeregister;
+
+    if (!params)
+    {
+        RNBO::CoreObject tmpRnboObject;
+
+        numParams = tmpRnboObject.getNumParameters();
+        numInputs = tmpRnboObject.getNumInputChannels();
+        numOutputs = tmpRnboObject.getNumOutputChannels();
+
+        desc.numparameters = numParams;
+        desc.numinputbuffers = numInputs > 0;
+        desc.numoutputbuffers = numOutputs > 0;
+
+        params = (FMOD_DSP_PARAMETER_DESC**)malloc(desc.numparameters * sizeof(FMOD_DSP_PARAMETER_DESC*));
+
+        for (int i = 0; i < numParams; ++i)
+        {
+            RNBO::ParameterInfo info = {};
+            tmpRnboObject.getParameterInfo(i, &info);
+
+            params[i] = (FMOD_DSP_PARAMETER_DESC *)malloc(sizeof(FMOD_DSP_PARAMETER_DESC));
+            memset(params[i], 0, sizeof(FMOD_DSP_PARAMETER_DESC));
+
+            snprintf(params[i]->name, sizeof(params[i]->name), "%s", tmpRnboObject.getParameterId(i));
+            snprintf(params[i]->label, sizeof(params[i]->label), "%s", info.unit);
+
+            params[i]->type = FMOD_DSP_PARAMETER_TYPE_FLOAT;
+            params[i]->floatdesc.defaultval = info.initialValue;
+            params[i]->floatdesc.min = info.min;
+            params[i]->floatdesc.max = info.max;
+        }
+
+        desc.paramdesc = params;
+    }
+    return &desc;
+}
+
+#endif

SimpleGame/FMOD/api/core/examples/plugins/output_mp3.cpp

@@ -0,0 +1,429 @@
+/*===============================================================================================
+ OUTPUT_MP3.DLL
+ Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+ Shows how to write an FMOD output plugin that writes the output to an mp3 file using 
+ lame_enc.dll.
+
+ Most of this source code that does the encoding is taken from the LAME encoder example.
+ An FMOD Studio output plugin is created by declaring the FMODGetOutputDescription function,
+ then filling out a FMOD_OUTPUT_DESCRIPTION and returning a pointer to it.
+ FMOD will then call those functions when appropriate.
+
+ To get the output from FMOD so that you can write it to your sound device (or LAME encoder
+ function in this case), FMOD_OUTPUT_STATE::readfrommixer is called to run the mixer.
+
+ We acknowledge that we are using LAME, which originates from www.mp3dev.org.
+ LAME is under the LGPL and as an external FMOD plugin with full source code for the interface
+ it is allowable under the LGPL to be distributed in this fashion.
+
+===============================================================================================*/
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <windows.h>
+
+#include "fmod.hpp"
+
+#include "BladeMP3EncDll.h"
+
+typedef struct
+{
+    FILE               *mFP;    
+    HINSTANCE           mDLL;
+    HBE_STREAM          hbeStream;
+    PBYTE               pMP3Buffer;
+    PSHORT              pWAVBuffer;
+    BE_VERSION          Version;
+    DWORD               dwMP3Buffer;
+    DWORD               dwSamples;
+
+    BEINITSTREAM        beInitStream;
+    BEENCODECHUNK       beEncodeChunk;
+    BEDEINITSTREAM      beDeinitStream;
+    BECLOSESTREAM       beCloseStream;
+    BEVERSION           beVersion;
+    BEWRITEVBRHEADER    beWriteVBRHeader;
+
+    int                 dspbufferlength;
+
+} outputmp3_state;
+
+FMOD_OUTPUT_DESCRIPTION mp3output;
+
+FMOD_RESULT F_CALL OutputMP3_GetNumDriversCallback(FMOD_OUTPUT_STATE *output_state, int *numdrivers);
+FMOD_RESULT F_CALL OutputMP3_GetDriverInfoCallback(FMOD_OUTPUT_STATE *output_state, int id, char *name, int namelen, FMOD_GUID *guid, int *systemrate, FMOD_SPEAKERMODE *speakermode, int *speakermodechannels);
+FMOD_RESULT F_CALL OutputMP3_InitCallback(FMOD_OUTPUT_STATE *output_state, int selecteddriver, FMOD_INITFLAGS flags, int *outputrate, FMOD_SPEAKERMODE *speakermode, int *speakermodechannels, FMOD_SOUND_FORMAT *outputformat, int dspbufferlength, int *dspnumbuffers, int *dspnumadditionalbuffers, void *extradriverdata);
+FMOD_RESULT F_CALL OutputMP3_CloseCallback(FMOD_OUTPUT_STATE *output_state);
+FMOD_RESULT F_CALL OutputMP3_UpdateCallback(FMOD_OUTPUT_STATE *output_state);
+FMOD_RESULT F_CALL OutputMP3_GetHandleCallback(FMOD_OUTPUT_STATE *output_state, void **handle);
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+    FMODGetOutputDescription is mandantory for every fmod plugin.  This is the symbol the registerplugin function searches for.
+    Must be declared with F_CALL to make it export as stdcall.
+*/
+F_EXPORT FMOD_OUTPUT_DESCRIPTION* F_CALL FMODGetOutputDescription()
+{
+    memset(&mp3output, 0, sizeof(FMOD_OUTPUT_DESCRIPTION));
+
+    mp3output.apiversion    = FMOD_OUTPUT_PLUGIN_VERSION;
+    mp3output.name          = "FMOD MP3 Output";
+    mp3output.version       = 0x00010000;
+    mp3output.method        = FMOD_OUTPUT_METHOD_MIX_DIRECT;
+    mp3output.getnumdrivers = OutputMP3_GetNumDriversCallback;
+    mp3output.getdriverinfo = OutputMP3_GetDriverInfoCallback;
+    mp3output.init          = OutputMP3_InitCallback;
+    mp3output.close         = OutputMP3_CloseCallback;
+    mp3output.update        = OutputMP3_UpdateCallback;
+    mp3output.gethandle     = OutputMP3_GetHandleCallback;
+
+    return &mp3output;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/*
+[
+    [DESCRIPTION]
+
+    [PARAMETERS]
+ 
+    [REMARKS]
+
+    [SEE_ALSO]
+]
+*/
+FMOD_RESULT F_CALL OutputMP3_GetNumDriversCallback(FMOD_OUTPUT_STATE * /*output*/, int *numdrivers)
+{
+    *numdrivers = 1;
+
+    return FMOD_OK;
+}
+
+
+/*
+[
+    [DESCRIPTION]
+
+    [PARAMETERS]
+ 
+    [REMARKS]
+
+    [SEE_ALSO]
+]
+*/
+FMOD_RESULT F_CALL OutputMP3_GetDriverInfoCallback(FMOD_OUTPUT_STATE * /*output*/, int /*id*/, char *name, int namelen, FMOD_GUID * /*guid*/, int * /*systemrate*/, FMOD_SPEAKERMODE *speakermode, int *speakermodechannels)
+{
+    strncpy(name, "fmodoutput.mp3", namelen);
+
+    *speakermode = FMOD_SPEAKERMODE_STEREO;
+    *speakermodechannels = 2;
+
+    return FMOD_OK;
+}
+
+
+/*
+[
+    [DESCRIPTION]
+
+    [PARAMETERS]
+ 
+    [REMARKS]
+
+    [SEE_ALSO]
+]
+*/
+FMOD_RESULT F_CALL OutputMP3_InitCallback(FMOD_OUTPUT_STATE *output_state, int /*selecteddriver*/, FMOD_INITFLAGS /*flags*/, int *outputrate, FMOD_SPEAKERMODE *speakermode, int *speakermodechannels, FMOD_SOUND_FORMAT *outputformat, int dspbufferlength, int */*dspnumbuffers*/, int */*dspnumadditionalbuffers*/, void *extradriverdata)
+{
+    outputmp3_state *state;
+    BE_CONFIG        beConfig = {0,};
+    BE_ERR           err = 0;
+    char             filename[256];
+
+    /*
+        Create a structure that we can attach to the plugin instance.
+    */
+    state = (outputmp3_state *)calloc(sizeof(outputmp3_state), 1);
+    if (!state)
+    {
+        return FMOD_ERR_MEMORY;
+    }
+    output_state->plugindata = state;
+    
+    *outputformat        = FMOD_SOUND_FORMAT_PCM16;
+    *speakermode         = FMOD_SPEAKERMODE_STEREO;
+    *speakermodechannels = 2;
+
+#ifdef _WIN64
+    state->mDLL = LoadLibrary("lame_enc64.dll");
+#else
+    state->mDLL = LoadLibrary("lame_enc.dll");
+#endif    
+    if (!state->mDLL)
+    {
+        return FMOD_ERR_PLUGIN_RESOURCE;
+    }
+
+    state->dspbufferlength = dspbufferlength;
+
+    /*
+        Get Interface functions from the DLL
+    */
+    state->beInitStream        = (BEINITSTREAM)     GetProcAddress(state->mDLL, TEXT_BEINITSTREAM);
+    state->beEncodeChunk    = (BEENCODECHUNK)    GetProcAddress(state->mDLL, TEXT_BEENCODECHUNK);
+    state->beDeinitStream    = (BEDEINITSTREAM)   GetProcAddress(state->mDLL, TEXT_BEDEINITSTREAM);
+    state->beCloseStream    = (BECLOSESTREAM)    GetProcAddress(state->mDLL, TEXT_BECLOSESTREAM);
+    state->beVersion        = (BEVERSION)        GetProcAddress(state->mDLL, TEXT_BEVERSION);
+    state->beWriteVBRHeader = (BEWRITEVBRHEADER) GetProcAddress(state->mDLL, TEXT_BEWRITEVBRHEADER);
+
+    // Check if all interfaces are present
+    if(!state->beInitStream || !state->beEncodeChunk || !state->beDeinitStream || !state->beCloseStream || !state->beVersion || !state->beWriteVBRHeader)
+    {
+        return FMOD_ERR_PLUGIN;
+    }
+
+    // Get the version number
+    state->beVersion( &state->Version );
+
+    memset(&beConfig,0,sizeof(beConfig));                    // clear all fields
+
+    // use the LAME config structure
+    beConfig.dwConfig = BE_CONFIG_LAME;
+
+    // this are the default settings for testcase.wav
+
+    // FMOD NOTE : The 'extradriverdata' param could be used to pass in info about the bitrate and encoding settings.
+
+    beConfig.format.LHV1.dwStructVersion    = 1;
+    beConfig.format.LHV1.dwStructSize       = sizeof(beConfig);        
+    beConfig.format.LHV1.dwSampleRate       = *outputrate;          // INPUT FREQUENCY
+    beConfig.format.LHV1.dwReSampleRate     = 0;                    // DON"T RESAMPLE
+    beConfig.format.LHV1.nMode              = BE_MP3_MODE_JSTEREO;  // OUTPUT IN STREO
+    beConfig.format.LHV1.dwBitrate          = 128;                  // MINIMUM BIT RATE
+    beConfig.format.LHV1.nPreset            = LQP_R3MIX;            // QUALITY PRESET SETTING
+    beConfig.format.LHV1.dwMpegVersion      = MPEG1;                // MPEG VERSION (I or II)
+    beConfig.format.LHV1.dwPsyModel         = 0;                    // USE DEFAULT PSYCHOACOUSTIC MODEL 
+    beConfig.format.LHV1.dwEmphasis         = 0;                    // NO EMPHASIS TURNED ON
+    beConfig.format.LHV1.bOriginal          = TRUE;                 // SET ORIGINAL FLAG
+    beConfig.format.LHV1.bWriteVBRHeader    = TRUE;                 // Write INFO tag
+
+//    beConfig.format.LHV1.dwMaxBitrate     = 320;                  // MAXIMUM BIT RATE
+//    beConfig.format.LHV1.bCRC             = TRUE;                 // INSERT CRC
+//    beConfig.format.LHV1.bCopyright       = TRUE;                 // SET COPYRIGHT FLAG    
+//    beConfig.format.LHV1.bPrivate         = TRUE;                 // SET PRIVATE FLAG
+//    beConfig.format.LHV1.bWriteVBRHeader  = TRUE;                 // YES, WRITE THE XING VBR HEADER
+//    beConfig.format.LHV1.bEnableVBR       = TRUE;                 // USE VBR
+//    beConfig.format.LHV1.nVBRQuality      = 5;                    // SET VBR QUALITY
+    beConfig.format.LHV1.bNoRes             = TRUE;                 // No Bit resorvoir
+
+// Preset Test
+//    beConfig.format.LHV1.nPreset          = LQP_PHONE;
+
+    // Init the MP3 Stream
+    err = state->beInitStream(&beConfig, &state->dwSamples, &state->dwMP3Buffer, &state->hbeStream);
+
+    // Check result
+    if(err != BE_ERR_SUCCESSFUL)
+    {
+        return FMOD_ERR_PLUGIN;
+    }
+
+    // Allocate MP3 buffer
+    state->pMP3Buffer = (PBYTE)malloc(state->dwMP3Buffer);
+    if(!state->pMP3Buffer)
+    {
+        return FMOD_ERR_MEMORY;
+    }
+
+    // Allocate WAV buffer
+    state->pWAVBuffer = (PSHORT)malloc(state->dwSamples * sizeof(SHORT));
+    if (!state->pWAVBuffer)
+    {
+        return FMOD_ERR_MEMORY;
+    }
+
+    if (!extradriverdata)
+    {
+        strncpy(filename, "fmodoutput.mp3", 256);
+    }
+    else
+    {
+        strncpy(filename, (char *)extradriverdata, 256);
+    }
+
+    state->mFP = fopen(filename, "wb");
+    if (!state->mFP)
+    {
+        return FMOD_ERR_FILE_NOTFOUND;
+    }
+
+    return FMOD_OK;
+}
+
+
+/*
+[
+    [DESCRIPTION]
+
+    [PARAMETERS]
+ 
+    [REMARKS]
+
+    [SEE_ALSO]
+]
+*/
+FMOD_RESULT F_CALL OutputMP3_CloseCallback(FMOD_OUTPUT_STATE *output_state)
+{
+    outputmp3_state *state = (outputmp3_state *)output_state->plugindata;
+    DWORD dwWrite=0;
+    BE_ERR err;
+
+    if (!state)
+    {
+        return FMOD_OK;
+    }
+
+    // Deinit the stream
+    err = state->beDeinitStream(state->hbeStream, state->pMP3Buffer, &dwWrite);
+
+    // Check result
+    if(err != BE_ERR_SUCCESSFUL)
+    {
+        state->beCloseStream(state->hbeStream);
+
+        return FMOD_ERR_PLUGIN;
+    }
+
+    // Are there any bytes returned from the DeInit call?
+    // If so, write them to disk
+    if( dwWrite )
+    {
+        if( fwrite( state->pMP3Buffer, 1, dwWrite, state->mFP ) != dwWrite )
+        {
+            return FMOD_ERR_FILE_BAD;
+        }
+    }
+
+    // close the MP3 Stream
+    state->beCloseStream( state->hbeStream );
+
+    if (state->pWAVBuffer)
+    {
+        free(state->pWAVBuffer);
+        state->pWAVBuffer = 0;
+    }
+
+    if (state->pMP3Buffer)
+    {
+        free(state->pMP3Buffer);
+        state->pMP3Buffer = 0;
+    }
+
+    if (state->mFP)
+    {
+        fclose(state->mFP);
+        state->mFP = 0;
+    }
+
+    if (state)
+    {
+        free(state);
+        output_state->plugindata = 0;
+    }
+
+    return FMOD_OK;
+}
+
+
+/*
+[
+    [DESCRIPTION]
+
+    [PARAMETERS]
+ 
+    [REMARKS]
+
+    [SEE_ALSO]
+]
+*/
+FMOD_RESULT F_CALL OutputMP3_UpdateCallback(FMOD_OUTPUT_STATE *output_state)
+{
+    FMOD_RESULT result;
+    outputmp3_state *state = (outputmp3_state *)output_state->plugindata;
+    DWORD dwRead=0;
+    DWORD dwWrite=0;
+    BE_ERR err;
+
+    /*
+        Update the mixer to the interleaved buffer.
+    */
+    PSHORT destptr = state->pWAVBuffer;
+    unsigned int len = state->dwSamples / 2; /* /2 = stereo */;
+
+    while (len)
+    {
+        unsigned int l = len; // > state->dspbufferlength ? state->dspbufferlength : len;
+
+        result = output_state->readfrommixer(output_state, destptr, l);   
+        if (result != FMOD_OK)
+        {
+            return FMOD_OK;
+        }
+
+        len -= l;
+        destptr += (l * 2); /* *2 = stereo. */
+    }
+          
+    dwRead = state->dwSamples * sizeof(SHORT);
+
+    // Encode samples
+    err = state->beEncodeChunk(state->hbeStream, dwRead / sizeof(SHORT), state->pWAVBuffer, state->pMP3Buffer, &dwWrite);
+
+    // Check result
+    if(err != BE_ERR_SUCCESSFUL)
+    {
+        state->beCloseStream(state->hbeStream);
+        return FMOD_ERR_PLUGIN;
+    }
+        
+    // write dwWrite bytes that are returned in tehe pMP3Buffer to disk
+    if (fwrite(state->pMP3Buffer, 1, dwWrite, state->mFP) != dwWrite)
+    {
+        return FMOD_ERR_FILE_BAD;
+    }
+   
+    return FMOD_OK;
+}
+
+
+/*
+[
+    [DESCRIPTION]
+
+    [PARAMETERS]
+ 
+    [REMARKS]
+
+    [SEE_ALSO]
+]
+*/
+FMOD_RESULT F_CALL OutputMP3_GetHandleCallback(FMOD_OUTPUT_STATE *output_state, void **handle)
+{
+    outputmp3_state *state = (outputmp3_state *)output_state->plugindata;
+
+    *handle = state->mFP;
+
+    return FMOD_OK;
+}
+
+

SimpleGame/FMOD/api/core/examples/record.cpp

@@ -0,0 +1,222 @@
+/*==============================================================================
+Record example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to record continuously and play back the same data while
+keeping a specified latency between the two. This is achieved by delaying the
+start of playback until the specified number of milliseconds has been recorded.
+At runtime the playback speed will be slightly altered to compensate for any
+drift in either play or record drivers.
+
+For information on using FMOD example code in your own programs, visit
+https://www.fmod.com/legal
+==============================================================================*/
+#include "fmod.hpp"
+#include "common.h"
+
+#define LATENCY_MS      (50) /* Some devices will require higher latency to avoid glitches */
+#define DRIFT_MS        (1)
+#define DEVICE_INDEX    (0)
+
+int FMOD_Main()
+{
+    FMOD::Channel *channel = NULL;
+    unsigned int samplesRecorded = 0;
+    unsigned int samplesPlayed = 0;
+    bool dspEnabled = false;
+
+    void *extraDriverData = NULL;
+    Common_Init(&extraDriverData);
+
+    /*
+        Create a System object and initialize.
+    */
+    FMOD::System *system = NULL;
+    FMOD_RESULT result = FMOD::System_Create(&system);
+    ERRCHECK(result);
+
+    result = system->init(100, FMOD_INIT_NORMAL, extraDriverData);
+    ERRCHECK(result);
+
+    int numDrivers = 0;
+    result = system->getRecordNumDrivers(NULL, &numDrivers);
+    ERRCHECK(result);
+
+    if (numDrivers == 0)
+    {
+        Common_Fatal("No recording devices found/plugged in!  Aborting.");
+    }
+
+    /*
+        Determine latency in samples.
+    */
+    int nativeRate = 0;
+    int nativeChannels = 0;
+    result = system->getRecordDriverInfo(DEVICE_INDEX, NULL, 0, NULL, &nativeRate, NULL, &nativeChannels, NULL);
+    ERRCHECK(result);
+
+    unsigned int driftThreshold = (nativeRate * DRIFT_MS) / 1000;       /* The point where we start compensating for drift */
+    unsigned int desiredLatency = (nativeRate * LATENCY_MS) / 1000;     /* User specified latency */
+    unsigned int adjustedLatency = desiredLatency;                      /* User specified latency adjusted for driver update granularity */
+    int actualLatency = desiredLatency;                                 /* Latency measured once playback begins (smoothened for jitter) */
+
+    /*
+        Create user sound to record into, then start recording.
+    */
+    FMOD_CREATESOUNDEXINFO exinfo = {0};
+    exinfo.cbsize           = sizeof(FMOD_CREATESOUNDEXINFO);
+    exinfo.numchannels      = nativeChannels;
+    exinfo.format           = FMOD_SOUND_FORMAT_PCM16;
+    exinfo.defaultfrequency = nativeRate;
+    exinfo.length           = nativeRate * sizeof(short) * nativeChannels; /* 1 second buffer, size here doesn't change latency */
+    
+    FMOD::Sound *sound = NULL;
+    result = system->createSound(0, FMOD_LOOP_NORMAL | FMOD_OPENUSER, &exinfo, &sound);
+    ERRCHECK(result);
+
+    result = system->recordStart(DEVICE_INDEX, sound, true);
+    ERRCHECK(result);
+
+    unsigned int soundLength = 0;
+    result = sound->getLength(&soundLength, FMOD_TIMEUNIT_PCM);
+    ERRCHECK(result);
+
+    /*
+        Main loop
+    */
+    do
+    {
+        Common_Update();
+
+        /*
+            Add a DSP effect -- just for fun
+        */
+        if (Common_BtnPress(BTN_ACTION1))
+        {
+            FMOD_REVERB_PROPERTIES propOn = FMOD_PRESET_CONCERTHALL;
+            FMOD_REVERB_PROPERTIES propOff = FMOD_PRESET_OFF;
+
+            dspEnabled = !dspEnabled;
+
+            result = system->setReverbProperties(0, dspEnabled ? &propOn : &propOff);
+            ERRCHECK(result);
+        }
+
+        result = system->update();
+        ERRCHECK(result);
+       
+        /*
+            Determine how much has been recorded since we last checked
+        */
+        unsigned int recordPos = 0;
+        result = system->getRecordPosition(DEVICE_INDEX, &recordPos);
+        if (result != FMOD_ERR_RECORD_DISCONNECTED)
+        {
+            ERRCHECK(result);
+        }
+
+        static unsigned int lastRecordPos = 0;
+        unsigned int recordDelta = (recordPos >= lastRecordPos) ? (recordPos - lastRecordPos) : (recordPos + soundLength - lastRecordPos);
+        lastRecordPos = recordPos;
+        samplesRecorded += recordDelta;
+
+        static unsigned int minRecordDelta = (unsigned int)-1;
+        if (recordDelta && (recordDelta < minRecordDelta))
+        {
+            minRecordDelta = recordDelta; /* Smallest driver granularity seen so far */
+            adjustedLatency = (recordDelta <= desiredLatency) ? desiredLatency : recordDelta; /* Adjust our latency if driver granularity is high */
+        }
+        
+        /*
+            Delay playback until our desired latency is reached.
+        */
+        if (!channel && samplesRecorded >= adjustedLatency)
+        {
+            result = system->playSound(sound, 0, false, &channel);
+            ERRCHECK(result);
+        }
+
+        if (channel)
+        {
+            /*
+                Stop playback if recording stops.
+            */
+            bool isRecording = false;
+            result = system->isRecording(DEVICE_INDEX, &isRecording);
+            if (result != FMOD_ERR_RECORD_DISCONNECTED)
+            {
+                ERRCHECK(result);
+            }
+
+            if (!isRecording)
+            {
+                result = channel->setPaused(true);
+                ERRCHECK(result);
+            }
+
+            /*
+                Determine how much has been played since we last checked.
+            */
+            unsigned int playPos = 0;
+            result = channel->getPosition(&playPos, FMOD_TIMEUNIT_PCM);
+            ERRCHECK(result);
+
+            static unsigned int lastPlayPos = 0;
+            unsigned int playDelta = (playPos >= lastPlayPos) ? (playPos - lastPlayPos) : (playPos + soundLength - lastPlayPos);
+            lastPlayPos = playPos;
+            samplesPlayed += playDelta;
+            
+            /*
+                Compensate for any drift.
+            */
+            int latency = samplesRecorded - samplesPlayed;
+            actualLatency = (int)((0.97f * actualLatency) + (0.03f * latency));
+
+            int playbackRate = nativeRate;
+            if (actualLatency < (int)(adjustedLatency - driftThreshold)) 
+            {
+                /* Play position is catching up to the record position, slow playback down by 2% */
+                playbackRate = nativeRate - (nativeRate / 50); 
+            }
+            else if (actualLatency > (int)(adjustedLatency + driftThreshold))
+            {
+                /* Play position is falling behind the record position, speed playback up by 2% */
+                playbackRate = nativeRate + (nativeRate / 50);
+            }
+
+            channel->setFrequency((float)playbackRate);
+            ERRCHECK(result);
+        }
+
+        Common_Draw("==================================================");
+        Common_Draw("Record Example.");
+        Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+        Common_Draw("==================================================");
+        Common_Draw("");
+        Common_Draw("Adjust LATENCY define to compensate for stuttering");
+        Common_Draw("Current value is %dms", LATENCY_MS);
+        Common_Draw("");
+        Common_Draw("Press %s to %s DSP effect", Common_BtnStr(BTN_ACTION1), dspEnabled ? "disable" : "enable");
+        Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
+        Common_Draw("");
+        Common_Draw("Adjusted latency: %4d (%dms)", adjustedLatency, adjustedLatency * 1000 / nativeRate);
+        Common_Draw("Actual latency:   %4d (%dms)", actualLatency, actualLatency * 1000 / nativeRate);
+        Common_Draw("");
+        Common_Draw("Recorded: %5d (%ds)", samplesRecorded, samplesRecorded / nativeRate);
+        Common_Draw("Played:   %5d (%ds)", samplesPlayed, samplesPlayed / nativeRate);
+
+        Common_Sleep(10);
+    } while (!Common_BtnPress(BTN_QUIT));
+
+    /*
+        Shut down
+    */
+    result = sound->release();
+    ERRCHECK(result);
+    result = system->release();
+    ERRCHECK(result);
+
+    Common_Close();
+
+    return 0;
+}

SimpleGame/FMOD/api/core/examples/record_enumeration.cpp

@@ -0,0 +1,212 @@
+/*==============================================================================
+Record enumeration example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how to enumerate the available recording drivers on this
+device. It demonstrates how the enumerated list changes as microphones are
+attached and detached. It also shows that you can record from multi mics at
+the same time.
+
+Please note to minimize latency care should be taken to control the number
+of samples between the record position and the play position. Check the record
+example for details on this process.
+
+For information on using FMOD example code in your own programs, visit
+https://www.fmod.com/legal
+==============================================================================*/
+#include "fmod.hpp"
+#include "common.h"
+
+static const int MAX_DRIVERS = 16;
+static const int MAX_DRIVERS_IN_VIEW = 3;
+
+struct RECORD_STATE
+{
+    FMOD::Sound *sound;
+    FMOD::Channel *channel;
+};
+
+FMOD_RESULT F_CALL SystemCallback(FMOD_SYSTEM* /*system*/, FMOD_SYSTEM_CALLBACK_TYPE /*type*/, void *, void *, void *userData)
+{
+    int *recordListChangedCount = (int *)userData;
+    *recordListChangedCount = *recordListChangedCount + 1;
+
+    return FMOD_OK;
+}
+
+int FMOD_Main()
+{
+    int scroll = 0;
+    int cursor = 0;
+    RECORD_STATE record[MAX_DRIVERS] = { };
+
+    void *extraDriverData = NULL;
+    Common_Init(&extraDriverData);
+
+    /*
+        Create a System object and initialize.
+    */
+    FMOD::System *system = NULL;
+    FMOD_RESULT result = FMOD::System_Create(&system);
+    ERRCHECK(result);
+
+    result = system->init(100, FMOD_INIT_NORMAL, extraDriverData);
+    ERRCHECK(result);
+
+    /*
+        Setup a callback so we can be notified if the record list has changed.
+    */
+    int recordListChangedCount = 0;
+    result = system->setUserData(&recordListChangedCount);
+    ERRCHECK(result);
+
+    result = system->setCallback(&SystemCallback, FMOD_SYSTEM_CALLBACK_RECORDLISTCHANGED);
+    ERRCHECK(result);
+    
+    /*
+        Main loop
+    */
+    do
+    {
+        Common_Update();
+
+        int numDrivers = 0;
+        int numConnected = 0;
+        result = system->getRecordNumDrivers(&numDrivers, &numConnected);
+        ERRCHECK(result);
+
+        numDrivers = Common_Min(numDrivers, MAX_DRIVERS); /* Clamp the reported number of drivers to simplify this example */
+
+        if (Common_BtnPress(BTN_ACTION1))
+        {
+            bool isRecording = false;
+            system->isRecording(cursor, &isRecording);
+
+            if (isRecording)
+            {
+                system->recordStop(cursor);
+            }
+            else
+            {
+                /* Clean up previous record sound */
+                if (record[cursor].sound)
+                {
+                    result = record[cursor].sound->release();
+                    ERRCHECK(result);
+                }
+
+                /* Query device native settings and start a recording */
+                int nativeRate = 0;
+                int nativeChannels = 0;
+                result = system->getRecordDriverInfo(cursor, NULL, 0, NULL, &nativeRate, NULL, &nativeChannels, NULL);
+                ERRCHECK(result);
+
+                FMOD_CREATESOUNDEXINFO exinfo = {0};
+                exinfo.cbsize           = sizeof(FMOD_CREATESOUNDEXINFO);
+                exinfo.numchannels      = nativeChannels;
+                exinfo.format           = FMOD_SOUND_FORMAT_PCM16;
+                exinfo.defaultfrequency = nativeRate;
+                exinfo.length           = nativeRate * sizeof(short) * nativeChannels; /* 1 second buffer, size here doesn't change latency */
+    
+                result = system->createSound(0, FMOD_LOOP_NORMAL | FMOD_OPENUSER, &exinfo, &record[cursor].sound);
+                ERRCHECK(result);
+
+                result = system->recordStart(cursor, record[cursor].sound, true);
+                if (result != FMOD_ERR_RECORD_DISCONNECTED)
+                {
+                    ERRCHECK(result);
+                }
+            }
+        }
+        else if (Common_BtnPress(BTN_ACTION2))
+        {
+            bool isPlaying = false;
+            record[cursor].channel->isPlaying(&isPlaying);
+
+            if (isPlaying)
+            {
+                record[cursor].channel->stop();
+            }
+            else if (record[cursor].sound)
+            {
+                result = system->playSound(record[cursor].sound, NULL, false, &record[cursor].channel);
+                ERRCHECK(result);
+            }
+        }
+        else if (Common_BtnPress(BTN_UP))
+        {
+            cursor = Common_Max(cursor - 1, 0);
+            scroll = Common_Max(scroll - 1, 0);
+        }
+        else if (Common_BtnPress(BTN_DOWN))
+        {
+            if (numDrivers)
+            {
+                cursor = Common_Min(cursor + 1, numDrivers - 1);
+            }
+
+            if (numDrivers > MAX_DRIVERS_IN_VIEW)
+            {
+                scroll = Common_Min(scroll + 1, numDrivers - MAX_DRIVERS_IN_VIEW);
+            }
+        }
+
+        result = system->update();
+        ERRCHECK(result);
+
+        Common_Draw("==================================================");
+        Common_Draw("Record Enumeration Example.");
+        Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+        Common_Draw("==================================================");
+        Common_Draw("");
+        Common_Draw("Record list has updated %d time(s).", recordListChangedCount);
+        Common_Draw("Currently %d device(s) plugged in.", numConnected);
+        Common_Draw("");
+        Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
+        Common_Draw("Press %s and %s to scroll list", Common_BtnStr(BTN_UP), Common_BtnStr(BTN_DOWN));
+        Common_Draw("Press %s start / stop recording", Common_BtnStr(BTN_ACTION1));
+        Common_Draw("Press %s start / stop playback", Common_BtnStr(BTN_ACTION2));
+        Common_Draw("");
+        int numDisplay = Common_Min(numDrivers, MAX_DRIVERS_IN_VIEW);
+        for (int i = scroll; i < scroll + numDisplay; i++)
+        {
+            char name[256];
+            int sampleRate;
+            int channels;
+            FMOD_GUID guid;
+            FMOD_DRIVER_STATE state;
+
+            result = system->getRecordDriverInfo(i, name, sizeof(name), &guid, &sampleRate, NULL, &channels, &state);
+            ERRCHECK(result);
+
+            bool isRecording = false;
+            system->isRecording(i, &isRecording);
+
+            bool isPlaying = false;
+            record[i].channel->isPlaying(&isPlaying);
+
+            Common_Draw("%c%2d. %s%.41s", (cursor == i) ? '>' : ' ', i, (state & FMOD_DRIVER_STATE_DEFAULT) ? "(*) " : "", name);
+            Common_Draw("%dKHz %dch {%08X-%04X-%04X-%04X-%02X%02X%02X%02X%02X%02X}", sampleRate / 1000, channels, guid.Data1, guid.Data2, guid.Data3, guid.Data4[0] << 8 | guid.Data4[1], guid.Data4[2], guid.Data4[3], guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]);
+            Common_Draw("(%s) (%s) (%s)", (state & FMOD_DRIVER_STATE_CONNECTED) ? "Connected" : "Unplugged", isRecording ? "Recording" : "Not recording", isPlaying ? "Playing" : "Not playing");
+            Common_Draw("");
+        }
+
+        Common_Sleep(50);
+    } while (!Common_BtnPress(BTN_QUIT));
+
+    for (int i = 0; i < MAX_DRIVERS; i++)
+    {
+        if (record[i].sound)
+        {
+            result = record[i].sound->release();
+            ERRCHECK(result);
+        }
+    }
+
+    result = system->release();
+    ERRCHECK(result);
+
+    Common_Close();
+
+    return 0;
+}

SimpleGame/FMOD/api/core/examples/user_created_sound.cpp

@@ -0,0 +1,190 @@
+/*==============================================================================
+User Created Sound Example
+Copyright (c), Firelight Technologies Pty, Ltd 2004-2025.
+
+This example shows how create a sound with data filled by the user. It shows a
+user created static sample, followed by a user created stream. The former
+allocates all memory needed for the sound and is played back as a static sample, 
+while the latter streams the data in chunks as it plays, using far less memory.
+
+For information on using FMOD example code in your own programs, visit
+https://www.fmod.com/legal
+==============================================================================*/
+#include "fmod.hpp"
+#include "common.h"
+#include <math.h>
+
+FMOD_RESULT F_CALL pcmreadcallback(FMOD_SOUND* /*sound*/, void *data, unsigned int datalen)
+{
+    static float  t1 = 0, t2 = 0;        // time
+    static float  v1 = 0, v2 = 0;        // velocity
+    signed short *stereo16bitbuffer = (signed short *)data;
+
+    for (unsigned int count = 0; count < (datalen >> 2); count++)     // >>2 = 16bit stereo (4 bytes per sample)
+    {
+        *stereo16bitbuffer++ = (signed short)(Common_Sin(t1) * 32767.0f);    // left channel
+        *stereo16bitbuffer++ = (signed short)(Common_Sin(t2) * 32767.0f);    // right channel
+
+        t1 += 0.01f   + v1;
+        t2 += 0.0142f + v2;
+        v1 += (float)(Common_Sin(t1) * 0.002f);
+        v2 += (float)(Common_Sin(t2) * 0.002f);
+    }
+
+    return FMOD_OK;
+}
+
+FMOD_RESULT F_CALL pcmsetposcallback(FMOD_SOUND* /*sound*/, int /*subsound*/, unsigned int /*position*/, FMOD_TIMEUNIT /*postype*/)
+{
+    /*
+        This is useful if the user calls Channel::setPosition and you want to seek your data accordingly.
+    */
+    return FMOD_OK;
+}
+
+int FMOD_Main()
+{
+    FMOD::System           *system;
+    FMOD::Sound            *sound;
+    FMOD::Channel          *channel = 0;
+    FMOD_RESULT             result;
+    FMOD_MODE               mode = FMOD_OPENUSER | FMOD_LOOP_NORMAL;
+    FMOD_CREATESOUNDEXINFO  exinfo;
+    void                   *extradriverdata = 0;
+    
+    Common_Init(&extradriverdata);
+
+    /*
+        Create a System object and initialize.
+    */
+    result = FMOD::System_Create(&system);
+    ERRCHECK(result);
+
+    result = system->init(32, FMOD_INIT_NORMAL, extradriverdata);
+    ERRCHECK(result);
+        
+    do
+    {
+        Common_Update();
+
+        if (Common_BtnPress(BTN_ACTION1))
+        {
+            mode |= FMOD_CREATESTREAM;
+        }
+
+        result = system->update();
+        ERRCHECK(result);
+
+        Common_Draw("==================================================");
+        Common_Draw("User Created Sound Example.");
+        Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+        Common_Draw("==================================================");
+        Common_Draw("");
+        Common_Draw("Sound played here is generated in realtime. It will either play as a stream which means it is continually filled as it is playing, or it will play as a static sample, which means it is filled once as the sound is created, then when played it will just play that short loop of data.");
+        Common_Draw("");
+        Common_Draw("Press %s to play an infinite generated stream", Common_BtnStr(BTN_ACTION1));
+        Common_Draw("Press %s to play a static looping sample", Common_BtnStr(BTN_ACTION2));
+        Common_Draw("");
+
+        Common_Sleep(50);
+    } while (!Common_BtnPress(BTN_ACTION1) && !Common_BtnPress(BTN_ACTION2) && !Common_BtnPress(BTN_QUIT));
+
+    /*
+        Create and play the sound.
+    */
+    memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
+    exinfo.cbsize            = sizeof(FMOD_CREATESOUNDEXINFO);  /* Required. */
+    exinfo.numchannels       = 2;                               /* Number of channels in the sound. */
+    exinfo.defaultfrequency  = 44100;                           /* Default playback rate of sound. */
+    exinfo.decodebuffersize  = 44100;                           /* Chunk size of stream update in samples. This will be the amount of data passed to the user callback. */
+    exinfo.length            = exinfo.defaultfrequency * exinfo.numchannels * sizeof(signed short) * 5; /* Length of PCM data in bytes of whole song (for Sound::getLength) */
+    exinfo.format            = FMOD_SOUND_FORMAT_PCM16;         /* Data format of sound. */
+    exinfo.pcmreadcallback   = pcmreadcallback;                 /* User callback for reading. */
+    exinfo.pcmsetposcallback = pcmsetposcallback;               /* User callback for seeking. */
+
+    result = system->createSound(0, mode, &exinfo, &sound);
+    ERRCHECK(result);
+
+    result = system->playSound(sound, 0, 0, &channel);
+    ERRCHECK(result);
+
+    /*
+        Main loop.
+    */
+    do
+    {
+        Common_Update();
+
+        if (Common_BtnPress(BTN_ACTION1))
+        {
+            bool paused;
+            result = channel->getPaused(&paused);
+            ERRCHECK(result);
+            result = channel->setPaused(!paused);
+            ERRCHECK(result);
+        }
+
+        result = system->update();
+        ERRCHECK(result);
+
+        {
+            unsigned int ms = 0;
+            unsigned int lenms = 0;
+            bool         playing = false;
+            bool         paused = false;
+
+            if (channel)
+            {
+                result = channel->isPlaying(&playing);
+                if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE))
+                {
+                    ERRCHECK(result);
+                }
+
+                result = channel->getPaused(&paused);
+                if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE))
+                {
+                    ERRCHECK(result);
+                }
+
+                result = channel->getPosition(&ms, FMOD_TIMEUNIT_MS);
+                if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE))
+                {
+                    ERRCHECK(result);
+                }
+               
+                result = sound->getLength(&lenms, FMOD_TIMEUNIT_MS);
+                if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE))
+                {
+                    ERRCHECK(result);
+                }
+            }
+
+            Common_Draw("==================================================");
+            Common_Draw("User Created Sound Example.");
+            Common_Draw("Copyright (c) Firelight Technologies 2004-2025.");
+            Common_Draw("==================================================");
+            Common_Draw("");
+            Common_Draw("Press %s to toggle pause", Common_BtnStr(BTN_ACTION1));
+            Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
+            Common_Draw("");
+            Common_Draw("Time %02d:%02d:%02d/%02d:%02d:%02d : %s", ms / 1000 / 60, ms / 1000 % 60, ms / 10 % 100, lenms / 1000 / 60, lenms / 1000 % 60, lenms / 10 % 100, paused ? "Paused " : playing ? "Playing" : "Stopped");
+        }
+
+        Common_Sleep(50);
+    } while (!Common_BtnPress(BTN_QUIT));
+
+    /*
+        Shut down
+    */
+    result = sound->release();
+    ERRCHECK(result);
+    result = system->close();
+    ERRCHECK(result);
+    result = system->release();
+    ERRCHECK(result);
+
+    Common_Close();
+
+    return 0;
+}

SimpleGame/FMOD/api/core/examples/vs2017/3d.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{FC0F9AB6-B661-4C11-B323-7AB76159647E}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\3d.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/3d.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/asyncio.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{253F945A-674D-4AC9-AD17-8A79E611D177}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\asyncio.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/asyncio.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/channel_groups.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{FFC0AAB0-2216-4BE9-9B08-017B7585BB42}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\channel_groups.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/channel_groups.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/convolution_reverb.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{731C2023-73AE-4DD4-BE41-D420C9B1AEB3}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\convolution_reverb.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/convolution_reverb.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/dsp_custom.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{2E155196-9ADA-4BA8-A7F0-F53B8F9DEF86}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\dsp_custom.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/dsp_custom.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/dsp_effect_per_speaker.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{1B5A31E5-9C05-4680-91F8-D3CED3CD4BFE}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\dsp_effect_per_speaker.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/dsp_effect_per_speaker.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/dsp_inspector.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{3561F16E-76B3-44B0-8522-DC002D7A4462}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\dsp_inspector.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/dsp_inspector.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/effects.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{EB716030-6147-46E6-923A-9BE3761A5D83}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\effects.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/effects.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/examples.sln

@@ -0,0 +1,538 @@
+
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 15
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "3d", "3d.vcxproj", "{FC0F9AB6-B661-4C11-B323-7AB76159647E}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "asyncio", "asyncio.vcxproj", "{253F945A-674D-4AC9-AD17-8A79E611D177}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "channel_groups", "channel_groups.vcxproj", "{FFC0AAB0-2216-4BE9-9B08-017B7585BB42}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "convolution_reverb", "convolution_reverb.vcxproj", "{731C2023-73AE-4DD4-BE41-D420C9B1AEB3}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dsp_custom", "dsp_custom.vcxproj", "{2E155196-9ADA-4BA8-A7F0-F53B8F9DEF86}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dsp_effect_per_speaker", "dsp_effect_per_speaker.vcxproj", "{1B5A31E5-9C05-4680-91F8-D3CED3CD4BFE}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dsp_inspector", "dsp_inspector.vcxproj", "{3561F16E-76B3-44B0-8522-DC002D7A4462}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "effects", "effects.vcxproj", "{EB716030-6147-46E6-923A-9BE3761A5D83}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gapless_playback", "gapless_playback.vcxproj", "{38EDE105-ED40-416E-8B3F-D68485441AA8}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "generate_tone", "generate_tone.vcxproj", "{7932C973-B540-4E74-942D-0BF5728BF091}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "granular_synth", "granular_synth.vcxproj", "{501C3C3D-8B4D-4EB2-9474-5463C68EA271}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "load_from_memory", "load_from_memory.vcxproj", "{D26E9EEF-F930-451B-8358-B4E961C2A15F}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "multiple_speaker", "multiple_speaker.vcxproj", "{8C976B7E-7365-4BBF-9685-B5F19A07E44F}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "multiple_system", "multiple_system.vcxproj", "{E8C07E07-E0FE-4357-A1C2-DBFB0D87E3F3}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "net_stream", "net_stream.vcxproj", "{85132E7A-73F1-4A05-A483-B7313EAB5213}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "play_sound", "play_sound.vcxproj", "{D9EB1955-6B94-4104-B575-F49E58C41950}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "play_stream", "play_stream.vcxproj", "{86B8B44F-5D74-41B8-BADD-27D0E4CC1133}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "record", "record.vcxproj", "{47B4FD36-0DC7-4696-9130-C06BB6AE7A33}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "record_enumeration", "record_enumeration.vcxproj", "{3904C036-87C3-4926-8CF3-09044A309655}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "user_created_sound", "user_created_sound.vcxproj", "{28C809E6-BCD2-4828-93B2-151A21C6DF5C}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fmod_codec_raw", "fmod_codec_raw.vcxproj", "{5633D9E2-14D5-4CC2-B955-5BFB1305755D}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fmod_distance_filter", "fmod_distance_filter.vcxproj", "{551E887A-BDCF-4260-8FD6-167E5D50F3EC}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fmod_gain", "fmod_gain.vcxproj", "{A32E6CB7-4CDC-4C96-BBA7-6C1393C1B2DB}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fmod_noise", "fmod_noise.vcxproj", "{2842107C-FC3A-4CAD-84BC-A9C5B720D92C}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fmod_rnbo", "fmod_rnbo.vcxproj", "{886B5D10-5CC4-4292-A764-8EB1D3C66D44}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "output_mp3", "output_mp3.vcxproj", "{D356A850-2D79-47D2-A914-34A2913E3D0B}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Debug|x64 = Debug|x64
+		Debug|ARM64 = Debug|ARM64
+		Release|Win32 = Release|Win32
+		Release|x64 = Release|x64
+		Release|ARM64 = Release|ARM64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{FC0F9AB6-B661-4C11-B323-7AB76159647E}.Debug|Win32.ActiveCfg = Debug|Win32
+		{FC0F9AB6-B661-4C11-B323-7AB76159647E}.Debug|Win32.Build.0 = Debug|Win32
+		{FC0F9AB6-B661-4C11-B323-7AB76159647E}.Debug|Win32.Deploy.0 = Debug|Win32
+		{FC0F9AB6-B661-4C11-B323-7AB76159647E}.Debug|x64.ActiveCfg = Debug|x64
+		{FC0F9AB6-B661-4C11-B323-7AB76159647E}.Debug|x64.Build.0 = Debug|x64
+		{FC0F9AB6-B661-4C11-B323-7AB76159647E}.Debug|x64.Deploy.0 = Debug|x64
+		{FC0F9AB6-B661-4C11-B323-7AB76159647E}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{FC0F9AB6-B661-4C11-B323-7AB76159647E}.Debug|ARM64.Build.0 = Debug|ARM64
+		{FC0F9AB6-B661-4C11-B323-7AB76159647E}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{FC0F9AB6-B661-4C11-B323-7AB76159647E}.Release|Win32.ActiveCfg = Release|Win32
+		{FC0F9AB6-B661-4C11-B323-7AB76159647E}.Release|Win32.Build.0 = Release|Win32
+		{FC0F9AB6-B661-4C11-B323-7AB76159647E}.Release|Win32.Deploy.0 = Release|Win32
+		{FC0F9AB6-B661-4C11-B323-7AB76159647E}.Release|x64.ActiveCfg = Release|x64
+		{FC0F9AB6-B661-4C11-B323-7AB76159647E}.Release|x64.Build.0 = Release|x64
+		{FC0F9AB6-B661-4C11-B323-7AB76159647E}.Release|x64.Deploy.0 = Release|x64
+		{FC0F9AB6-B661-4C11-B323-7AB76159647E}.Release|ARM64.ActiveCfg = Release|ARM64
+		{FC0F9AB6-B661-4C11-B323-7AB76159647E}.Release|ARM64.Build.0 = Release|ARM64
+		{FC0F9AB6-B661-4C11-B323-7AB76159647E}.Release|ARM64.Deploy.0 = Release|ARM64
+		{253F945A-674D-4AC9-AD17-8A79E611D177}.Debug|Win32.ActiveCfg = Debug|Win32
+		{253F945A-674D-4AC9-AD17-8A79E611D177}.Debug|Win32.Build.0 = Debug|Win32
+		{253F945A-674D-4AC9-AD17-8A79E611D177}.Debug|Win32.Deploy.0 = Debug|Win32
+		{253F945A-674D-4AC9-AD17-8A79E611D177}.Debug|x64.ActiveCfg = Debug|x64
+		{253F945A-674D-4AC9-AD17-8A79E611D177}.Debug|x64.Build.0 = Debug|x64
+		{253F945A-674D-4AC9-AD17-8A79E611D177}.Debug|x64.Deploy.0 = Debug|x64
+		{253F945A-674D-4AC9-AD17-8A79E611D177}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{253F945A-674D-4AC9-AD17-8A79E611D177}.Debug|ARM64.Build.0 = Debug|ARM64
+		{253F945A-674D-4AC9-AD17-8A79E611D177}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{253F945A-674D-4AC9-AD17-8A79E611D177}.Release|Win32.ActiveCfg = Release|Win32
+		{253F945A-674D-4AC9-AD17-8A79E611D177}.Release|Win32.Build.0 = Release|Win32
+		{253F945A-674D-4AC9-AD17-8A79E611D177}.Release|Win32.Deploy.0 = Release|Win32
+		{253F945A-674D-4AC9-AD17-8A79E611D177}.Release|x64.ActiveCfg = Release|x64
+		{253F945A-674D-4AC9-AD17-8A79E611D177}.Release|x64.Build.0 = Release|x64
+		{253F945A-674D-4AC9-AD17-8A79E611D177}.Release|x64.Deploy.0 = Release|x64
+		{253F945A-674D-4AC9-AD17-8A79E611D177}.Release|ARM64.ActiveCfg = Release|ARM64
+		{253F945A-674D-4AC9-AD17-8A79E611D177}.Release|ARM64.Build.0 = Release|ARM64
+		{253F945A-674D-4AC9-AD17-8A79E611D177}.Release|ARM64.Deploy.0 = Release|ARM64
+		{FFC0AAB0-2216-4BE9-9B08-017B7585BB42}.Debug|Win32.ActiveCfg = Debug|Win32
+		{FFC0AAB0-2216-4BE9-9B08-017B7585BB42}.Debug|Win32.Build.0 = Debug|Win32
+		{FFC0AAB0-2216-4BE9-9B08-017B7585BB42}.Debug|Win32.Deploy.0 = Debug|Win32
+		{FFC0AAB0-2216-4BE9-9B08-017B7585BB42}.Debug|x64.ActiveCfg = Debug|x64
+		{FFC0AAB0-2216-4BE9-9B08-017B7585BB42}.Debug|x64.Build.0 = Debug|x64
+		{FFC0AAB0-2216-4BE9-9B08-017B7585BB42}.Debug|x64.Deploy.0 = Debug|x64
+		{FFC0AAB0-2216-4BE9-9B08-017B7585BB42}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{FFC0AAB0-2216-4BE9-9B08-017B7585BB42}.Debug|ARM64.Build.0 = Debug|ARM64
+		{FFC0AAB0-2216-4BE9-9B08-017B7585BB42}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{FFC0AAB0-2216-4BE9-9B08-017B7585BB42}.Release|Win32.ActiveCfg = Release|Win32
+		{FFC0AAB0-2216-4BE9-9B08-017B7585BB42}.Release|Win32.Build.0 = Release|Win32
+		{FFC0AAB0-2216-4BE9-9B08-017B7585BB42}.Release|Win32.Deploy.0 = Release|Win32
+		{FFC0AAB0-2216-4BE9-9B08-017B7585BB42}.Release|x64.ActiveCfg = Release|x64
+		{FFC0AAB0-2216-4BE9-9B08-017B7585BB42}.Release|x64.Build.0 = Release|x64
+		{FFC0AAB0-2216-4BE9-9B08-017B7585BB42}.Release|x64.Deploy.0 = Release|x64
+		{FFC0AAB0-2216-4BE9-9B08-017B7585BB42}.Release|ARM64.ActiveCfg = Release|ARM64
+		{FFC0AAB0-2216-4BE9-9B08-017B7585BB42}.Release|ARM64.Build.0 = Release|ARM64
+		{FFC0AAB0-2216-4BE9-9B08-017B7585BB42}.Release|ARM64.Deploy.0 = Release|ARM64
+		{731C2023-73AE-4DD4-BE41-D420C9B1AEB3}.Debug|Win32.ActiveCfg = Debug|Win32
+		{731C2023-73AE-4DD4-BE41-D420C9B1AEB3}.Debug|Win32.Build.0 = Debug|Win32
+		{731C2023-73AE-4DD4-BE41-D420C9B1AEB3}.Debug|Win32.Deploy.0 = Debug|Win32
+		{731C2023-73AE-4DD4-BE41-D420C9B1AEB3}.Debug|x64.ActiveCfg = Debug|x64
+		{731C2023-73AE-4DD4-BE41-D420C9B1AEB3}.Debug|x64.Build.0 = Debug|x64
+		{731C2023-73AE-4DD4-BE41-D420C9B1AEB3}.Debug|x64.Deploy.0 = Debug|x64
+		{731C2023-73AE-4DD4-BE41-D420C9B1AEB3}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{731C2023-73AE-4DD4-BE41-D420C9B1AEB3}.Debug|ARM64.Build.0 = Debug|ARM64
+		{731C2023-73AE-4DD4-BE41-D420C9B1AEB3}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{731C2023-73AE-4DD4-BE41-D420C9B1AEB3}.Release|Win32.ActiveCfg = Release|Win32
+		{731C2023-73AE-4DD4-BE41-D420C9B1AEB3}.Release|Win32.Build.0 = Release|Win32
+		{731C2023-73AE-4DD4-BE41-D420C9B1AEB3}.Release|Win32.Deploy.0 = Release|Win32
+		{731C2023-73AE-4DD4-BE41-D420C9B1AEB3}.Release|x64.ActiveCfg = Release|x64
+		{731C2023-73AE-4DD4-BE41-D420C9B1AEB3}.Release|x64.Build.0 = Release|x64
+		{731C2023-73AE-4DD4-BE41-D420C9B1AEB3}.Release|x64.Deploy.0 = Release|x64
+		{731C2023-73AE-4DD4-BE41-D420C9B1AEB3}.Release|ARM64.ActiveCfg = Release|ARM64
+		{731C2023-73AE-4DD4-BE41-D420C9B1AEB3}.Release|ARM64.Build.0 = Release|ARM64
+		{731C2023-73AE-4DD4-BE41-D420C9B1AEB3}.Release|ARM64.Deploy.0 = Release|ARM64
+		{2E155196-9ADA-4BA8-A7F0-F53B8F9DEF86}.Debug|Win32.ActiveCfg = Debug|Win32
+		{2E155196-9ADA-4BA8-A7F0-F53B8F9DEF86}.Debug|Win32.Build.0 = Debug|Win32
+		{2E155196-9ADA-4BA8-A7F0-F53B8F9DEF86}.Debug|Win32.Deploy.0 = Debug|Win32
+		{2E155196-9ADA-4BA8-A7F0-F53B8F9DEF86}.Debug|x64.ActiveCfg = Debug|x64
+		{2E155196-9ADA-4BA8-A7F0-F53B8F9DEF86}.Debug|x64.Build.0 = Debug|x64
+		{2E155196-9ADA-4BA8-A7F0-F53B8F9DEF86}.Debug|x64.Deploy.0 = Debug|x64
+		{2E155196-9ADA-4BA8-A7F0-F53B8F9DEF86}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{2E155196-9ADA-4BA8-A7F0-F53B8F9DEF86}.Debug|ARM64.Build.0 = Debug|ARM64
+		{2E155196-9ADA-4BA8-A7F0-F53B8F9DEF86}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{2E155196-9ADA-4BA8-A7F0-F53B8F9DEF86}.Release|Win32.ActiveCfg = Release|Win32
+		{2E155196-9ADA-4BA8-A7F0-F53B8F9DEF86}.Release|Win32.Build.0 = Release|Win32
+		{2E155196-9ADA-4BA8-A7F0-F53B8F9DEF86}.Release|Win32.Deploy.0 = Release|Win32
+		{2E155196-9ADA-4BA8-A7F0-F53B8F9DEF86}.Release|x64.ActiveCfg = Release|x64
+		{2E155196-9ADA-4BA8-A7F0-F53B8F9DEF86}.Release|x64.Build.0 = Release|x64
+		{2E155196-9ADA-4BA8-A7F0-F53B8F9DEF86}.Release|x64.Deploy.0 = Release|x64
+		{2E155196-9ADA-4BA8-A7F0-F53B8F9DEF86}.Release|ARM64.ActiveCfg = Release|ARM64
+		{2E155196-9ADA-4BA8-A7F0-F53B8F9DEF86}.Release|ARM64.Build.0 = Release|ARM64
+		{2E155196-9ADA-4BA8-A7F0-F53B8F9DEF86}.Release|ARM64.Deploy.0 = Release|ARM64
+		{1B5A31E5-9C05-4680-91F8-D3CED3CD4BFE}.Debug|Win32.ActiveCfg = Debug|Win32
+		{1B5A31E5-9C05-4680-91F8-D3CED3CD4BFE}.Debug|Win32.Build.0 = Debug|Win32
+		{1B5A31E5-9C05-4680-91F8-D3CED3CD4BFE}.Debug|Win32.Deploy.0 = Debug|Win32
+		{1B5A31E5-9C05-4680-91F8-D3CED3CD4BFE}.Debug|x64.ActiveCfg = Debug|x64
+		{1B5A31E5-9C05-4680-91F8-D3CED3CD4BFE}.Debug|x64.Build.0 = Debug|x64
+		{1B5A31E5-9C05-4680-91F8-D3CED3CD4BFE}.Debug|x64.Deploy.0 = Debug|x64
+		{1B5A31E5-9C05-4680-91F8-D3CED3CD4BFE}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{1B5A31E5-9C05-4680-91F8-D3CED3CD4BFE}.Debug|ARM64.Build.0 = Debug|ARM64
+		{1B5A31E5-9C05-4680-91F8-D3CED3CD4BFE}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{1B5A31E5-9C05-4680-91F8-D3CED3CD4BFE}.Release|Win32.ActiveCfg = Release|Win32
+		{1B5A31E5-9C05-4680-91F8-D3CED3CD4BFE}.Release|Win32.Build.0 = Release|Win32
+		{1B5A31E5-9C05-4680-91F8-D3CED3CD4BFE}.Release|Win32.Deploy.0 = Release|Win32
+		{1B5A31E5-9C05-4680-91F8-D3CED3CD4BFE}.Release|x64.ActiveCfg = Release|x64
+		{1B5A31E5-9C05-4680-91F8-D3CED3CD4BFE}.Release|x64.Build.0 = Release|x64
+		{1B5A31E5-9C05-4680-91F8-D3CED3CD4BFE}.Release|x64.Deploy.0 = Release|x64
+		{1B5A31E5-9C05-4680-91F8-D3CED3CD4BFE}.Release|ARM64.ActiveCfg = Release|ARM64
+		{1B5A31E5-9C05-4680-91F8-D3CED3CD4BFE}.Release|ARM64.Build.0 = Release|ARM64
+		{1B5A31E5-9C05-4680-91F8-D3CED3CD4BFE}.Release|ARM64.Deploy.0 = Release|ARM64
+		{3561F16E-76B3-44B0-8522-DC002D7A4462}.Debug|Win32.ActiveCfg = Debug|Win32
+		{3561F16E-76B3-44B0-8522-DC002D7A4462}.Debug|Win32.Build.0 = Debug|Win32
+		{3561F16E-76B3-44B0-8522-DC002D7A4462}.Debug|Win32.Deploy.0 = Debug|Win32
+		{3561F16E-76B3-44B0-8522-DC002D7A4462}.Debug|x64.ActiveCfg = Debug|x64
+		{3561F16E-76B3-44B0-8522-DC002D7A4462}.Debug|x64.Build.0 = Debug|x64
+		{3561F16E-76B3-44B0-8522-DC002D7A4462}.Debug|x64.Deploy.0 = Debug|x64
+		{3561F16E-76B3-44B0-8522-DC002D7A4462}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{3561F16E-76B3-44B0-8522-DC002D7A4462}.Debug|ARM64.Build.0 = Debug|ARM64
+		{3561F16E-76B3-44B0-8522-DC002D7A4462}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{3561F16E-76B3-44B0-8522-DC002D7A4462}.Release|Win32.ActiveCfg = Release|Win32
+		{3561F16E-76B3-44B0-8522-DC002D7A4462}.Release|Win32.Build.0 = Release|Win32
+		{3561F16E-76B3-44B0-8522-DC002D7A4462}.Release|Win32.Deploy.0 = Release|Win32
+		{3561F16E-76B3-44B0-8522-DC002D7A4462}.Release|x64.ActiveCfg = Release|x64
+		{3561F16E-76B3-44B0-8522-DC002D7A4462}.Release|x64.Build.0 = Release|x64
+		{3561F16E-76B3-44B0-8522-DC002D7A4462}.Release|x64.Deploy.0 = Release|x64
+		{3561F16E-76B3-44B0-8522-DC002D7A4462}.Release|ARM64.ActiveCfg = Release|ARM64
+		{3561F16E-76B3-44B0-8522-DC002D7A4462}.Release|ARM64.Build.0 = Release|ARM64
+		{3561F16E-76B3-44B0-8522-DC002D7A4462}.Release|ARM64.Deploy.0 = Release|ARM64
+		{EB716030-6147-46E6-923A-9BE3761A5D83}.Debug|Win32.ActiveCfg = Debug|Win32
+		{EB716030-6147-46E6-923A-9BE3761A5D83}.Debug|Win32.Build.0 = Debug|Win32
+		{EB716030-6147-46E6-923A-9BE3761A5D83}.Debug|Win32.Deploy.0 = Debug|Win32
+		{EB716030-6147-46E6-923A-9BE3761A5D83}.Debug|x64.ActiveCfg = Debug|x64
+		{EB716030-6147-46E6-923A-9BE3761A5D83}.Debug|x64.Build.0 = Debug|x64
+		{EB716030-6147-46E6-923A-9BE3761A5D83}.Debug|x64.Deploy.0 = Debug|x64
+		{EB716030-6147-46E6-923A-9BE3761A5D83}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{EB716030-6147-46E6-923A-9BE3761A5D83}.Debug|ARM64.Build.0 = Debug|ARM64
+		{EB716030-6147-46E6-923A-9BE3761A5D83}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{EB716030-6147-46E6-923A-9BE3761A5D83}.Release|Win32.ActiveCfg = Release|Win32
+		{EB716030-6147-46E6-923A-9BE3761A5D83}.Release|Win32.Build.0 = Release|Win32
+		{EB716030-6147-46E6-923A-9BE3761A5D83}.Release|Win32.Deploy.0 = Release|Win32
+		{EB716030-6147-46E6-923A-9BE3761A5D83}.Release|x64.ActiveCfg = Release|x64
+		{EB716030-6147-46E6-923A-9BE3761A5D83}.Release|x64.Build.0 = Release|x64
+		{EB716030-6147-46E6-923A-9BE3761A5D83}.Release|x64.Deploy.0 = Release|x64
+		{EB716030-6147-46E6-923A-9BE3761A5D83}.Release|ARM64.ActiveCfg = Release|ARM64
+		{EB716030-6147-46E6-923A-9BE3761A5D83}.Release|ARM64.Build.0 = Release|ARM64
+		{EB716030-6147-46E6-923A-9BE3761A5D83}.Release|ARM64.Deploy.0 = Release|ARM64
+		{38EDE105-ED40-416E-8B3F-D68485441AA8}.Debug|Win32.ActiveCfg = Debug|Win32
+		{38EDE105-ED40-416E-8B3F-D68485441AA8}.Debug|Win32.Build.0 = Debug|Win32
+		{38EDE105-ED40-416E-8B3F-D68485441AA8}.Debug|Win32.Deploy.0 = Debug|Win32
+		{38EDE105-ED40-416E-8B3F-D68485441AA8}.Debug|x64.ActiveCfg = Debug|x64
+		{38EDE105-ED40-416E-8B3F-D68485441AA8}.Debug|x64.Build.0 = Debug|x64
+		{38EDE105-ED40-416E-8B3F-D68485441AA8}.Debug|x64.Deploy.0 = Debug|x64
+		{38EDE105-ED40-416E-8B3F-D68485441AA8}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{38EDE105-ED40-416E-8B3F-D68485441AA8}.Debug|ARM64.Build.0 = Debug|ARM64
+		{38EDE105-ED40-416E-8B3F-D68485441AA8}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{38EDE105-ED40-416E-8B3F-D68485441AA8}.Release|Win32.ActiveCfg = Release|Win32
+		{38EDE105-ED40-416E-8B3F-D68485441AA8}.Release|Win32.Build.0 = Release|Win32
+		{38EDE105-ED40-416E-8B3F-D68485441AA8}.Release|Win32.Deploy.0 = Release|Win32
+		{38EDE105-ED40-416E-8B3F-D68485441AA8}.Release|x64.ActiveCfg = Release|x64
+		{38EDE105-ED40-416E-8B3F-D68485441AA8}.Release|x64.Build.0 = Release|x64
+		{38EDE105-ED40-416E-8B3F-D68485441AA8}.Release|x64.Deploy.0 = Release|x64
+		{38EDE105-ED40-416E-8B3F-D68485441AA8}.Release|ARM64.ActiveCfg = Release|ARM64
+		{38EDE105-ED40-416E-8B3F-D68485441AA8}.Release|ARM64.Build.0 = Release|ARM64
+		{38EDE105-ED40-416E-8B3F-D68485441AA8}.Release|ARM64.Deploy.0 = Release|ARM64
+		{7932C973-B540-4E74-942D-0BF5728BF091}.Debug|Win32.ActiveCfg = Debug|Win32
+		{7932C973-B540-4E74-942D-0BF5728BF091}.Debug|Win32.Build.0 = Debug|Win32
+		{7932C973-B540-4E74-942D-0BF5728BF091}.Debug|Win32.Deploy.0 = Debug|Win32
+		{7932C973-B540-4E74-942D-0BF5728BF091}.Debug|x64.ActiveCfg = Debug|x64
+		{7932C973-B540-4E74-942D-0BF5728BF091}.Debug|x64.Build.0 = Debug|x64
+		{7932C973-B540-4E74-942D-0BF5728BF091}.Debug|x64.Deploy.0 = Debug|x64
+		{7932C973-B540-4E74-942D-0BF5728BF091}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{7932C973-B540-4E74-942D-0BF5728BF091}.Debug|ARM64.Build.0 = Debug|ARM64
+		{7932C973-B540-4E74-942D-0BF5728BF091}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{7932C973-B540-4E74-942D-0BF5728BF091}.Release|Win32.ActiveCfg = Release|Win32
+		{7932C973-B540-4E74-942D-0BF5728BF091}.Release|Win32.Build.0 = Release|Win32
+		{7932C973-B540-4E74-942D-0BF5728BF091}.Release|Win32.Deploy.0 = Release|Win32
+		{7932C973-B540-4E74-942D-0BF5728BF091}.Release|x64.ActiveCfg = Release|x64
+		{7932C973-B540-4E74-942D-0BF5728BF091}.Release|x64.Build.0 = Release|x64
+		{7932C973-B540-4E74-942D-0BF5728BF091}.Release|x64.Deploy.0 = Release|x64
+		{7932C973-B540-4E74-942D-0BF5728BF091}.Release|ARM64.ActiveCfg = Release|ARM64
+		{7932C973-B540-4E74-942D-0BF5728BF091}.Release|ARM64.Build.0 = Release|ARM64
+		{7932C973-B540-4E74-942D-0BF5728BF091}.Release|ARM64.Deploy.0 = Release|ARM64
+		{501C3C3D-8B4D-4EB2-9474-5463C68EA271}.Debug|Win32.ActiveCfg = Debug|Win32
+		{501C3C3D-8B4D-4EB2-9474-5463C68EA271}.Debug|Win32.Build.0 = Debug|Win32
+		{501C3C3D-8B4D-4EB2-9474-5463C68EA271}.Debug|Win32.Deploy.0 = Debug|Win32
+		{501C3C3D-8B4D-4EB2-9474-5463C68EA271}.Debug|x64.ActiveCfg = Debug|x64
+		{501C3C3D-8B4D-4EB2-9474-5463C68EA271}.Debug|x64.Build.0 = Debug|x64
+		{501C3C3D-8B4D-4EB2-9474-5463C68EA271}.Debug|x64.Deploy.0 = Debug|x64
+		{501C3C3D-8B4D-4EB2-9474-5463C68EA271}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{501C3C3D-8B4D-4EB2-9474-5463C68EA271}.Debug|ARM64.Build.0 = Debug|ARM64
+		{501C3C3D-8B4D-4EB2-9474-5463C68EA271}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{501C3C3D-8B4D-4EB2-9474-5463C68EA271}.Release|Win32.ActiveCfg = Release|Win32
+		{501C3C3D-8B4D-4EB2-9474-5463C68EA271}.Release|Win32.Build.0 = Release|Win32
+		{501C3C3D-8B4D-4EB2-9474-5463C68EA271}.Release|Win32.Deploy.0 = Release|Win32
+		{501C3C3D-8B4D-4EB2-9474-5463C68EA271}.Release|x64.ActiveCfg = Release|x64
+		{501C3C3D-8B4D-4EB2-9474-5463C68EA271}.Release|x64.Build.0 = Release|x64
+		{501C3C3D-8B4D-4EB2-9474-5463C68EA271}.Release|x64.Deploy.0 = Release|x64
+		{501C3C3D-8B4D-4EB2-9474-5463C68EA271}.Release|ARM64.ActiveCfg = Release|ARM64
+		{501C3C3D-8B4D-4EB2-9474-5463C68EA271}.Release|ARM64.Build.0 = Release|ARM64
+		{501C3C3D-8B4D-4EB2-9474-5463C68EA271}.Release|ARM64.Deploy.0 = Release|ARM64
+		{D26E9EEF-F930-451B-8358-B4E961C2A15F}.Debug|Win32.ActiveCfg = Debug|Win32
+		{D26E9EEF-F930-451B-8358-B4E961C2A15F}.Debug|Win32.Build.0 = Debug|Win32
+		{D26E9EEF-F930-451B-8358-B4E961C2A15F}.Debug|Win32.Deploy.0 = Debug|Win32
+		{D26E9EEF-F930-451B-8358-B4E961C2A15F}.Debug|x64.ActiveCfg = Debug|x64
+		{D26E9EEF-F930-451B-8358-B4E961C2A15F}.Debug|x64.Build.0 = Debug|x64
+		{D26E9EEF-F930-451B-8358-B4E961C2A15F}.Debug|x64.Deploy.0 = Debug|x64
+		{D26E9EEF-F930-451B-8358-B4E961C2A15F}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{D26E9EEF-F930-451B-8358-B4E961C2A15F}.Debug|ARM64.Build.0 = Debug|ARM64
+		{D26E9EEF-F930-451B-8358-B4E961C2A15F}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{D26E9EEF-F930-451B-8358-B4E961C2A15F}.Release|Win32.ActiveCfg = Release|Win32
+		{D26E9EEF-F930-451B-8358-B4E961C2A15F}.Release|Win32.Build.0 = Release|Win32
+		{D26E9EEF-F930-451B-8358-B4E961C2A15F}.Release|Win32.Deploy.0 = Release|Win32
+		{D26E9EEF-F930-451B-8358-B4E961C2A15F}.Release|x64.ActiveCfg = Release|x64
+		{D26E9EEF-F930-451B-8358-B4E961C2A15F}.Release|x64.Build.0 = Release|x64
+		{D26E9EEF-F930-451B-8358-B4E961C2A15F}.Release|x64.Deploy.0 = Release|x64
+		{D26E9EEF-F930-451B-8358-B4E961C2A15F}.Release|ARM64.ActiveCfg = Release|ARM64
+		{D26E9EEF-F930-451B-8358-B4E961C2A15F}.Release|ARM64.Build.0 = Release|ARM64
+		{D26E9EEF-F930-451B-8358-B4E961C2A15F}.Release|ARM64.Deploy.0 = Release|ARM64
+		{8C976B7E-7365-4BBF-9685-B5F19A07E44F}.Debug|Win32.ActiveCfg = Debug|Win32
+		{8C976B7E-7365-4BBF-9685-B5F19A07E44F}.Debug|Win32.Build.0 = Debug|Win32
+		{8C976B7E-7365-4BBF-9685-B5F19A07E44F}.Debug|Win32.Deploy.0 = Debug|Win32
+		{8C976B7E-7365-4BBF-9685-B5F19A07E44F}.Debug|x64.ActiveCfg = Debug|x64
+		{8C976B7E-7365-4BBF-9685-B5F19A07E44F}.Debug|x64.Build.0 = Debug|x64
+		{8C976B7E-7365-4BBF-9685-B5F19A07E44F}.Debug|x64.Deploy.0 = Debug|x64
+		{8C976B7E-7365-4BBF-9685-B5F19A07E44F}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{8C976B7E-7365-4BBF-9685-B5F19A07E44F}.Debug|ARM64.Build.0 = Debug|ARM64
+		{8C976B7E-7365-4BBF-9685-B5F19A07E44F}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{8C976B7E-7365-4BBF-9685-B5F19A07E44F}.Release|Win32.ActiveCfg = Release|Win32
+		{8C976B7E-7365-4BBF-9685-B5F19A07E44F}.Release|Win32.Build.0 = Release|Win32
+		{8C976B7E-7365-4BBF-9685-B5F19A07E44F}.Release|Win32.Deploy.0 = Release|Win32
+		{8C976B7E-7365-4BBF-9685-B5F19A07E44F}.Release|x64.ActiveCfg = Release|x64
+		{8C976B7E-7365-4BBF-9685-B5F19A07E44F}.Release|x64.Build.0 = Release|x64
+		{8C976B7E-7365-4BBF-9685-B5F19A07E44F}.Release|x64.Deploy.0 = Release|x64
+		{8C976B7E-7365-4BBF-9685-B5F19A07E44F}.Release|ARM64.ActiveCfg = Release|ARM64
+		{8C976B7E-7365-4BBF-9685-B5F19A07E44F}.Release|ARM64.Build.0 = Release|ARM64
+		{8C976B7E-7365-4BBF-9685-B5F19A07E44F}.Release|ARM64.Deploy.0 = Release|ARM64
+		{E8C07E07-E0FE-4357-A1C2-DBFB0D87E3F3}.Debug|Win32.ActiveCfg = Debug|Win32
+		{E8C07E07-E0FE-4357-A1C2-DBFB0D87E3F3}.Debug|Win32.Build.0 = Debug|Win32
+		{E8C07E07-E0FE-4357-A1C2-DBFB0D87E3F3}.Debug|Win32.Deploy.0 = Debug|Win32
+		{E8C07E07-E0FE-4357-A1C2-DBFB0D87E3F3}.Debug|x64.ActiveCfg = Debug|x64
+		{E8C07E07-E0FE-4357-A1C2-DBFB0D87E3F3}.Debug|x64.Build.0 = Debug|x64
+		{E8C07E07-E0FE-4357-A1C2-DBFB0D87E3F3}.Debug|x64.Deploy.0 = Debug|x64
+		{E8C07E07-E0FE-4357-A1C2-DBFB0D87E3F3}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{E8C07E07-E0FE-4357-A1C2-DBFB0D87E3F3}.Debug|ARM64.Build.0 = Debug|ARM64
+		{E8C07E07-E0FE-4357-A1C2-DBFB0D87E3F3}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{E8C07E07-E0FE-4357-A1C2-DBFB0D87E3F3}.Release|Win32.ActiveCfg = Release|Win32
+		{E8C07E07-E0FE-4357-A1C2-DBFB0D87E3F3}.Release|Win32.Build.0 = Release|Win32
+		{E8C07E07-E0FE-4357-A1C2-DBFB0D87E3F3}.Release|Win32.Deploy.0 = Release|Win32
+		{E8C07E07-E0FE-4357-A1C2-DBFB0D87E3F3}.Release|x64.ActiveCfg = Release|x64
+		{E8C07E07-E0FE-4357-A1C2-DBFB0D87E3F3}.Release|x64.Build.0 = Release|x64
+		{E8C07E07-E0FE-4357-A1C2-DBFB0D87E3F3}.Release|x64.Deploy.0 = Release|x64
+		{E8C07E07-E0FE-4357-A1C2-DBFB0D87E3F3}.Release|ARM64.ActiveCfg = Release|ARM64
+		{E8C07E07-E0FE-4357-A1C2-DBFB0D87E3F3}.Release|ARM64.Build.0 = Release|ARM64
+		{E8C07E07-E0FE-4357-A1C2-DBFB0D87E3F3}.Release|ARM64.Deploy.0 = Release|ARM64
+		{85132E7A-73F1-4A05-A483-B7313EAB5213}.Debug|Win32.ActiveCfg = Debug|Win32
+		{85132E7A-73F1-4A05-A483-B7313EAB5213}.Debug|Win32.Build.0 = Debug|Win32
+		{85132E7A-73F1-4A05-A483-B7313EAB5213}.Debug|Win32.Deploy.0 = Debug|Win32
+		{85132E7A-73F1-4A05-A483-B7313EAB5213}.Debug|x64.ActiveCfg = Debug|x64
+		{85132E7A-73F1-4A05-A483-B7313EAB5213}.Debug|x64.Build.0 = Debug|x64
+		{85132E7A-73F1-4A05-A483-B7313EAB5213}.Debug|x64.Deploy.0 = Debug|x64
+		{85132E7A-73F1-4A05-A483-B7313EAB5213}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{85132E7A-73F1-4A05-A483-B7313EAB5213}.Debug|ARM64.Build.0 = Debug|ARM64
+		{85132E7A-73F1-4A05-A483-B7313EAB5213}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{85132E7A-73F1-4A05-A483-B7313EAB5213}.Release|Win32.ActiveCfg = Release|Win32
+		{85132E7A-73F1-4A05-A483-B7313EAB5213}.Release|Win32.Build.0 = Release|Win32
+		{85132E7A-73F1-4A05-A483-B7313EAB5213}.Release|Win32.Deploy.0 = Release|Win32
+		{85132E7A-73F1-4A05-A483-B7313EAB5213}.Release|x64.ActiveCfg = Release|x64
+		{85132E7A-73F1-4A05-A483-B7313EAB5213}.Release|x64.Build.0 = Release|x64
+		{85132E7A-73F1-4A05-A483-B7313EAB5213}.Release|x64.Deploy.0 = Release|x64
+		{85132E7A-73F1-4A05-A483-B7313EAB5213}.Release|ARM64.ActiveCfg = Release|ARM64
+		{85132E7A-73F1-4A05-A483-B7313EAB5213}.Release|ARM64.Build.0 = Release|ARM64
+		{85132E7A-73F1-4A05-A483-B7313EAB5213}.Release|ARM64.Deploy.0 = Release|ARM64
+		{D9EB1955-6B94-4104-B575-F49E58C41950}.Debug|Win32.ActiveCfg = Debug|Win32
+		{D9EB1955-6B94-4104-B575-F49E58C41950}.Debug|Win32.Build.0 = Debug|Win32
+		{D9EB1955-6B94-4104-B575-F49E58C41950}.Debug|Win32.Deploy.0 = Debug|Win32
+		{D9EB1955-6B94-4104-B575-F49E58C41950}.Debug|x64.ActiveCfg = Debug|x64
+		{D9EB1955-6B94-4104-B575-F49E58C41950}.Debug|x64.Build.0 = Debug|x64
+		{D9EB1955-6B94-4104-B575-F49E58C41950}.Debug|x64.Deploy.0 = Debug|x64
+		{D9EB1955-6B94-4104-B575-F49E58C41950}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{D9EB1955-6B94-4104-B575-F49E58C41950}.Debug|ARM64.Build.0 = Debug|ARM64
+		{D9EB1955-6B94-4104-B575-F49E58C41950}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{D9EB1955-6B94-4104-B575-F49E58C41950}.Release|Win32.ActiveCfg = Release|Win32
+		{D9EB1955-6B94-4104-B575-F49E58C41950}.Release|Win32.Build.0 = Release|Win32
+		{D9EB1955-6B94-4104-B575-F49E58C41950}.Release|Win32.Deploy.0 = Release|Win32
+		{D9EB1955-6B94-4104-B575-F49E58C41950}.Release|x64.ActiveCfg = Release|x64
+		{D9EB1955-6B94-4104-B575-F49E58C41950}.Release|x64.Build.0 = Release|x64
+		{D9EB1955-6B94-4104-B575-F49E58C41950}.Release|x64.Deploy.0 = Release|x64
+		{D9EB1955-6B94-4104-B575-F49E58C41950}.Release|ARM64.ActiveCfg = Release|ARM64
+		{D9EB1955-6B94-4104-B575-F49E58C41950}.Release|ARM64.Build.0 = Release|ARM64
+		{D9EB1955-6B94-4104-B575-F49E58C41950}.Release|ARM64.Deploy.0 = Release|ARM64
+		{86B8B44F-5D74-41B8-BADD-27D0E4CC1133}.Debug|Win32.ActiveCfg = Debug|Win32
+		{86B8B44F-5D74-41B8-BADD-27D0E4CC1133}.Debug|Win32.Build.0 = Debug|Win32
+		{86B8B44F-5D74-41B8-BADD-27D0E4CC1133}.Debug|Win32.Deploy.0 = Debug|Win32
+		{86B8B44F-5D74-41B8-BADD-27D0E4CC1133}.Debug|x64.ActiveCfg = Debug|x64
+		{86B8B44F-5D74-41B8-BADD-27D0E4CC1133}.Debug|x64.Build.0 = Debug|x64
+		{86B8B44F-5D74-41B8-BADD-27D0E4CC1133}.Debug|x64.Deploy.0 = Debug|x64
+		{86B8B44F-5D74-41B8-BADD-27D0E4CC1133}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{86B8B44F-5D74-41B8-BADD-27D0E4CC1133}.Debug|ARM64.Build.0 = Debug|ARM64
+		{86B8B44F-5D74-41B8-BADD-27D0E4CC1133}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{86B8B44F-5D74-41B8-BADD-27D0E4CC1133}.Release|Win32.ActiveCfg = Release|Win32
+		{86B8B44F-5D74-41B8-BADD-27D0E4CC1133}.Release|Win32.Build.0 = Release|Win32
+		{86B8B44F-5D74-41B8-BADD-27D0E4CC1133}.Release|Win32.Deploy.0 = Release|Win32
+		{86B8B44F-5D74-41B8-BADD-27D0E4CC1133}.Release|x64.ActiveCfg = Release|x64
+		{86B8B44F-5D74-41B8-BADD-27D0E4CC1133}.Release|x64.Build.0 = Release|x64
+		{86B8B44F-5D74-41B8-BADD-27D0E4CC1133}.Release|x64.Deploy.0 = Release|x64
+		{86B8B44F-5D74-41B8-BADD-27D0E4CC1133}.Release|ARM64.ActiveCfg = Release|ARM64
+		{86B8B44F-5D74-41B8-BADD-27D0E4CC1133}.Release|ARM64.Build.0 = Release|ARM64
+		{86B8B44F-5D74-41B8-BADD-27D0E4CC1133}.Release|ARM64.Deploy.0 = Release|ARM64
+		{47B4FD36-0DC7-4696-9130-C06BB6AE7A33}.Debug|Win32.ActiveCfg = Debug|Win32
+		{47B4FD36-0DC7-4696-9130-C06BB6AE7A33}.Debug|Win32.Build.0 = Debug|Win32
+		{47B4FD36-0DC7-4696-9130-C06BB6AE7A33}.Debug|Win32.Deploy.0 = Debug|Win32
+		{47B4FD36-0DC7-4696-9130-C06BB6AE7A33}.Debug|x64.ActiveCfg = Debug|x64
+		{47B4FD36-0DC7-4696-9130-C06BB6AE7A33}.Debug|x64.Build.0 = Debug|x64
+		{47B4FD36-0DC7-4696-9130-C06BB6AE7A33}.Debug|x64.Deploy.0 = Debug|x64
+		{47B4FD36-0DC7-4696-9130-C06BB6AE7A33}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{47B4FD36-0DC7-4696-9130-C06BB6AE7A33}.Debug|ARM64.Build.0 = Debug|ARM64
+		{47B4FD36-0DC7-4696-9130-C06BB6AE7A33}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{47B4FD36-0DC7-4696-9130-C06BB6AE7A33}.Release|Win32.ActiveCfg = Release|Win32
+		{47B4FD36-0DC7-4696-9130-C06BB6AE7A33}.Release|Win32.Build.0 = Release|Win32
+		{47B4FD36-0DC7-4696-9130-C06BB6AE7A33}.Release|Win32.Deploy.0 = Release|Win32
+		{47B4FD36-0DC7-4696-9130-C06BB6AE7A33}.Release|x64.ActiveCfg = Release|x64
+		{47B4FD36-0DC7-4696-9130-C06BB6AE7A33}.Release|x64.Build.0 = Release|x64
+		{47B4FD36-0DC7-4696-9130-C06BB6AE7A33}.Release|x64.Deploy.0 = Release|x64
+		{47B4FD36-0DC7-4696-9130-C06BB6AE7A33}.Release|ARM64.ActiveCfg = Release|ARM64
+		{47B4FD36-0DC7-4696-9130-C06BB6AE7A33}.Release|ARM64.Build.0 = Release|ARM64
+		{47B4FD36-0DC7-4696-9130-C06BB6AE7A33}.Release|ARM64.Deploy.0 = Release|ARM64
+		{3904C036-87C3-4926-8CF3-09044A309655}.Debug|Win32.ActiveCfg = Debug|Win32
+		{3904C036-87C3-4926-8CF3-09044A309655}.Debug|Win32.Build.0 = Debug|Win32
+		{3904C036-87C3-4926-8CF3-09044A309655}.Debug|Win32.Deploy.0 = Debug|Win32
+		{3904C036-87C3-4926-8CF3-09044A309655}.Debug|x64.ActiveCfg = Debug|x64
+		{3904C036-87C3-4926-8CF3-09044A309655}.Debug|x64.Build.0 = Debug|x64
+		{3904C036-87C3-4926-8CF3-09044A309655}.Debug|x64.Deploy.0 = Debug|x64
+		{3904C036-87C3-4926-8CF3-09044A309655}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{3904C036-87C3-4926-8CF3-09044A309655}.Debug|ARM64.Build.0 = Debug|ARM64
+		{3904C036-87C3-4926-8CF3-09044A309655}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{3904C036-87C3-4926-8CF3-09044A309655}.Release|Win32.ActiveCfg = Release|Win32
+		{3904C036-87C3-4926-8CF3-09044A309655}.Release|Win32.Build.0 = Release|Win32
+		{3904C036-87C3-4926-8CF3-09044A309655}.Release|Win32.Deploy.0 = Release|Win32
+		{3904C036-87C3-4926-8CF3-09044A309655}.Release|x64.ActiveCfg = Release|x64
+		{3904C036-87C3-4926-8CF3-09044A309655}.Release|x64.Build.0 = Release|x64
+		{3904C036-87C3-4926-8CF3-09044A309655}.Release|x64.Deploy.0 = Release|x64
+		{3904C036-87C3-4926-8CF3-09044A309655}.Release|ARM64.ActiveCfg = Release|ARM64
+		{3904C036-87C3-4926-8CF3-09044A309655}.Release|ARM64.Build.0 = Release|ARM64
+		{3904C036-87C3-4926-8CF3-09044A309655}.Release|ARM64.Deploy.0 = Release|ARM64
+		{28C809E6-BCD2-4828-93B2-151A21C6DF5C}.Debug|Win32.ActiveCfg = Debug|Win32
+		{28C809E6-BCD2-4828-93B2-151A21C6DF5C}.Debug|Win32.Build.0 = Debug|Win32
+		{28C809E6-BCD2-4828-93B2-151A21C6DF5C}.Debug|Win32.Deploy.0 = Debug|Win32
+		{28C809E6-BCD2-4828-93B2-151A21C6DF5C}.Debug|x64.ActiveCfg = Debug|x64
+		{28C809E6-BCD2-4828-93B2-151A21C6DF5C}.Debug|x64.Build.0 = Debug|x64
+		{28C809E6-BCD2-4828-93B2-151A21C6DF5C}.Debug|x64.Deploy.0 = Debug|x64
+		{28C809E6-BCD2-4828-93B2-151A21C6DF5C}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{28C809E6-BCD2-4828-93B2-151A21C6DF5C}.Debug|ARM64.Build.0 = Debug|ARM64
+		{28C809E6-BCD2-4828-93B2-151A21C6DF5C}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{28C809E6-BCD2-4828-93B2-151A21C6DF5C}.Release|Win32.ActiveCfg = Release|Win32
+		{28C809E6-BCD2-4828-93B2-151A21C6DF5C}.Release|Win32.Build.0 = Release|Win32
+		{28C809E6-BCD2-4828-93B2-151A21C6DF5C}.Release|Win32.Deploy.0 = Release|Win32
+		{28C809E6-BCD2-4828-93B2-151A21C6DF5C}.Release|x64.ActiveCfg = Release|x64
+		{28C809E6-BCD2-4828-93B2-151A21C6DF5C}.Release|x64.Build.0 = Release|x64
+		{28C809E6-BCD2-4828-93B2-151A21C6DF5C}.Release|x64.Deploy.0 = Release|x64
+		{28C809E6-BCD2-4828-93B2-151A21C6DF5C}.Release|ARM64.ActiveCfg = Release|ARM64
+		{28C809E6-BCD2-4828-93B2-151A21C6DF5C}.Release|ARM64.Build.0 = Release|ARM64
+		{28C809E6-BCD2-4828-93B2-151A21C6DF5C}.Release|ARM64.Deploy.0 = Release|ARM64
+		{5633D9E2-14D5-4CC2-B955-5BFB1305755D}.Debug|Win32.ActiveCfg = Debug|Win32
+		{5633D9E2-14D5-4CC2-B955-5BFB1305755D}.Debug|Win32.Build.0 = Debug|Win32
+		{5633D9E2-14D5-4CC2-B955-5BFB1305755D}.Debug|Win32.Deploy.0 = Debug|Win32
+		{5633D9E2-14D5-4CC2-B955-5BFB1305755D}.Debug|x64.ActiveCfg = Debug|x64
+		{5633D9E2-14D5-4CC2-B955-5BFB1305755D}.Debug|x64.Build.0 = Debug|x64
+		{5633D9E2-14D5-4CC2-B955-5BFB1305755D}.Debug|x64.Deploy.0 = Debug|x64
+		{5633D9E2-14D5-4CC2-B955-5BFB1305755D}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{5633D9E2-14D5-4CC2-B955-5BFB1305755D}.Debug|ARM64.Build.0 = Debug|ARM64
+		{5633D9E2-14D5-4CC2-B955-5BFB1305755D}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{5633D9E2-14D5-4CC2-B955-5BFB1305755D}.Release|Win32.ActiveCfg = Release|Win32
+		{5633D9E2-14D5-4CC2-B955-5BFB1305755D}.Release|Win32.Build.0 = Release|Win32
+		{5633D9E2-14D5-4CC2-B955-5BFB1305755D}.Release|Win32.Deploy.0 = Release|Win32
+		{5633D9E2-14D5-4CC2-B955-5BFB1305755D}.Release|x64.ActiveCfg = Release|x64
+		{5633D9E2-14D5-4CC2-B955-5BFB1305755D}.Release|x64.Build.0 = Release|x64
+		{5633D9E2-14D5-4CC2-B955-5BFB1305755D}.Release|x64.Deploy.0 = Release|x64
+		{5633D9E2-14D5-4CC2-B955-5BFB1305755D}.Release|ARM64.ActiveCfg = Release|ARM64
+		{5633D9E2-14D5-4CC2-B955-5BFB1305755D}.Release|ARM64.Build.0 = Release|ARM64
+		{5633D9E2-14D5-4CC2-B955-5BFB1305755D}.Release|ARM64.Deploy.0 = Release|ARM64
+		{551E887A-BDCF-4260-8FD6-167E5D50F3EC}.Debug|Win32.ActiveCfg = Debug|Win32
+		{551E887A-BDCF-4260-8FD6-167E5D50F3EC}.Debug|Win32.Build.0 = Debug|Win32
+		{551E887A-BDCF-4260-8FD6-167E5D50F3EC}.Debug|Win32.Deploy.0 = Debug|Win32
+		{551E887A-BDCF-4260-8FD6-167E5D50F3EC}.Debug|x64.ActiveCfg = Debug|x64
+		{551E887A-BDCF-4260-8FD6-167E5D50F3EC}.Debug|x64.Build.0 = Debug|x64
+		{551E887A-BDCF-4260-8FD6-167E5D50F3EC}.Debug|x64.Deploy.0 = Debug|x64
+		{551E887A-BDCF-4260-8FD6-167E5D50F3EC}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{551E887A-BDCF-4260-8FD6-167E5D50F3EC}.Debug|ARM64.Build.0 = Debug|ARM64
+		{551E887A-BDCF-4260-8FD6-167E5D50F3EC}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{551E887A-BDCF-4260-8FD6-167E5D50F3EC}.Release|Win32.ActiveCfg = Release|Win32
+		{551E887A-BDCF-4260-8FD6-167E5D50F3EC}.Release|Win32.Build.0 = Release|Win32
+		{551E887A-BDCF-4260-8FD6-167E5D50F3EC}.Release|Win32.Deploy.0 = Release|Win32
+		{551E887A-BDCF-4260-8FD6-167E5D50F3EC}.Release|x64.ActiveCfg = Release|x64
+		{551E887A-BDCF-4260-8FD6-167E5D50F3EC}.Release|x64.Build.0 = Release|x64
+		{551E887A-BDCF-4260-8FD6-167E5D50F3EC}.Release|x64.Deploy.0 = Release|x64
+		{551E887A-BDCF-4260-8FD6-167E5D50F3EC}.Release|ARM64.ActiveCfg = Release|ARM64
+		{551E887A-BDCF-4260-8FD6-167E5D50F3EC}.Release|ARM64.Build.0 = Release|ARM64
+		{551E887A-BDCF-4260-8FD6-167E5D50F3EC}.Release|ARM64.Deploy.0 = Release|ARM64
+		{A32E6CB7-4CDC-4C96-BBA7-6C1393C1B2DB}.Debug|Win32.ActiveCfg = Debug|Win32
+		{A32E6CB7-4CDC-4C96-BBA7-6C1393C1B2DB}.Debug|Win32.Build.0 = Debug|Win32
+		{A32E6CB7-4CDC-4C96-BBA7-6C1393C1B2DB}.Debug|Win32.Deploy.0 = Debug|Win32
+		{A32E6CB7-4CDC-4C96-BBA7-6C1393C1B2DB}.Debug|x64.ActiveCfg = Debug|x64
+		{A32E6CB7-4CDC-4C96-BBA7-6C1393C1B2DB}.Debug|x64.Build.0 = Debug|x64
+		{A32E6CB7-4CDC-4C96-BBA7-6C1393C1B2DB}.Debug|x64.Deploy.0 = Debug|x64
+		{A32E6CB7-4CDC-4C96-BBA7-6C1393C1B2DB}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{A32E6CB7-4CDC-4C96-BBA7-6C1393C1B2DB}.Debug|ARM64.Build.0 = Debug|ARM64
+		{A32E6CB7-4CDC-4C96-BBA7-6C1393C1B2DB}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{A32E6CB7-4CDC-4C96-BBA7-6C1393C1B2DB}.Release|Win32.ActiveCfg = Release|Win32
+		{A32E6CB7-4CDC-4C96-BBA7-6C1393C1B2DB}.Release|Win32.Build.0 = Release|Win32
+		{A32E6CB7-4CDC-4C96-BBA7-6C1393C1B2DB}.Release|Win32.Deploy.0 = Release|Win32
+		{A32E6CB7-4CDC-4C96-BBA7-6C1393C1B2DB}.Release|x64.ActiveCfg = Release|x64
+		{A32E6CB7-4CDC-4C96-BBA7-6C1393C1B2DB}.Release|x64.Build.0 = Release|x64
+		{A32E6CB7-4CDC-4C96-BBA7-6C1393C1B2DB}.Release|x64.Deploy.0 = Release|x64
+		{A32E6CB7-4CDC-4C96-BBA7-6C1393C1B2DB}.Release|ARM64.ActiveCfg = Release|ARM64
+		{A32E6CB7-4CDC-4C96-BBA7-6C1393C1B2DB}.Release|ARM64.Build.0 = Release|ARM64
+		{A32E6CB7-4CDC-4C96-BBA7-6C1393C1B2DB}.Release|ARM64.Deploy.0 = Release|ARM64
+		{2842107C-FC3A-4CAD-84BC-A9C5B720D92C}.Debug|Win32.ActiveCfg = Debug|Win32
+		{2842107C-FC3A-4CAD-84BC-A9C5B720D92C}.Debug|Win32.Build.0 = Debug|Win32
+		{2842107C-FC3A-4CAD-84BC-A9C5B720D92C}.Debug|Win32.Deploy.0 = Debug|Win32
+		{2842107C-FC3A-4CAD-84BC-A9C5B720D92C}.Debug|x64.ActiveCfg = Debug|x64
+		{2842107C-FC3A-4CAD-84BC-A9C5B720D92C}.Debug|x64.Build.0 = Debug|x64
+		{2842107C-FC3A-4CAD-84BC-A9C5B720D92C}.Debug|x64.Deploy.0 = Debug|x64
+		{2842107C-FC3A-4CAD-84BC-A9C5B720D92C}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{2842107C-FC3A-4CAD-84BC-A9C5B720D92C}.Debug|ARM64.Build.0 = Debug|ARM64
+		{2842107C-FC3A-4CAD-84BC-A9C5B720D92C}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{2842107C-FC3A-4CAD-84BC-A9C5B720D92C}.Release|Win32.ActiveCfg = Release|Win32
+		{2842107C-FC3A-4CAD-84BC-A9C5B720D92C}.Release|Win32.Build.0 = Release|Win32
+		{2842107C-FC3A-4CAD-84BC-A9C5B720D92C}.Release|Win32.Deploy.0 = Release|Win32
+		{2842107C-FC3A-4CAD-84BC-A9C5B720D92C}.Release|x64.ActiveCfg = Release|x64
+		{2842107C-FC3A-4CAD-84BC-A9C5B720D92C}.Release|x64.Build.0 = Release|x64
+		{2842107C-FC3A-4CAD-84BC-A9C5B720D92C}.Release|x64.Deploy.0 = Release|x64
+		{2842107C-FC3A-4CAD-84BC-A9C5B720D92C}.Release|ARM64.ActiveCfg = Release|ARM64
+		{2842107C-FC3A-4CAD-84BC-A9C5B720D92C}.Release|ARM64.Build.0 = Release|ARM64
+		{2842107C-FC3A-4CAD-84BC-A9C5B720D92C}.Release|ARM64.Deploy.0 = Release|ARM64
+		{886B5D10-5CC4-4292-A764-8EB1D3C66D44}.Debug|Win32.ActiveCfg = Debug|Win32
+		{886B5D10-5CC4-4292-A764-8EB1D3C66D44}.Debug|Win32.Build.0 = Debug|Win32
+		{886B5D10-5CC4-4292-A764-8EB1D3C66D44}.Debug|Win32.Deploy.0 = Debug|Win32
+		{886B5D10-5CC4-4292-A764-8EB1D3C66D44}.Debug|x64.ActiveCfg = Debug|x64
+		{886B5D10-5CC4-4292-A764-8EB1D3C66D44}.Debug|x64.Build.0 = Debug|x64
+		{886B5D10-5CC4-4292-A764-8EB1D3C66D44}.Debug|x64.Deploy.0 = Debug|x64
+		{886B5D10-5CC4-4292-A764-8EB1D3C66D44}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{886B5D10-5CC4-4292-A764-8EB1D3C66D44}.Debug|ARM64.Build.0 = Debug|ARM64
+		{886B5D10-5CC4-4292-A764-8EB1D3C66D44}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{886B5D10-5CC4-4292-A764-8EB1D3C66D44}.Release|Win32.ActiveCfg = Release|Win32
+		{886B5D10-5CC4-4292-A764-8EB1D3C66D44}.Release|Win32.Build.0 = Release|Win32
+		{886B5D10-5CC4-4292-A764-8EB1D3C66D44}.Release|Win32.Deploy.0 = Release|Win32
+		{886B5D10-5CC4-4292-A764-8EB1D3C66D44}.Release|x64.ActiveCfg = Release|x64
+		{886B5D10-5CC4-4292-A764-8EB1D3C66D44}.Release|x64.Build.0 = Release|x64
+		{886B5D10-5CC4-4292-A764-8EB1D3C66D44}.Release|x64.Deploy.0 = Release|x64
+		{886B5D10-5CC4-4292-A764-8EB1D3C66D44}.Release|ARM64.ActiveCfg = Release|ARM64
+		{886B5D10-5CC4-4292-A764-8EB1D3C66D44}.Release|ARM64.Build.0 = Release|ARM64
+		{886B5D10-5CC4-4292-A764-8EB1D3C66D44}.Release|ARM64.Deploy.0 = Release|ARM64
+		{D356A850-2D79-47D2-A914-34A2913E3D0B}.Debug|Win32.ActiveCfg = Debug|Win32
+		{D356A850-2D79-47D2-A914-34A2913E3D0B}.Debug|Win32.Build.0 = Debug|Win32
+		{D356A850-2D79-47D2-A914-34A2913E3D0B}.Debug|Win32.Deploy.0 = Debug|Win32
+		{D356A850-2D79-47D2-A914-34A2913E3D0B}.Debug|x64.ActiveCfg = Debug|x64
+		{D356A850-2D79-47D2-A914-34A2913E3D0B}.Debug|x64.Build.0 = Debug|x64
+		{D356A850-2D79-47D2-A914-34A2913E3D0B}.Debug|x64.Deploy.0 = Debug|x64
+		{D356A850-2D79-47D2-A914-34A2913E3D0B}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{D356A850-2D79-47D2-A914-34A2913E3D0B}.Debug|ARM64.Build.0 = Debug|ARM64
+		{D356A850-2D79-47D2-A914-34A2913E3D0B}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{D356A850-2D79-47D2-A914-34A2913E3D0B}.Release|Win32.ActiveCfg = Release|Win32
+		{D356A850-2D79-47D2-A914-34A2913E3D0B}.Release|Win32.Build.0 = Release|Win32
+		{D356A850-2D79-47D2-A914-34A2913E3D0B}.Release|Win32.Deploy.0 = Release|Win32
+		{D356A850-2D79-47D2-A914-34A2913E3D0B}.Release|x64.ActiveCfg = Release|x64
+		{D356A850-2D79-47D2-A914-34A2913E3D0B}.Release|x64.Build.0 = Release|x64
+		{D356A850-2D79-47D2-A914-34A2913E3D0B}.Release|x64.Deploy.0 = Release|x64
+		{D356A850-2D79-47D2-A914-34A2913E3D0B}.Release|ARM64.ActiveCfg = Release|ARM64
+		{D356A850-2D79-47D2-A914-34A2913E3D0B}.Release|ARM64.Build.0 = Release|ARM64
+		{D356A850-2D79-47D2-A914-34A2913E3D0B}.Release|ARM64.Deploy.0 = Release|ARM64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

SimpleGame/FMOD/api/core/examples/vs2017/fmod_codec_raw.vcxproj

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+    <Suffix Condition="'$(Platform)'=='x64'">$(Suffix)64</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{5633D9E2-14D5-4CC2-B955-5BFB1305755D}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary Condition="'$(Configuration)'=='Release'">MultiThreaded</RuntimeLibrary>
+      <RuntimeLibrary Condition="'$(Configuration)'=='Debug'">MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\plugins\fmod_codec_raw.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/fmod_distance_filter.vcxproj

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+    <Suffix Condition="'$(Platform)'=='x64'">$(Suffix)64</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{551E887A-BDCF-4260-8FD6-167E5D50F3EC}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary Condition="'$(Configuration)'=='Release'">MultiThreaded</RuntimeLibrary>
+      <RuntimeLibrary Condition="'$(Configuration)'=='Debug'">MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\plugins\fmod_distance_filter.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/fmod_gain.vcxproj

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+    <Suffix Condition="'$(Platform)'=='x64'">$(Suffix)64</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{A32E6CB7-4CDC-4C96-BBA7-6C1393C1B2DB}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary Condition="'$(Configuration)'=='Release'">MultiThreaded</RuntimeLibrary>
+      <RuntimeLibrary Condition="'$(Configuration)'=='Debug'">MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\plugins\fmod_gain.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/fmod_noise.vcxproj

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+    <Suffix Condition="'$(Platform)'=='x64'">$(Suffix)64</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{2842107C-FC3A-4CAD-84BC-A9C5B720D92C}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary Condition="'$(Configuration)'=='Release'">MultiThreaded</RuntimeLibrary>
+      <RuntimeLibrary Condition="'$(Configuration)'=='Debug'">MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\plugins\fmod_noise.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/fmod_rnbo.vcxproj

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+    <Suffix Condition="'$(Platform)'=='x64'">$(Suffix)64</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{886B5D10-5CC4-4292-A764-8EB1D3C66D44}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary Condition="'$(Configuration)'=='Release'">MultiThreaded</RuntimeLibrary>
+      <RuntimeLibrary Condition="'$(Configuration)'=='Debug'">MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\plugins\fmod_rnbo.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/gapless_playback.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{38EDE105-ED40-416E-8B3F-D68485441AA8}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\gapless_playback.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/gapless_playback.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/generate_tone.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{7932C973-B540-4E74-942D-0BF5728BF091}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\generate_tone.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/generate_tone.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/granular_synth.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{501C3C3D-8B4D-4EB2-9474-5463C68EA271}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\granular_synth.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/granular_synth.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/load_from_memory.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{D26E9EEF-F930-451B-8358-B4E961C2A15F}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\load_from_memory.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/load_from_memory.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/multiple_speaker.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{8C976B7E-7365-4BBF-9685-B5F19A07E44F}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\multiple_speaker.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/multiple_speaker.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/multiple_system.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{E8C07E07-E0FE-4357-A1C2-DBFB0D87E3F3}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\multiple_system.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/multiple_system.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/net_stream.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{85132E7A-73F1-4A05-A483-B7313EAB5213}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\net_stream.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/net_stream.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/output_mp3.vcxproj

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+    <Suffix Condition="'$(Platform)'=='x64'">$(Suffix)64</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{D356A850-2D79-47D2-A914-34A2913E3D0B}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary Condition="'$(Configuration)'=='Release'">MultiThreaded</RuntimeLibrary>
+      <RuntimeLibrary Condition="'$(Configuration)'=='Debug'">MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\plugins\output_mp3.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/play_sound.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{D9EB1955-6B94-4104-B575-F49E58C41950}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\play_sound.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/play_sound.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/play_stream.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{86B8B44F-5D74-41B8-BADD-27D0E4CC1133}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\play_stream.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/play_stream.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/record.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{47B4FD36-0DC7-4696-9130-C06BB6AE7A33}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\record.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/record.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/record_enumeration.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{3904C036-87C3-4926-8CF3-09044A309655}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\record_enumeration.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/record_enumeration.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/user_created_sound.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{28C809E6-BCD2-4828-93B2-151A21C6DF5C}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v141</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\user_created_sound.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2017/user_created_sound.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2019/3d.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{F53FDB54-D284-42FB-BCB0-B67061A91AAF}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v142</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\3d.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2019/3d.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2019/asyncio.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{2C84C4FB-3C48-4861-B92E-CA539B2E1E72}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v142</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\asyncio.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

SimpleGame/FMOD/api/core/examples/vs2019/asyncio.vcxproj.filters

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\common.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common_platform.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{937abb1b-0123-4875-9828-07ed9f9813e3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common_platform.h">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common.h">
+      <Filter>common</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

SimpleGame/FMOD/api/core/examples/vs2019/channel_groups.vcxproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <Arch>x86</Arch>
+    <Arch Condition="'$(Platform)'=='x64'">x64</Arch>
+    <Arch Condition="'$(Platform)'=='ARM64'">ARM64</Arch>
+    <Suffix Condition="'$(Configuration)'=='Debug'">L</Suffix>
+  </PropertyGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{930D8C68-154E-4064-B04D-120A338E2FBD}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset>v142</PlatformToolset>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(SolutionDir)_builds\$(ProjectName)\$(Configuration)\$(Platform)\Intermediate\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+    <TargetName>$(ProjectName)$(Suffix)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <AdditionalIncludeDirectories>..\..\inc</AdditionalIncludeDirectories>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_WIN32_WINNT=0x601;WINVER=0x601;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\lib\$(Arch)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>fmod$(Suffix)_vc.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>if not exist ..\bin mkdir ..\bin
+copy /Y "$(TargetPath)" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" ..\bin
+copy /Y "..\..\lib\$(Arch)\fmod$(Suffix).dll" "$(OutDir)"
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common.h" />
+    <ClCompile Include="..\common.cpp" />
+    <ClInclude Include="..\common_platform.h" />
+    <ClCompile Include="..\common_platform.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\channel_groups.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>