uniquake/engine/MockFMOD/libfmod/prx.cpp

#define DLL_EXPORTS
#include "fmod.h"
#include <string.h>

FMOD_RESULT F_API FMOD_System_Create(FMOD_SYSTEM **system)
{
	*system = nullptr;
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_System_Release(FMOD_SYSTEM *system)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_System_Init(FMOD_SYSTEM *system, int maxchannels, FMOD_INITFLAGS flags, void *extradriverdata)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_System_Close(FMOD_SYSTEM *system)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_System_GetVersion(FMOD_SYSTEM *system, unsigned int *version)
{
	*version = FMOD_VERSION;
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_System_GetDriver(FMOD_SYSTEM *system, int *driver)
{
	*driver = 0;
	return FMOD_OK;
}

static const char *templatename = "mock";

FMOD_RESULT F_API FMOD_System_GetDriverInfo(FMOD_SYSTEM *system, int id, char *name, int namelen, FMOD_GUID *guid, int *systemrate, FMOD_SPEAKERMODE *speakermode, int *speakermodechannels)
{
	strncpy_s(name, namelen, templatename, sizeof(templatename));
	*systemrate = 0;
	*speakermode = FMOD_SPEAKERMODE_DEFAULT;
	*speakermodechannels = 0;
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_System_Set3DListenerAttributes(FMOD_SYSTEM *system, int listener, const FMOD_VECTOR *pos, const FMOD_VECTOR *vel, const FMOD_VECTOR *forward, const FMOD_VECTOR *up)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_System_Set3DRolloffCallback(FMOD_SYSTEM *system, FMOD_3D_ROLLOFF_CALLBACK callback)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_System_SetSoftwareChannels(FMOD_SYSTEM *system, int numsoftwarechannels)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_System_Update(FMOD_SYSTEM *system)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_System_GetMasterChannelGroup(FMOD_SYSTEM *system, FMOD_CHANNELGROUP **channelgroup)
{
	*channelgroup = nullptr;
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_System_CreateChannelGroup(FMOD_SYSTEM *system, const char *name, FMOD_CHANNELGROUP **channelgroup)
{
	*channelgroup = nullptr;
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_System_CreateSound(FMOD_SYSTEM *system, const char *name_or_data, FMOD_MODE mode, FMOD_CREATESOUNDEXINFO *exinfo, FMOD_SOUND **sound)
{
	*sound = nullptr;
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_System_PlaySound(FMOD_SYSTEM *system, FMOD_SOUND *sound, FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL paused, FMOD_CHANNEL **channel)
{
	*channel = nullptr;
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_Channel_SetMode(FMOD_CHANNEL *channel, FMOD_MODE mode)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_Channel_SetPaused(FMOD_CHANNEL *channel, FMOD_BOOL paused)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_Channel_SetLoopCount(FMOD_CHANNEL *channel, int loopcount)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_Channel_Stop(FMOD_CHANNEL *channel)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_Channel_SetUserData(FMOD_CHANNEL *channel, void *userdata)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_Channel_GetUserData(FMOD_CHANNEL *channel, void **userdata)
{
	*userdata = nullptr;
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_Channel_Set3DAttributes(FMOD_CHANNEL *channel, const FMOD_VECTOR *pos, const FMOD_VECTOR *vel)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_Channel_Set3DLevel(FMOD_CHANNEL *channel, float level)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_Channel_SetVolume(FMOD_CHANNEL *channel, float volume)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_Channel_GetVolume(FMOD_CHANNEL *channel, float *volume)
{
	*volume = 1.0f;
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_Channel_SetCallback(FMOD_CHANNEL *channel, FMOD_CHANNELCONTROL_CALLBACK callback)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_Channel_SetDelay(FMOD_CHANNEL *channel, unsigned long long dspclock_start, unsigned long long dspclock_end, FMOD_BOOL stopchannels)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_Channel_SetFadePointRamp(FMOD_CHANNEL *channel, unsigned long long dspclock, float volume)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_Channel_SetLoopPoints(FMOD_CHANNEL *channel, unsigned int loopstart, FMOD_TIMEUNIT loopstarttype, unsigned int loopend, FMOD_TIMEUNIT loopendtype)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_Channel_SetPriority(FMOD_CHANNEL *channel, int priority)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_Sound_Release(FMOD_SOUND *sound)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_Sound_GetFormat(FMOD_SOUND *sound, FMOD_SOUND_TYPE *type, FMOD_SOUND_FORMAT *format, int *channels, int *bits)
{
	*type = FMOD_SOUND_TYPE_UNKNOWN;
	*format = FMOD_SOUND_FORMAT_NONE;
	*channels = 0;
	*bits = 0;
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_Sound_GetLength(FMOD_SOUND *sound, unsigned int *length, FMOD_TIMEUNIT lengthtype)
{
	*length = 0;
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_ChannelGroup_Release(FMOD_CHANNELGROUP *channelgroup)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_ChannelGroup_SetVolume(FMOD_CHANNELGROUP *channelgroup, float volume)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_ChannelGroup_GetVolume(FMOD_CHANNELGROUP *channelgroup, float *volume)
{
	*volume = 1.0f;
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_ChannelGroup_GetDSPClock(FMOD_CHANNELGROUP *channelgroup, unsigned long long *dspclock, unsigned long long *parentclock)
{
	*dspclock = 0;
	*parentclock = 0;
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_ChannelGroup_Set3DMinMaxDistance(FMOD_CHANNELGROUP *channelgroup, float mindistance, float maxdistance)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_ChannelGroup_SetMute(FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL mute)
{
	return FMOD_OK;
}

FMOD_RESULT F_API FMOD_ChannelGroup_Stop(FMOD_CHANNELGROUP *channelgroup)
{
	return FMOD_OK;
}