示例#1
0
文件: main.c 项目: mperroteau/Euterpe
void Java_org_fmod_programmerselected_Example_cBegin(JNIEnv *env, jobject thiz)
{
	FMOD_RESULT result = FMOD_OK;

	result = FMOD_EventSystem_Create(&gEventSystem);
	CHECK_RESULT(result);

	result = FMOD_EventSystem_Init(gEventSystem, 64, FMOD_INIT_NORMAL, 0, FMOD_EVENT_INIT_NORMAL);
	CHECK_RESULT(result);

	result = FMOD_EventSystem_SetMediaPath(gEventSystem, "/sdcard/fmod/");
	CHECK_RESULT(result);

	result = FMOD_EventSystem_Load(gEventSystem, "examples.fev", 0, 0);
	CHECK_RESULT(result);

    result = FMOD_EventSystem_GetGroup(gEventSystem, "examples/FeatureDemonstration/SequencingAndStitching", 0, &gEventGroup);
    CHECK_RESULT(result);
}
示例#2
0
文件: main.c 项目: mperroteau/Euterpe
void Java_org_fmod_parameters_Example_cBegin(JNIEnv *env, jobject thiz)
{
	FMOD_RESULT result = FMOD_OK;

	result = FMOD_EventSystem_Create(&gEventSystem);
	CHECK_RESULT(result);

	result = FMOD_EventSystem_Init(gEventSystem, 64, FMOD_INIT_NORMAL, 0, FMOD_EVENT_INIT_NORMAL);
	CHECK_RESULT(result);

	result = FMOD_EventSystem_SetMediaPath(gEventSystem, "/sdcard/fmod/");
	CHECK_RESULT(result);

	result = FMOD_EventSystem_Load(gEventSystem, "examples.fev", 0, 0);
	CHECK_RESULT(result);

    result = FMOD_EventSystem_GetGroup(gEventSystem, "examples/AdvancedTechniques", 0, &gEventGroup);
	CHECK_RESULT(result);

    result = FMOD_EventGroup_GetEvent(gEventGroup, "car", FMOD_EVENT_DEFAULT, &car);
	CHECK_RESULT(result);
    result = FMOD_EventSystem_GetCategory(gEventSystem, "master", &gMasterCategory);
	CHECK_RESULT(result);

    result = FMOD_Event_GetParameter(car, "load", &load);
	CHECK_RESULT(result);
    result = FMOD_EventParameter_GetRange(load, &loadMin, &loadMax);
	CHECK_RESULT(result);
    result = FMOD_EventParameter_SetValue(load, loadMax);
	CHECK_RESULT(result);

    result = FMOD_Event_GetParameterByIndex(car, 0, &rpm);
	CHECK_RESULT(result);
    result = FMOD_EventParameter_GetRange(rpm, &rpmMin, &rpmMax);
	CHECK_RESULT(result);
    result = FMOD_EventParameter_SetValue(rpm, 1000.0f);
	CHECK_RESULT(result);

    result = FMOD_Event_Start(car);
	CHECK_RESULT(result);
}
示例#3
0
int main(int argc, char *argv[])
{
    FMOD_RESULT        result;
    FMOD_EVENTSYSTEM  *eventsystem;
    FMOD_EVENTGROUP   *eventgroup;
    FMOD_EVENT        *event;
    int                key;

    printf("======================================================================\n");
    printf("Programmer Sound. Copyright (c) Firelight Technologies 2006-2011.\n");
    printf("======================================================================\n");

    ERRCHECK(result = FMOD_EventSystem_Create(&eventsystem));
    ERRCHECK(result = FMOD_EventSystem_Init(eventsystem, 64, FMOD_INIT_NORMAL, 0, FMOD_EVENT_INIT_NORMAL));
    ERRCHECK(result = FMOD_EventSystem_SetMediaPath(eventsystem, (char *)MEDIA_PATH));
    ERRCHECK(result = FMOD_EventSystem_Load(eventsystem, "examples.fev", 0, 0));
    ERRCHECK(result = FMOD_EventSystem_GetGroup(eventsystem, "examples/FeatureDemonstration/SequencingAndStitching", FMOD_EVENT_DEFAULT, &eventgroup));

    ERRCHECK(result = FMOD_EventSystem_GetSystemObject(eventsystem, &sys));
    ERRCHECK(result = FMOD_System_CreateStream(sys, FSB_NAME, FMOD_2D | FMOD_NONBLOCKING | FMOD_SOFTWARE, 0, &fsb));

    initIndexMap(fsb);

    printf("======================================================================\n");
    printf("Press 'Space' to start the 'Programmer Sound' event\n");
    printf("Press '>'     to increase sound index\n");
    printf("Press '<'     to decrease sound index\n");
    printf("Press 'Esc'   to quit\n");
    printf("======================================================================\n");
    printf("Sound index = %d\n", g_sound_index + 1);

    key = 0;
    do
    {
        if (_kbhit())
        {
            key = _getch();

            switch(key)
            {
                case ' ' :
                    ERRCHECK(result = FMOD_EventGroup_GetEvent(eventgroup, "ProgrammerSounds", FMOD_EVENT_DEFAULT, &event));
                    ERRCHECK(result = FMOD_Event_SetCallback(event, eventcallback, 0));
                    ERRCHECK(result = FMOD_Event_Start(event));
                    break;

                case '>' : case '.':
                    ++g_sound_index;
                    g_sound_index = (g_sound_index >= SOUND_INDEX_MAX) ? SOUND_INDEX_MAX - 1 : g_sound_index;
                    printf("Sound index = %d\n", g_sound_index + 1);
                    break;

                case '<' : case ',':
                    --g_sound_index;
                    g_sound_index = (g_sound_index < 0) ? 0 : g_sound_index;
                    printf("Sound index = %d\n", g_sound_index + 1);
                    break;
            }
        }

        ERRCHECK(result = FMOD_EventSystem_Update(eventsystem));
        Sleep(10);

    } while (key != 27);

    ERRCHECK(result = FMOD_EventSystem_Unload(eventsystem));
    ERRCHECK(result = FMOD_Sound_Release(fsb));
    ERRCHECK(result = FMOD_EventSystem_Release(eventsystem));
    return 0;
}
示例#4
0
文件: main.c 项目: chandonnet/FTB2015
int main(int argc, char *argv[])
{
    FMOD_EVENTSYSTEM     *eventsystem;
    FMOD_EVENTGROUP      *eventgroup;
    FMOD_EVENT           *event = 0;
    FMOD_RESULT           result;
    int                   key;
    int memory_changed = 1;

    printf("======================================================================\n");
    printf("Load Event Data Example.  Copyright (c) Firelight Technologies 2004-2014.\n");
    printf("==============================-------=================================\n");
    printf("This demonstrates loading and unloading of event data per event and\n");
    printf("per group.\n");
    printf("======================================================================\n\n");

    ERRCHECK(result = FMOD_EventSystem_Create(&eventsystem));
    ERRCHECK(result = FMOD_EventSystem_Init(eventsystem, 64, FMOD_INIT_NORMAL, 0, FMOD_EVENT_INIT_NORMAL));
    ERRCHECK(result = FMOD_EventSystem_SetMediaPath(eventsystem, "..\\media\\"));
    ERRCHECK(result = FMOD_EventSystem_Load(eventsystem, "examples.fev", 0, 0));
    ERRCHECK(result = FMOD_EventSystem_GetGroup(eventsystem, "examples/FeatureDemonstration/Basics", 1, &eventgroup));

    printf("======================================================================\n");
    printf("Press 'e'        to load event data\n");
    printf("Press 'E'        to unload event data\n");
    printf("Press 'g'        to load group data\n");
    printf("Press 'G'        to unload group data\n");
    printf("Press ESC        to quit\n");
    printf("======================================================================\n");

    key = 0;
    do
    {
        if (_kbhit())
        {

            key = _getch();

            if (key == 'e')
            {
                ERRCHECK(result = FMOD_EventGroup_GetEvent(eventgroup, "SimpleEvent", FMOD_EVENT_DEFAULT, &event));
                printf("Event data loaded\n");
                memory_changed = 1;
            }
            else if (key == 'E')
            {
                if (event)
                {
                    result = FMOD_EventGroup_FreeEventData(eventgroup, event, 1);
                    if (result != FMOD_ERR_INVALID_HANDLE)
                    {
                        ERRCHECK(result);
                        printf("Event data unloaded\n");
                        memory_changed = 1;
                    }
                    event = 0;
                }
            }
            else if (key == 'g')
            {
                ERRCHECK(result = FMOD_EventGroup_LoadEventData(eventgroup, FMOD_EVENT_RESOURCE_STREAMS_AND_SAMPLES, 0));
                printf("Event group data loaded\n");
                memory_changed = 1;
            }
            else if (key == 'G')
            {
                ERRCHECK(result = FMOD_EventGroup_FreeEventData(eventgroup, 0, 1));
                printf("Event group data unloaded\n");
                memory_changed = 1;
            }

        }

        if (memory_changed)
        {
            int memory_current, memory_max;
            ERRCHECK(result = FMOD_Memory_GetStats(&memory_current, &memory_max, 0));

            printf("Memory usage: current = %10d, max = %10d\n", memory_current, memory_max);
            memory_changed = 0;
        }

        ERRCHECK(result = FMOD_EventSystem_Update(eventsystem));
        Sleep(15);

    } while (key != 27);

    ERRCHECK(result = FMOD_EventGroup_FreeEventData(eventgroup, 0, 1));
    ERRCHECK(result = FMOD_EventSystem_Release(eventsystem));
    return 0;
}
示例#5
0
int main(int argc, char *argv[])
{
    FMOD_RESULT        result;
    FMOD_EVENTSYSTEM  *eventsystem;
    FMOD_EVENTGROUP   *eventgroup;
    FMOD_EVENT        *event[NUM_EVENTS];
    char              *event_name[NUM_EVENTS] = {
                           "Basics/BasicEventWithLooping",
                           "SequencingAndStitching/LoopLogic",
                           "3D Events/2D-3DPanMorph"
                       };
    int                key, i, userdata = 0;

    printf("======================================================================\n");
    printf("Realtime Tweaking. Copyright (c) Firelight Technologies 2004-2015.\n");
    printf("======================================================================\n");
    printf("This example shows how to initialize the FMOD Net Event System so that\n");
    printf("FMOD Designer can connect to your game and tweak events as they're\n");
    printf("playing.\n");
    printf("Start some events then connect to this app using the Audition menu\n");
    printf("in FMOD Designer. You can use 127.0.0.1 for the IP address if you\n");
    printf("don't want to use two machines. Load tutorials.fdp and change the \n");
    printf("volume of the playing events using the volume slider in the event\n");
    printf("property sheet\n");
    printf("======================================================================\n\n");

    ERRCHECK(result = FMOD_EventSystem_Create(&eventsystem));
    ERRCHECK(result = FMOD_NetEventSystem_Init(eventsystem, FMOD_EVENT_NET_PORT));
    ERRCHECK(result = FMOD_EventSystem_Init(eventsystem, 64, FMOD_INIT_NORMAL, 0, FMOD_EVENT_INIT_NORMAL));
    ERRCHECK(result = FMOD_EventSystem_SetMediaPath(eventsystem, (char *)MEDIA_PATH));
    ERRCHECK(result = FMOD_EventSystem_Load(eventsystem, "examples.fev", 0, 0));
    ERRCHECK(result = FMOD_EventSystem_GetGroup(eventsystem, "examples/FeatureDemonstration", FMOD_EVENT_DEFAULT, &eventgroup));

    for (i=0; i < NUM_EVENTS; i++)
    {
        event[i] = 0;
    }

    printf("======================================================================\n");
    printf("Press 1 - 3  to start/stop events\n");
    printf("Press ESC    to quit\n");
    printf("======================================================================\n");

    key = 0;
    do
    {
        if (_kbhit())
        {
            key = _getch();

            if ((key >= '1') && (key <= '3'))
            {
                i = (int)(key - '1');

                if (event[i])
                {
                    ERRCHECK(result = FMOD_Event_Stop(event[i], 1));
                    event[i] = 0;
                    printf("Stopping '%s'\n", event_name[i]);
                }
                else
                {
                    ERRCHECK(result = FMOD_EventGroup_GetEvent(eventgroup, event_name[i], FMOD_EVENT_DEFAULT, &event[i]));
                    ERRCHECK(result = FMOD_Event_SetCallback(event[i], eventcallback, (void *)(userdata++)));
                    ERRCHECK(result = FMOD_Event_Start(event[i]));
                    printf("Starting '%s'\n", event_name[i]);
                }
            }
        }

        ERRCHECK(result = FMOD_EventSystem_Update(eventsystem));
        ERRCHECK(result = FMOD_NetEventSystem_Update());
        Sleep(10);

    } while (key != 27);

    ERRCHECK(result = FMOD_EventSystem_Release(eventsystem));
    ERRCHECK(result = FMOD_NetEventSystem_Shutdown());
    return 0;
}
示例#6
0
int main(int argc, char *argv[])
{
    FMOD_EVENTSYSTEM     *eventsystem;
    FMOD_EVENTGROUP      *eventgroup;
    FMOD_EVENTCATEGORY   *mastercategory;
    FMOD_EVENT           *car;
    FMOD_EVENTPARAMETER  *rpm;
    FMOD_EVENTPARAMETER  *load;
    FMOD_RESULT           result;
    int                   key;
    float                 rpm_val, rpm_min, rpm_max, rpm_increment, load_val, load_min, load_max, load_increment;

    printf("======================================================================\n");
    printf("Parameters Example.  Copyright (c) Firelight Technologies 2004-2015.\n");
    printf("==============================-------=================================\n");
    printf("This demonstrates the use of FMOD event parameters. It simply plays an\n");
    printf("event, retrieves the parameters and allows the user to adjust them.\n");
    printf("======================================================================\n\n");

    ERRCHECK(result = FMOD_EventSystem_Create(&eventsystem));
    ERRCHECK(result = FMOD_EventSystem_Init(eventsystem, 64, FMOD_INIT_NORMAL, 0, FMOD_EVENT_INIT_NORMAL));
    ERRCHECK(result = FMOD_EventSystem_SetMediaPath(eventsystem, "..\\media\\"));
    ERRCHECK(result = FMOD_EventSystem_Load(eventsystem, "examples.fev", 0, 0));
    ERRCHECK(result = FMOD_EventSystem_GetGroup(eventsystem, "examples/AdvancedTechniques", FMOD_EVENT_DEFAULT, &eventgroup));
    ERRCHECK(result = FMOD_EventGroup_GetEvent(eventgroup, "car", FMOD_EVENT_DEFAULT, &car));

    ERRCHECK(result = FMOD_EventSystem_GetCategory(eventsystem, "master", &mastercategory));

    ERRCHECK(result = FMOD_Event_GetParameter(car, "load", &load));
    ERRCHECK(result = FMOD_EventParameter_GetRange(load, &load_min, &load_max));
    ERRCHECK(result = FMOD_EventParameter_SetValue(load, load_max));

    ERRCHECK(result = FMOD_Event_GetParameterByIndex(car, 0, &rpm));
    ERRCHECK(result = FMOD_EventParameter_GetRange(rpm, &rpm_min, &rpm_max));
    ERRCHECK(result = FMOD_EventParameter_SetValue(rpm, 1000.0f));

    ERRCHECK(result = FMOD_Event_Start(car));

    printf("======================================================================\n");
    printf("Press '<' or ',' to decrease RPM\n");
    printf("Press '>' or '.' to increase RPM\n");
    printf("Press '-' or '_' to decrease load\n");
    printf("Press '+' or '=' to increase load\n");
    printf("Press ESC        to quit\n");
    printf("======================================================================\n");

    rpm_increment   = (rpm_max - rpm_min) / (float)UPDATE_INTERVAL;
    ERRCHECK(result = FMOD_EventParameter_GetValue(rpm, &rpm_val));
    load_increment  = (load_max - load_min) / (float)UPDATE_INTERVAL;
    ERRCHECK(result = FMOD_EventParameter_GetValue(load, &load_val));

    key = 0;
    do
    {
        if (_kbhit())
        {
            key = _getch();

            if (key == '<' || key == ',')
            {
                rpm_val -= rpm_increment;
                if (rpm_val < rpm_min)
                {
                    rpm_val = rpm_min;
                }

                ERRCHECK(result = FMOD_EventParameter_SetValue(rpm, rpm_val));
            }
            else if (key == '>' || key == '.')
            {
                rpm_val += rpm_increment;
                if (rpm_val > rpm_max)
                {
                    rpm_val = rpm_max;
                }

                ERRCHECK(result = FMOD_EventParameter_SetValue(rpm, rpm_val));
            }
            if (key == '-' || key == '_')
            {
                load_val -= load_increment;
                if (load_val < load_min)
                {
                    load_val = load_min;
                }

                ERRCHECK(result = FMOD_EventParameter_SetValue(load, load_val));
            }
            else if (key == '+' || key == '=')
            {
                load_val += load_increment;
                if (load_val > load_max)
                {
                    load_val = load_max;
                }

                ERRCHECK(result = FMOD_EventParameter_SetValue(load, load_val));
            }
            else if (key == ' ')
            {
                int paused;

                ERRCHECK(result = FMOD_EventCategory_GetPaused(mastercategory, &paused));
                paused = !paused;
                ERRCHECK(result = FMOD_EventCategory_SetPaused(mastercategory, paused));
            }

        }

        ERRCHECK(result = FMOD_EventSystem_Update(eventsystem));
        Sleep(15);

        printf("RPM = %.4f, load = %.4f        \r", rpm_val, load_val);

    } while (key != 27);

    ERRCHECK(result = FMOD_EventGroup_FreeEventData(eventgroup, 0, 1));
    ERRCHECK(result = FMOD_EventSystem_Release(eventsystem));
    return 0;
}
示例#7
0
int main(int argc, char *argv[])
{
    FMOD_EVENTSYSTEM     *eventsystem;
    FMOD_EVENTGROUP      *eventgroup;
    FMOD_EVENT           *event = 0;
    FMOD_RESULT           result;
    int                   key;
    int state_changed = 1;

    printf("======================================================================\n");
    printf("Info-only Event Example.  Copyright (c) Firelight Technologies 2004-2015.\n");
    printf("==============================-------=================================\n");
    printf("This demonstrates usage and functionality of info-only events.\n");
    printf("======================================================================\n\n");

    ERRCHECK(result = FMOD_EventSystem_Create(&eventsystem));
    ERRCHECK(result = FMOD_EventSystem_Init(eventsystem, 64, FMOD_INIT_NORMAL, 0, FMOD_EVENT_INIT_NORMAL));
    ERRCHECK(result = FMOD_EventSystem_SetMediaPath(eventsystem, "..\\media\\"));
    ERRCHECK(result = FMOD_EventSystem_Load(eventsystem, "examples.fev", 0, 0));
    ERRCHECK(result = FMOD_EventSystem_GetGroup(eventsystem, "examples/FeatureDemonstration/Basics", 0, &eventgroup));

    printf("======================================================================\n");
    printf("Press 'i'        to get an info-only event\n");
    printf("Press 'e'        to get an event instance\n");
    printf("Press 'u'        to unload all event data\n");
    printf("Press '1' - '0'  to set event volume between 10%% - 100%%\n");
    printf("Press Space      to start/stop the current event\n");
    printf("Press ESC        to quit\n");
    printf("======================================================================\n");


    key = 0;
    do
    {
        if (_kbhit())
        {

            key = _getch();

            if (key == 'i')
            {
                /* Get an info-only event.
                   Notes:
                   - This is the parent from which all instances of the
                     specified event are derived.
                   - This call will not allocate memory for event instances or
                     load sample data.
                   - The resulting event cannot be played, it simply allows
                     querying and setting of event properties.
                   - Any properties which are set on the info-only event will be
                     copied to all instances which are retrieved from then on.
                 */
                ERRCHECK(result = FMOD_EventGroup_GetEvent(eventgroup, "BasicEventWithLooping", FMOD_EVENT_INFOONLY, &event));
                printf("getEvent(FMOD_EVENT_INFOONLY) succeeded\n");
                state_changed = 1;
            }
            else if (key == 'e')
            {
                /* Get an event instance.
                   Notes:
                   - This call will allocate memory for event instances and
                     load sample data if required.
                   - The resulting event can be played.
                   - Any properties which have been set on the info-only event
                     will be copied to this instance.
                 */
                ERRCHECK(result = FMOD_EventGroup_GetEvent(eventgroup, "BasicEventWithLooping", FMOD_EVENT_DEFAULT, &event));
                printf("getEvent(FMOD_EVENT_DEFAULT) succeeded\n");
                state_changed = 1;
            }
            else if (key == ' ')
            {
                if (event)
                {
                    FMOD_EVENT_STATE state;

                    result = FMOD_Event_GetState(event, &state);
                    if (result != FMOD_ERR_INVALID_HANDLE)
                    {
                        ERRCHECK(result);
                    }

                    if (state & FMOD_EVENT_STATE_PLAYING)
                    {
                        /* Attempt to stop the event.
                           - This will fail if the event is info-only.
                         */
                        result = FMOD_Event_Stop(event, 0);
                        if(result == FMOD_OK)
                        {
                            printf("event->stop() succeeded\n");
                            state_changed = 1;
                        }
                        else
                        {
                            printf("event->stop() returned an error:\n\t(%d) %s\n", result, FMOD_ErrorString(result));
                        }
                    }
                    else
                    {
                        /* Attempt to start the event.
                           - This will fail if the event is info-only.
                         */
                        result = FMOD_Event_Start(event);
                        if (result == FMOD_OK)
                        {
                            printf("event->start() succeeded\n");
                            state_changed = 1;
                        }
                        else
                        {
                            printf("event->start() returned an error:\n\t(%d) %s\n", result, FMOD_ErrorString(result));
                        }
                    }
                }
            }
            else if (key >= '0' && key <= '9')
            {
                /* Attempt to set the event's volume.
                   - This will succeed on both info-only events and instances.
                   - Volume set on the info-only event will be copied to
                     all instances retrieved from now on.
                   - Volume set on an instance will only apply to that instance.
                 */
                float volume = (float)(key - '0');

                if (volume == 0)
                {
                    volume = 10.0f;
                }

                volume /= 10.0f;

                result = FMOD_Event_SetVolume(event, volume);
                if (result == FMOD_OK)
                {
                    printf("event->setVolume() succeeded\n");
                    state_changed = 1;
                }
                else
                {
                    printf("event->setVolume() returned an error:\n\t(%d) %s\n", result, FMOD_ErrorString(result));
                }
            }
            else if (key == 'u')
            {
                ERRCHECK(result = FMOD_EventGroup_FreeEventData(eventgroup, 0, 1));
                printf("Event data unloaded\n");
                state_changed = 1;
            }

        }

        if (state_changed)
        {
            int memory_current, memory_max;
            ERRCHECK(result = FMOD_Memory_GetStats(&memory_current, &memory_max, 0));

            printf("Memory usage: current = %10d, max = %10d\n", memory_current, memory_max);

            if (event)
            {
                /* Attempt to get the event's volume.
                   - This will succeed on both info-only events and instances.
                 */
                float volume;

                result = FMOD_Event_GetVolume(event, &volume);
                if (result != FMOD_ERR_INVALID_HANDLE)
                {
                    ERRCHECK(result);
                    printf("Volume: %.2f\n", volume);
                }
            }

            state_changed = 0;
        }

        ERRCHECK(result = FMOD_EventSystem_Update(eventsystem));
        Sleep(15);

    } while (key != 27);

    ERRCHECK(result = FMOD_EventGroup_FreeEventData(eventgroup, 0, 1));
    ERRCHECK(result = FMOD_EventSystem_Release(eventsystem));
    return 0;
}
示例#8
0
文件: main.c 项目: chandonnet/FTB2015
int main(int argc, char *argv[])
{
    FMOD_RESULT        result;
    FMOD_EVENTSYSTEM  *eventsystem;
    FMOD_EVENTGROUP   *eventgroup;
    FMOD_EVENT        *event;
    int                key;

    enum
    {
        StealOldest,
        StealNewest,
        StealQuietest,
        JustFail,
        JustFailIfQuietest
    } event_behaviour = StealOldest;

    ERRCHECK(result = FMOD_EventSystem_Create(&eventsystem));
    ERRCHECK(result = FMOD_EventSystem_Init(eventsystem, 64, FMOD_INIT_NORMAL, 0, FMOD_EVENT_INIT_NORMAL));
    ERRCHECK(result = FMOD_EventSystem_SetMediaPath(eventsystem, (char *)MEDIA_PATH));
    ERRCHECK(result = FMOD_EventSystem_Load(eventsystem, "examples.fev", 0, 0));
    ERRCHECK(result = FMOD_EventSystem_GetGroup(eventsystem, "examples/FeatureDemonstration/MaxPlayback", FMOD_EVENT_DEFAULT, &eventgroup));
    ERRCHECK(result);

    printf("======================================================================\n");
    printf("Max Playbacks Example.  Copyright (c) Firelight Technologies 2004-2014.\n");
    printf("----------------------------------------------------------------------\n");
    printf("Press '1'   to select 'Steal oldest' behaviour\n");
    printf("Press '2'   to select 'Steal newest' behaviour\n");
    printf("Press '3'   to select 'Steal quietest' behaviour\n");
    printf("Press '4'   to select 'Just fail' behaviour\n");
    printf("Press '5'   to select 'Just fail if quietest' behaviour\n");
    printf("Press Space to start an event\n");
    printf("Press 's'   to stop all events\n");
    printf("Press '>'   to increase event distance\n");
    printf("Press '<'   to decrease event distance\n");
    printf("Press ESC to quit\n");
    printf("======================================================================\n");

    key = 0;
    do
    {
        if (_kbhit())
        {
            char *name;
            key = _getch();

            switch(key)
            {
                case '1' : // 'Steal oldest'
                    event_behaviour = StealOldest;
                    stopAllEvents(eventgroup);
                    break;

                case '2' : // 'Steal newest'
                    event_behaviour = StealNewest;
                    stopAllEvents(eventgroup);
                    break;

                case '3' : // 'Steal quietest'
                    event_behaviour = StealQuietest;
                    stopAllEvents(eventgroup);
                    break;

                case '4' : // 'Just fail'
                    event_behaviour = JustFail;
                    stopAllEvents(eventgroup);
                    break;

                case '5' : // 'Just fail if quietest'
                    event_behaviour = JustFailIfQuietest;
                    stopAllEvents(eventgroup);
                    break;

                case ' ' : // Play an event

                    switch(event_behaviour)
                    {
                        case StealOldest :
                            name = "MaxPlay-StealOldest";
                            break;

                        case StealNewest :
                            name = "MaxPlay-StealNewest";
                            break;

                        case StealQuietest :
                            name = "MaxPlay-StealQuietest";
                            break;

                        case JustFail :
                            name = "MaxPlay-JustFail";
                            break;

                        case JustFailIfQuietest :
                            name = "MaxPlay-JustFailIfQuietest";
                            break;
                    }

                    // Clear the line
                    printf("%79s\r", " ");

                    if (event_behaviour == JustFailIfQuietest)
                    {
                        /* The 'Just fail if quietest' behaviour calculates the expected
                           volume of the event based on the properties of the info-only
                           event, so we have to get the info-only event first and set it
                           up appropriately.
                         */

                        // get the info-only event to set up for volume calculation
                        ERRCHECK(result = FMOD_EventGroup_GetEvent(eventgroup, name, FMOD_EVENT_INFOONLY, &event));

                        /* set the desired properties on the info-only event
                           Notes:
                           - distances below the event's 3D Min Distance all give the
                             same volume; in this case, getEvent will just fail
                           - we could set other volume-affecting properties here as
                             well (e.g. orientation if the event has a falloff cone)
                         */
                        setupEvent(event);

                        // attempt to get a real event instance
                        result = FMOD_EventGroup_GetEvent(eventgroup, name, FMOD_EVENT_DEFAULT, &event);
                        if (result == FMOD_OK)
                        {
                            FMOD_EVENTPARAMETER *param;

                            printf("getEvent(\"%s\") succeeded\n", name);

                            /* we don't need to set the position of the instance,
                               as it is copied from the info-only event, but we
                               do need to set the parameter value.
                             */
                            ERRCHECK(result = FMOD_Event_GetParameter(event, "sound", &param));
                            ERRCHECK(result = FMOD_EventParameter_SetValue(param, g_sound));
                            ERRCHECK(result = FMOD_Event_Start(event));
                        }
                        else
                        {
                            printf("getEvent(\"%s\") failed\n", name);
                        }
                    }
                    else
                    {
                        result = FMOD_EventGroup_GetEvent(eventgroup, name, FMOD_EVENT_DEFAULT, &event);
                        if (result == FMOD_OK)
                        {
                            printf("getEvent(\"%s\") succeeded\n", name);
                            setupEvent(event);
                            ERRCHECK(result = FMOD_Event_Start(event));
                        }
                        else
                        {
                            printf("getEvent(\"%s\") failed\n", name);
                        }
                    }

                    ++g_sound;
                    if(g_sound > 3)
                    {
                        g_sound = 0;
                    }

                    break;

                case 's' :
                    stopAllEvents(eventgroup);
                    break;

                case '>' : case '.' :
                    g_distance += 0.1f;
                    break;

                case '<' : case ',' :
                    g_distance -= 0.1f;
                    g_distance = (g_distance < 0.0f) ? 0.0f : g_distance;
                    break;
            }


            switch(event_behaviour)
            {
                case StealOldest:
                    name = "Steal oldest";
                    break;

                case StealNewest:
                    name = "Steal newest";
                    break;

                case StealQuietest:
                    name = "Steal quietest";
                    break;

                case JustFail:
                    name = "Just fail";
                    break;

                case JustFailIfQuietest:
                    name = "Just fail if quietest";
                    break;
            }

            printf("Sound = %1.0f, Distance = %4.1f, Behaviour = %-25s\r", g_sound, g_distance, name);
        }

        ERRCHECK(result = FMOD_EventSystem_Update(eventsystem));
        Sleep(10);

    } while (key != 27);

    ERRCHECK(result = FMOD_EventSystem_Unload(eventsystem));
    ERRCHECK(result = FMOD_EventSystem_Release(eventsystem));
    return 0;
}