Illusion/C2048
1
0
Fork 0
mirror of https://github.com/IllusionMan1212/C2048.git synced 2026-10-24 02:12:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

basic game logic with simple translation animation

Browse Source
This commit is contained in:
Illusion
2023-12-13 06:58:08 +02:00
parent 7360359a48
commit 9620e12681
44 changed files with 33798 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitignore
+4
View File
@@ -0,0 +1,4 @@
compile_commands.json
*.o
c2048
.cache
3rdparty/fmod/include/fmod.h
Vendored
+668
View File
@@ -0,0 +1,668 @@
/* ======================================================================================== */
/* FMOD Core API - C header file. */
/* Copyright (c), Firelight Technologies Pty, Ltd. 2004-2023. */
/* */
/* Use this header in conjunction with fmod_common.h (which contains all the constants / */
/* callbacks) to develop using the C interface */
/* */
/* For more detail visit: */
/* https://fmod.com/docs/2.02/api/core-api.html */
/* ======================================================================================== */
#ifndef _FMOD_H
#define _FMOD_H
#include "fmod_common.h"
#ifdef __cplusplus
extern "C"
{
#endif
/*
FMOD global system functions (optional).
*/
FMOD_RESULT F_API FMOD_Memory_Initialize (void *poolmem, int poollen, FMOD_MEMORY_ALLOC_CALLBACK useralloc, FMOD_MEMORY_REALLOC_CALLBACK userrealloc, FMOD_MEMORY_FREE_CALLBACK userfree, FMOD_MEMORY_TYPE memtypeflags);
FMOD_RESULT F_API FMOD_Memory_GetStats (int *currentalloced, int *maxalloced, FMOD_BOOL blocking);
FMOD_RESULT F_API FMOD_Debug_Initialize (FMOD_DEBUG_FLAGS flags, FMOD_DEBUG_MODE mode, FMOD_DEBUG_CALLBACK callback, const char *filename);
FMOD_RESULT F_API FMOD_File_SetDiskBusy (int busy);
FMOD_RESULT F_API FMOD_File_GetDiskBusy (int *busy);
FMOD_RESULT F_API FMOD_Thread_SetAttributes (FMOD_THREAD_TYPE type, FMOD_THREAD_AFFINITY affinity, FMOD_THREAD_PRIORITY priority, FMOD_THREAD_STACK_SIZE stacksize);
/*
FMOD System factory functions. Use this to create an FMOD System Instance. below you will see FMOD_System_Init/Close to get started.
*/
FMOD_RESULT F_API FMOD_System_Create (FMOD_SYSTEM **system, unsigned int headerversion);
FMOD_RESULT F_API FMOD_System_Release (FMOD_SYSTEM *system);
/*
'System' API
*/
/* Setup functions. */
FMOD_RESULT F_API FMOD_System_SetOutput (FMOD_SYSTEM *system, FMOD_OUTPUTTYPE output);
FMOD_RESULT F_API FMOD_System_GetOutput (FMOD_SYSTEM *system, FMOD_OUTPUTTYPE *output);
FMOD_RESULT F_API FMOD_System_GetNumDrivers (FMOD_SYSTEM *system, int *numdrivers);
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);
FMOD_RESULT F_API FMOD_System_SetDriver (FMOD_SYSTEM *system, int driver);
FMOD_RESULT F_API FMOD_System_GetDriver (FMOD_SYSTEM *system, int *driver);
FMOD_RESULT F_API FMOD_System_SetSoftwareChannels (FMOD_SYSTEM *system, int numsoftwarechannels);
FMOD_RESULT F_API FMOD_System_GetSoftwareChannels (FMOD_SYSTEM *system, int *numsoftwarechannels);
FMOD_RESULT F_API FMOD_System_SetSoftwareFormat (FMOD_SYSTEM *system, int samplerate, FMOD_SPEAKERMODE speakermode, int numrawspeakers);
FMOD_RESULT F_API FMOD_System_GetSoftwareFormat (FMOD_SYSTEM *system, int *samplerate, FMOD_SPEAKERMODE *speakermode, int *numrawspeakers);
FMOD_RESULT F_API FMOD_System_SetDSPBufferSize (FMOD_SYSTEM *system, unsigned int bufferlength, int numbuffers);
FMOD_RESULT F_API FMOD_System_GetDSPBufferSize (FMOD_SYSTEM *system, unsigned int *bufferlength, int *numbuffers);
FMOD_RESULT F_API FMOD_System_SetFileSystem (FMOD_SYSTEM *system, FMOD_FILE_OPEN_CALLBACK useropen, FMOD_FILE_CLOSE_CALLBACK userclose, FMOD_FILE_READ_CALLBACK userread, FMOD_FILE_SEEK_CALLBACK userseek, FMOD_FILE_ASYNCREAD_CALLBACK userasyncread, FMOD_FILE_ASYNCCANCEL_CALLBACK userasynccancel, int blockalign);
FMOD_RESULT F_API FMOD_System_AttachFileSystem (FMOD_SYSTEM *system, FMOD_FILE_OPEN_CALLBACK useropen, FMOD_FILE_CLOSE_CALLBACK userclose, FMOD_FILE_READ_CALLBACK userread, FMOD_FILE_SEEK_CALLBACK userseek);
FMOD_RESULT F_API FMOD_System_SetAdvancedSettings (FMOD_SYSTEM *system, FMOD_ADVANCEDSETTINGS *settings);
FMOD_RESULT F_API FMOD_System_GetAdvancedSettings (FMOD_SYSTEM *system, FMOD_ADVANCEDSETTINGS *settings);
FMOD_RESULT F_API FMOD_System_SetCallback (FMOD_SYSTEM *system, FMOD_SYSTEM_CALLBACK callback, FMOD_SYSTEM_CALLBACK_TYPE callbackmask);
/* Plug-in support. */
FMOD_RESULT F_API FMOD_System_SetPluginPath (FMOD_SYSTEM *system, const char *path);
FMOD_RESULT F_API FMOD_System_LoadPlugin (FMOD_SYSTEM *system, const char *filename, unsigned int *handle, unsigned int priority);
FMOD_RESULT F_API FMOD_System_UnloadPlugin (FMOD_SYSTEM *system, unsigned int handle);
FMOD_RESULT F_API FMOD_System_GetNumNestedPlugins (FMOD_SYSTEM *system, unsigned int handle, int *count);
FMOD_RESULT F_API FMOD_System_GetNestedPlugin (FMOD_SYSTEM *system, unsigned int handle, int index, unsigned int *nestedhandle);
FMOD_RESULT F_API FMOD_System_GetNumPlugins (FMOD_SYSTEM *system, FMOD_PLUGINTYPE plugintype, int *numplugins);
FMOD_RESULT F_API FMOD_System_GetPluginHandle (FMOD_SYSTEM *system, FMOD_PLUGINTYPE plugintype, int index, unsigned int *handle);
FMOD_RESULT F_API FMOD_System_GetPluginInfo (FMOD_SYSTEM *system, unsigned int handle, FMOD_PLUGINTYPE *plugintype, char *name, int namelen, unsigned int *version);
FMOD_RESULT F_API FMOD_System_SetOutputByPlugin (FMOD_SYSTEM *system, unsigned int handle);
FMOD_RESULT F_API FMOD_System_GetOutputByPlugin (FMOD_SYSTEM *system, unsigned int *handle);
FMOD_RESULT F_API FMOD_System_CreateDSPByPlugin (FMOD_SYSTEM *system, unsigned int handle, FMOD_DSP **dsp);
FMOD_RESULT F_API FMOD_System_GetDSPInfoByPlugin (FMOD_SYSTEM *system, unsigned int handle, const FMOD_DSP_DESCRIPTION **description);
FMOD_RESULT F_API FMOD_System_RegisterCodec (FMOD_SYSTEM *system, FMOD_CODEC_DESCRIPTION *description, unsigned int *handle, unsigned int priority);
FMOD_RESULT F_API FMOD_System_RegisterDSP (FMOD_SYSTEM *system, const FMOD_DSP_DESCRIPTION *description, unsigned int *handle);
FMOD_RESULT F_API FMOD_System_RegisterOutput (FMOD_SYSTEM *system, const FMOD_OUTPUT_DESCRIPTION *description, unsigned int *handle);
/* Init/Close. */
FMOD_RESULT F_API FMOD_System_Init (FMOD_SYSTEM *system, int maxchannels, FMOD_INITFLAGS flags, void *extradriverdata);
FMOD_RESULT F_API FMOD_System_Close (FMOD_SYSTEM *system);
/* General post-init system functions. */
FMOD_RESULT F_API FMOD_System_Update (FMOD_SYSTEM *system);
FMOD_RESULT F_API FMOD_System_SetSpeakerPosition (FMOD_SYSTEM *system, FMOD_SPEAKER speaker, float x, float y, FMOD_BOOL active);
FMOD_RESULT F_API FMOD_System_GetSpeakerPosition (FMOD_SYSTEM *system, FMOD_SPEAKER speaker, float *x, float *y, FMOD_BOOL *active);
FMOD_RESULT F_API FMOD_System_SetStreamBufferSize (FMOD_SYSTEM *system, unsigned int filebuffersize, FMOD_TIMEUNIT filebuffersizetype);
FMOD_RESULT F_API FMOD_System_GetStreamBufferSize (FMOD_SYSTEM *system, unsigned int *filebuffersize, FMOD_TIMEUNIT *filebuffersizetype);
FMOD_RESULT F_API FMOD_System_Set3DSettings (FMOD_SYSTEM *system, float dopplerscale, float distancefactor, float rolloffscale);
FMOD_RESULT F_API FMOD_System_Get3DSettings (FMOD_SYSTEM *system, float *dopplerscale, float *distancefactor, float *rolloffscale);
FMOD_RESULT F_API FMOD_System_Set3DNumListeners (FMOD_SYSTEM *system, int numlisteners);
FMOD_RESULT F_API FMOD_System_Get3DNumListeners (FMOD_SYSTEM *system, int *numlisteners);
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);
FMOD_RESULT F_API FMOD_System_Get3DListenerAttributes (FMOD_SYSTEM *system, int listener, FMOD_VECTOR *pos, FMOD_VECTOR *vel, FMOD_VECTOR *forward, FMOD_VECTOR *up);
FMOD_RESULT F_API FMOD_System_Set3DRolloffCallback (FMOD_SYSTEM *system, FMOD_3D_ROLLOFF_CALLBACK callback);
FMOD_RESULT F_API FMOD_System_MixerSuspend (FMOD_SYSTEM *system);
FMOD_RESULT F_API FMOD_System_MixerResume (FMOD_SYSTEM *system);
FMOD_RESULT F_API FMOD_System_GetDefaultMixMatrix (FMOD_SYSTEM *system, FMOD_SPEAKERMODE sourcespeakermode, FMOD_SPEAKERMODE targetspeakermode, float *matrix, int matrixhop);
FMOD_RESULT F_API FMOD_System_GetSpeakerModeChannels (FMOD_SYSTEM *system, FMOD_SPEAKERMODE mode, int *channels);
/* System information functions. */
FMOD_RESULT F_API FMOD_System_GetVersion (FMOD_SYSTEM *system, unsigned int *version);
FMOD_RESULT F_API FMOD_System_GetOutputHandle (FMOD_SYSTEM *system, void **handle);
FMOD_RESULT F_API FMOD_System_GetChannelsPlaying (FMOD_SYSTEM *system, int *channels, int *realchannels);
FMOD_RESULT F_API FMOD_System_GetCPUUsage (FMOD_SYSTEM *system, FMOD_CPU_USAGE *usage);
FMOD_RESULT F_API FMOD_System_GetFileUsage (FMOD_SYSTEM *system, long long *sampleBytesRead, long long *streamBytesRead, long long *otherBytesRead);
/* Sound/DSP/Channel/FX creation and retrieval. */
FMOD_RESULT F_API FMOD_System_CreateSound (FMOD_SYSTEM *system, const char *name_or_data, FMOD_MODE mode, FMOD_CREATESOUNDEXINFO *exinfo, FMOD_SOUND **sound);
FMOD_RESULT F_API FMOD_System_CreateStream (FMOD_SYSTEM *system, const char *name_or_data, FMOD_MODE mode, FMOD_CREATESOUNDEXINFO *exinfo, FMOD_SOUND **sound);
FMOD_RESULT F_API FMOD_System_CreateDSP (FMOD_SYSTEM *system, const FMOD_DSP_DESCRIPTION *description, FMOD_DSP **dsp);
FMOD_RESULT F_API FMOD_System_CreateDSPByType (FMOD_SYSTEM *system, FMOD_DSP_TYPE type, FMOD_DSP **dsp);
FMOD_RESULT F_API FMOD_System_CreateChannelGroup (FMOD_SYSTEM *system, const char *name, FMOD_CHANNELGROUP **channelgroup);
FMOD_RESULT F_API FMOD_System_CreateSoundGroup (FMOD_SYSTEM *system, const char *name, FMOD_SOUNDGROUP **soundgroup);
FMOD_RESULT F_API FMOD_System_CreateReverb3D (FMOD_SYSTEM *system, FMOD_REVERB3D **reverb);
FMOD_RESULT F_API FMOD_System_PlaySound (FMOD_SYSTEM *system, FMOD_SOUND *sound, FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL paused, FMOD_CHANNEL **channel);
FMOD_RESULT F_API FMOD_System_PlayDSP (FMOD_SYSTEM *system, FMOD_DSP *dsp, FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL paused, FMOD_CHANNEL **channel);
FMOD_RESULT F_API FMOD_System_GetChannel (FMOD_SYSTEM *system, int channelid, FMOD_CHANNEL **channel);
FMOD_RESULT F_API FMOD_System_GetDSPInfoByType (FMOD_SYSTEM *system, FMOD_DSP_TYPE type, const FMOD_DSP_DESCRIPTION **description);
FMOD_RESULT F_API FMOD_System_GetMasterChannelGroup (FMOD_SYSTEM *system, FMOD_CHANNELGROUP **channelgroup);
FMOD_RESULT F_API FMOD_System_GetMasterSoundGroup (FMOD_SYSTEM *system, FMOD_SOUNDGROUP **soundgroup);
/* Routing to ports. */
FMOD_RESULT F_API FMOD_System_AttachChannelGroupToPort (FMOD_SYSTEM *system, FMOD_PORT_TYPE portType, FMOD_PORT_INDEX portIndex, FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL passThru);
FMOD_RESULT F_API FMOD_System_DetachChannelGroupFromPort(FMOD_SYSTEM *system, FMOD_CHANNELGROUP *channelgroup);
/* Reverb API. */
FMOD_RESULT F_API FMOD_System_SetReverbProperties (FMOD_SYSTEM *system, int instance, const FMOD_REVERB_PROPERTIES *prop);
FMOD_RESULT F_API FMOD_System_GetReverbProperties (FMOD_SYSTEM *system, int instance, FMOD_REVERB_PROPERTIES *prop);
/* System level DSP functionality. */
FMOD_RESULT F_API FMOD_System_LockDSP (FMOD_SYSTEM *system);
FMOD_RESULT F_API FMOD_System_UnlockDSP (FMOD_SYSTEM *system);
/* Recording API. */
FMOD_RESULT F_API FMOD_System_GetRecordNumDrivers (FMOD_SYSTEM *system, int *numdrivers, int *numconnected);
FMOD_RESULT F_API FMOD_System_GetRecordDriverInfo (FMOD_SYSTEM *system, int id, char *name, int namelen, FMOD_GUID *guid, int *systemrate, FMOD_SPEAKERMODE *speakermode, int *speakermodechannels, FMOD_DRIVER_STATE *state);
FMOD_RESULT F_API FMOD_System_GetRecordPosition (FMOD_SYSTEM *system, int id, unsigned int *position);
FMOD_RESULT F_API FMOD_System_RecordStart (FMOD_SYSTEM *system, int id, FMOD_SOUND *sound, FMOD_BOOL loop);
FMOD_RESULT F_API FMOD_System_RecordStop (FMOD_SYSTEM *system, int id);
FMOD_RESULT F_API FMOD_System_IsRecording (FMOD_SYSTEM *system, int id, FMOD_BOOL *recording);
/* Geometry API. */
FMOD_RESULT F_API FMOD_System_CreateGeometry (FMOD_SYSTEM *system, int maxpolygons, int maxvertices, FMOD_GEOMETRY **geometry);
FMOD_RESULT F_API FMOD_System_SetGeometrySettings (FMOD_SYSTEM *system, float maxworldsize);
FMOD_RESULT F_API FMOD_System_GetGeometrySettings (FMOD_SYSTEM *system, float *maxworldsize);
FMOD_RESULT F_API FMOD_System_LoadGeometry (FMOD_SYSTEM *system, const void *data, int datasize, FMOD_GEOMETRY **geometry);
FMOD_RESULT F_API FMOD_System_GetGeometryOcclusion (FMOD_SYSTEM *system, const FMOD_VECTOR *listener, const FMOD_VECTOR *source, float *direct, float *reverb);
/* Network functions. */
FMOD_RESULT F_API FMOD_System_SetNetworkProxy (FMOD_SYSTEM *system, const char *proxy);
FMOD_RESULT F_API FMOD_System_GetNetworkProxy (FMOD_SYSTEM *system, char *proxy, int proxylen);
FMOD_RESULT F_API FMOD_System_SetNetworkTimeout (FMOD_SYSTEM *system, int timeout);
FMOD_RESULT F_API FMOD_System_GetNetworkTimeout (FMOD_SYSTEM *system, int *timeout);
/* Userdata set/get. */
FMOD_RESULT F_API FMOD_System_SetUserData (FMOD_SYSTEM *system, void *userdata);
FMOD_RESULT F_API FMOD_System_GetUserData (FMOD_SYSTEM *system, void **userdata);
/* Sound API
*/
FMOD_RESULT F_API FMOD_Sound_Release (FMOD_SOUND *sound);
FMOD_RESULT F_API FMOD_Sound_GetSystemObject (FMOD_SOUND *sound, FMOD_SYSTEM **system);
/*
Standard sound manipulation functions.
*/
FMOD_RESULT F_API FMOD_Sound_Lock (FMOD_SOUND *sound, unsigned int offset, unsigned int length, void **ptr1, void **ptr2, unsigned int *len1, unsigned int *len2);
FMOD_RESULT F_API FMOD_Sound_Unlock (FMOD_SOUND *sound, void *ptr1, void *ptr2, unsigned int len1, unsigned int len2);
FMOD_RESULT F_API FMOD_Sound_SetDefaults (FMOD_SOUND *sound, float frequency, int priority);
FMOD_RESULT F_API FMOD_Sound_GetDefaults (FMOD_SOUND *sound, float *frequency, int *priority);
FMOD_RESULT F_API FMOD_Sound_Set3DMinMaxDistance (FMOD_SOUND *sound, float min, float max);
FMOD_RESULT F_API FMOD_Sound_Get3DMinMaxDistance (FMOD_SOUND *sound, float *min, float *max);
FMOD_RESULT F_API FMOD_Sound_Set3DConeSettings (FMOD_SOUND *sound, float insideconeangle, float outsideconeangle, float outsidevolume);
FMOD_RESULT F_API FMOD_Sound_Get3DConeSettings (FMOD_SOUND *sound, float *insideconeangle, float *outsideconeangle, float *outsidevolume);
FMOD_RESULT F_API FMOD_Sound_Set3DCustomRolloff (FMOD_SOUND *sound, FMOD_VECTOR *points, int numpoints);
FMOD_RESULT F_API FMOD_Sound_Get3DCustomRolloff (FMOD_SOUND *sound, FMOD_VECTOR **points, int *numpoints);
FMOD_RESULT F_API FMOD_Sound_GetSubSound (FMOD_SOUND *sound, int index, FMOD_SOUND **subsound);
FMOD_RESULT F_API FMOD_Sound_GetSubSoundParent (FMOD_SOUND *sound, FMOD_SOUND **parentsound);
FMOD_RESULT F_API FMOD_Sound_GetName (FMOD_SOUND *sound, char *name, int namelen);
FMOD_RESULT F_API FMOD_Sound_GetLength (FMOD_SOUND *sound, unsigned int *length, FMOD_TIMEUNIT lengthtype);
FMOD_RESULT F_API FMOD_Sound_GetFormat (FMOD_SOUND *sound, FMOD_SOUND_TYPE *type, FMOD_SOUND_FORMAT *format, int *channels, int *bits);
FMOD_RESULT F_API FMOD_Sound_GetNumSubSounds (FMOD_SOUND *sound, int *numsubsounds);
FMOD_RESULT F_API FMOD_Sound_GetNumTags (FMOD_SOUND *sound, int *numtags, int *numtagsupdated);
FMOD_RESULT F_API FMOD_Sound_GetTag (FMOD_SOUND *sound, const char *name, int index, FMOD_TAG *tag);
FMOD_RESULT F_API FMOD_Sound_GetOpenState (FMOD_SOUND *sound, FMOD_OPENSTATE *openstate, unsigned int *percentbuffered, FMOD_BOOL *starving, FMOD_BOOL *diskbusy);
FMOD_RESULT F_API FMOD_Sound_ReadData (FMOD_SOUND *sound, void *buffer, unsigned int length, unsigned int *read);
FMOD_RESULT F_API FMOD_Sound_SeekData (FMOD_SOUND *sound, unsigned int pcm);
FMOD_RESULT F_API FMOD_Sound_SetSoundGroup (FMOD_SOUND *sound, FMOD_SOUNDGROUP *soundgroup);
FMOD_RESULT F_API FMOD_Sound_GetSoundGroup (FMOD_SOUND *sound, FMOD_SOUNDGROUP **soundgroup);
/*
Synchronization point API. These points can come from markers embedded in wav files, and can also generate channel callbacks.
*/
FMOD_RESULT F_API FMOD_Sound_GetNumSyncPoints (FMOD_SOUND *sound, int *numsyncpoints);
FMOD_RESULT F_API FMOD_Sound_GetSyncPoint (FMOD_SOUND *sound, int index, FMOD_SYNCPOINT **point);
FMOD_RESULT F_API FMOD_Sound_GetSyncPointInfo (FMOD_SOUND *sound, FMOD_SYNCPOINT *point, char *name, int namelen, unsigned int *offset, FMOD_TIMEUNIT offsettype);
FMOD_RESULT F_API FMOD_Sound_AddSyncPoint (FMOD_SOUND *sound, unsigned int offset, FMOD_TIMEUNIT offsettype, const char *name, FMOD_SYNCPOINT **point);
FMOD_RESULT F_API FMOD_Sound_DeleteSyncPoint (FMOD_SOUND *sound, FMOD_SYNCPOINT *point);
/*
Functions also in Channel class but here they are the 'default' to save having to change it in Channel all the time.
*/
FMOD_RESULT F_API FMOD_Sound_SetMode (FMOD_SOUND *sound, FMOD_MODE mode);
FMOD_RESULT F_API FMOD_Sound_GetMode (FMOD_SOUND *sound, FMOD_MODE *mode);
FMOD_RESULT F_API FMOD_Sound_SetLoopCount (FMOD_SOUND *sound, int loopcount);
FMOD_RESULT F_API FMOD_Sound_GetLoopCount (FMOD_SOUND *sound, int *loopcount);
FMOD_RESULT F_API FMOD_Sound_SetLoopPoints (FMOD_SOUND *sound, unsigned int loopstart, FMOD_TIMEUNIT loopstarttype, unsigned int loopend, FMOD_TIMEUNIT loopendtype);
FMOD_RESULT F_API FMOD_Sound_GetLoopPoints (FMOD_SOUND *sound, unsigned int *loopstart, FMOD_TIMEUNIT loopstarttype, unsigned int *loopend, FMOD_TIMEUNIT loopendtype);
/*
For MOD/S3M/XM/IT/MID sequenced formats only.
*/
FMOD_RESULT F_API FMOD_Sound_GetMusicNumChannels (FMOD_SOUND *sound, int *numchannels);
FMOD_RESULT F_API FMOD_Sound_SetMusicChannelVolume (FMOD_SOUND *sound, int channel, float volume);
FMOD_RESULT F_API FMOD_Sound_GetMusicChannelVolume (FMOD_SOUND *sound, int channel, float *volume);
FMOD_RESULT F_API FMOD_Sound_SetMusicSpeed (FMOD_SOUND *sound, float speed);
FMOD_RESULT F_API FMOD_Sound_GetMusicSpeed (FMOD_SOUND *sound, float *speed);
/*
Userdata set/get.
*/
FMOD_RESULT F_API FMOD_Sound_SetUserData (FMOD_SOUND *sound, void *userdata);
FMOD_RESULT F_API FMOD_Sound_GetUserData (FMOD_SOUND *sound, void **userdata);
/*
'Channel' API
*/
FMOD_RESULT F_API FMOD_Channel_GetSystemObject (FMOD_CHANNEL *channel, FMOD_SYSTEM **system);
/*
General control functionality for Channels and ChannelGroups.
*/
FMOD_RESULT F_API FMOD_Channel_Stop (FMOD_CHANNEL *channel);
FMOD_RESULT F_API FMOD_Channel_SetPaused (FMOD_CHANNEL *channel, FMOD_BOOL paused);
FMOD_RESULT F_API FMOD_Channel_GetPaused (FMOD_CHANNEL *channel, FMOD_BOOL *paused);
FMOD_RESULT F_API FMOD_Channel_SetVolume (FMOD_CHANNEL *channel, float volume);
FMOD_RESULT F_API FMOD_Channel_GetVolume (FMOD_CHANNEL *channel, float *volume);
FMOD_RESULT F_API FMOD_Channel_SetVolumeRamp (FMOD_CHANNEL *channel, FMOD_BOOL ramp);
FMOD_RESULT F_API FMOD_Channel_GetVolumeRamp (FMOD_CHANNEL *channel, FMOD_BOOL *ramp);
FMOD_RESULT F_API FMOD_Channel_GetAudibility (FMOD_CHANNEL *channel, float *audibility);
FMOD_RESULT F_API FMOD_Channel_SetPitch (FMOD_CHANNEL *channel, float pitch);
FMOD_RESULT F_API FMOD_Channel_GetPitch (FMOD_CHANNEL *channel, float *pitch);
FMOD_RESULT F_API FMOD_Channel_SetMute (FMOD_CHANNEL *channel, FMOD_BOOL mute);
FMOD_RESULT F_API FMOD_Channel_GetMute (FMOD_CHANNEL *channel, FMOD_BOOL *mute);
FMOD_RESULT F_API FMOD_Channel_SetReverbProperties (FMOD_CHANNEL *channel, int instance, float wet);
FMOD_RESULT F_API FMOD_Channel_GetReverbProperties (FMOD_CHANNEL *channel, int instance, float *wet);
FMOD_RESULT F_API FMOD_Channel_SetLowPassGain (FMOD_CHANNEL *channel, float gain);
FMOD_RESULT F_API FMOD_Channel_GetLowPassGain (FMOD_CHANNEL *channel, float *gain);
FMOD_RESULT F_API FMOD_Channel_SetMode (FMOD_CHANNEL *channel, FMOD_MODE mode);
FMOD_RESULT F_API FMOD_Channel_GetMode (FMOD_CHANNEL *channel, FMOD_MODE *mode);
FMOD_RESULT F_API FMOD_Channel_SetCallback (FMOD_CHANNEL *channel, FMOD_CHANNELCONTROL_CALLBACK callback);
FMOD_RESULT F_API FMOD_Channel_IsPlaying (FMOD_CHANNEL *channel, FMOD_BOOL *isplaying);
/*
Note all 'set' functions alter a final matrix, this is why the only get function is getMixMatrix, to avoid other get functions returning incorrect/obsolete values.
*/
FMOD_RESULT F_API FMOD_Channel_SetPan (FMOD_CHANNEL *channel, float pan);
FMOD_RESULT F_API FMOD_Channel_SetMixLevelsOutput (FMOD_CHANNEL *channel, float frontleft, float frontright, float center, float lfe, float surroundleft, float surroundright, float backleft, float backright);
FMOD_RESULT F_API FMOD_Channel_SetMixLevelsInput (FMOD_CHANNEL *channel, float *levels, int numlevels);
FMOD_RESULT F_API FMOD_Channel_SetMixMatrix (FMOD_CHANNEL *channel, float *matrix, int outchannels, int inchannels, int inchannel_hop);
FMOD_RESULT F_API FMOD_Channel_GetMixMatrix (FMOD_CHANNEL *channel, float *matrix, int *outchannels, int *inchannels, int inchannel_hop);
/*
Clock based functionality.
*/
FMOD_RESULT F_API FMOD_Channel_GetDSPClock (FMOD_CHANNEL *channel, unsigned long long *dspclock, unsigned long long *parentclock);
FMOD_RESULT F_API FMOD_Channel_SetDelay (FMOD_CHANNEL *channel, unsigned long long dspclock_start, unsigned long long dspclock_end, FMOD_BOOL stopchannels);
FMOD_RESULT F_API FMOD_Channel_GetDelay (FMOD_CHANNEL *channel, unsigned long long *dspclock_start, unsigned long long *dspclock_end, FMOD_BOOL *stopchannels);
FMOD_RESULT F_API FMOD_Channel_AddFadePoint (FMOD_CHANNEL *channel, unsigned long long dspclock, float volume);
FMOD_RESULT F_API FMOD_Channel_SetFadePointRamp (FMOD_CHANNEL *channel, unsigned long long dspclock, float volume);
FMOD_RESULT F_API FMOD_Channel_RemoveFadePoints (FMOD_CHANNEL *channel, unsigned long long dspclock_start, unsigned long long dspclock_end);
FMOD_RESULT F_API FMOD_Channel_GetFadePoints (FMOD_CHANNEL *channel, unsigned int *numpoints, unsigned long long *point_dspclock, float *point_volume);
/*
DSP effects.
*/
FMOD_RESULT F_API FMOD_Channel_GetDSP (FMOD_CHANNEL *channel, int index, FMOD_DSP **dsp);
FMOD_RESULT F_API FMOD_Channel_AddDSP (FMOD_CHANNEL *channel, int index, FMOD_DSP *dsp);
FMOD_RESULT F_API FMOD_Channel_RemoveDSP (FMOD_CHANNEL *channel, FMOD_DSP *dsp);
FMOD_RESULT F_API FMOD_Channel_GetNumDSPs (FMOD_CHANNEL *channel, int *numdsps);
FMOD_RESULT F_API FMOD_Channel_SetDSPIndex (FMOD_CHANNEL *channel, FMOD_DSP *dsp, int index);
FMOD_RESULT F_API FMOD_Channel_GetDSPIndex (FMOD_CHANNEL *channel, FMOD_DSP *dsp, int *index);
/*
3D functionality.
*/
FMOD_RESULT F_API FMOD_Channel_Set3DAttributes (FMOD_CHANNEL *channel, const FMOD_VECTOR *pos, const FMOD_VECTOR *vel);
FMOD_RESULT F_API FMOD_Channel_Get3DAttributes (FMOD_CHANNEL *channel, FMOD_VECTOR *pos, FMOD_VECTOR *vel);
FMOD_RESULT F_API FMOD_Channel_Set3DMinMaxDistance (FMOD_CHANNEL *channel, float mindistance, float maxdistance);
FMOD_RESULT F_API FMOD_Channel_Get3DMinMaxDistance (FMOD_CHANNEL *channel, float *mindistance, float *maxdistance);
FMOD_RESULT F_API FMOD_Channel_Set3DConeSettings (FMOD_CHANNEL *channel, float insideconeangle, float outsideconeangle, float outsidevolume);
FMOD_RESULT F_API FMOD_Channel_Get3DConeSettings (FMOD_CHANNEL *channel, float *insideconeangle, float *outsideconeangle, float *outsidevolume);
FMOD_RESULT F_API FMOD_Channel_Set3DConeOrientation (FMOD_CHANNEL *channel, FMOD_VECTOR *orientation);
FMOD_RESULT F_API FMOD_Channel_Get3DConeOrientation (FMOD_CHANNEL *channel, FMOD_VECTOR *orientation);
FMOD_RESULT F_API FMOD_Channel_Set3DCustomRolloff (FMOD_CHANNEL *channel, FMOD_VECTOR *points, int numpoints);
FMOD_RESULT F_API FMOD_Channel_Get3DCustomRolloff (FMOD_CHANNEL *channel, FMOD_VECTOR **points, int *numpoints);
FMOD_RESULT F_API FMOD_Channel_Set3DOcclusion (FMOD_CHANNEL *channel, float directocclusion, float reverbocclusion);
FMOD_RESULT F_API FMOD_Channel_Get3DOcclusion (FMOD_CHANNEL *channel, float *directocclusion, float *reverbocclusion);
FMOD_RESULT F_API FMOD_Channel_Set3DSpread (FMOD_CHANNEL *channel, float angle);
FMOD_RESULT F_API FMOD_Channel_Get3DSpread (FMOD_CHANNEL *channel, float *angle);
FMOD_RESULT F_API FMOD_Channel_Set3DLevel (FMOD_CHANNEL *channel, float level);
FMOD_RESULT F_API FMOD_Channel_Get3DLevel (FMOD_CHANNEL *channel, float *level);
FMOD_RESULT F_API FMOD_Channel_Set3DDopplerLevel (FMOD_CHANNEL *channel, float level);
FMOD_RESULT F_API FMOD_Channel_Get3DDopplerLevel (FMOD_CHANNEL *channel, float *level);
FMOD_RESULT F_API FMOD_Channel_Set3DDistanceFilter (FMOD_CHANNEL *channel, FMOD_BOOL custom, float customLevel, float centerFreq);
FMOD_RESULT F_API FMOD_Channel_Get3DDistanceFilter (FMOD_CHANNEL *channel, FMOD_BOOL *custom, float *customLevel, float *centerFreq);
/*
Userdata set/get.
*/
FMOD_RESULT F_API FMOD_Channel_SetUserData (FMOD_CHANNEL *channel, void *userdata);
FMOD_RESULT F_API FMOD_Channel_GetUserData (FMOD_CHANNEL *channel, void **userdata);
/*
Channel specific control functionality.
*/
FMOD_RESULT F_API FMOD_Channel_SetFrequency (FMOD_CHANNEL *channel, float frequency);
FMOD_RESULT F_API FMOD_Channel_GetFrequency (FMOD_CHANNEL *channel, float *frequency);
FMOD_RESULT F_API FMOD_Channel_SetPriority (FMOD_CHANNEL *channel, int priority);
FMOD_RESULT F_API FMOD_Channel_GetPriority (FMOD_CHANNEL *channel, int *priority);
FMOD_RESULT F_API FMOD_Channel_SetPosition (FMOD_CHANNEL *channel, unsigned int position, FMOD_TIMEUNIT postype);
FMOD_RESULT F_API FMOD_Channel_GetPosition (FMOD_CHANNEL *channel, unsigned int *position, FMOD_TIMEUNIT postype);
FMOD_RESULT F_API FMOD_Channel_SetChannelGroup (FMOD_CHANNEL *channel, FMOD_CHANNELGROUP *channelgroup);
FMOD_RESULT F_API FMOD_Channel_GetChannelGroup (FMOD_CHANNEL *channel, FMOD_CHANNELGROUP **channelgroup);
FMOD_RESULT F_API FMOD_Channel_SetLoopCount (FMOD_CHANNEL *channel, int loopcount);
FMOD_RESULT F_API FMOD_Channel_GetLoopCount (FMOD_CHANNEL *channel, int *loopcount);
FMOD_RESULT F_API FMOD_Channel_SetLoopPoints (FMOD_CHANNEL *channel, unsigned int loopstart, FMOD_TIMEUNIT loopstarttype, unsigned int loopend, FMOD_TIMEUNIT loopendtype);
FMOD_RESULT F_API FMOD_Channel_GetLoopPoints (FMOD_CHANNEL *channel, unsigned int *loopstart, FMOD_TIMEUNIT loopstarttype, unsigned int *loopend, FMOD_TIMEUNIT loopendtype);
/*
Information only functions.
*/
FMOD_RESULT F_API FMOD_Channel_IsVirtual (FMOD_CHANNEL *channel, FMOD_BOOL *isvirtual);
FMOD_RESULT F_API FMOD_Channel_GetCurrentSound (FMOD_CHANNEL *channel, FMOD_SOUND **sound);
FMOD_RESULT F_API FMOD_Channel_GetIndex (FMOD_CHANNEL *channel, int *index);
/*
'ChannelGroup' API
*/
FMOD_RESULT F_API FMOD_ChannelGroup_GetSystemObject (FMOD_CHANNELGROUP *channelgroup, FMOD_SYSTEM **system);
/*
General control functionality for Channels and ChannelGroups.
*/
FMOD_RESULT F_API FMOD_ChannelGroup_Stop (FMOD_CHANNELGROUP *channelgroup);
FMOD_RESULT F_API FMOD_ChannelGroup_SetPaused (FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL paused);
FMOD_RESULT F_API FMOD_ChannelGroup_GetPaused (FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL *paused);
FMOD_RESULT F_API FMOD_ChannelGroup_SetVolume (FMOD_CHANNELGROUP *channelgroup, float volume);
FMOD_RESULT F_API FMOD_ChannelGroup_GetVolume (FMOD_CHANNELGROUP *channelgroup, float *volume);
FMOD_RESULT F_API FMOD_ChannelGroup_SetVolumeRamp (FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL ramp);
FMOD_RESULT F_API FMOD_ChannelGroup_GetVolumeRamp (FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL *ramp);
FMOD_RESULT F_API FMOD_ChannelGroup_GetAudibility (FMOD_CHANNELGROUP *channelgroup, float *audibility);
FMOD_RESULT F_API FMOD_ChannelGroup_SetPitch (FMOD_CHANNELGROUP *channelgroup, float pitch);
FMOD_RESULT F_API FMOD_ChannelGroup_GetPitch (FMOD_CHANNELGROUP *channelgroup, float *pitch);
FMOD_RESULT F_API FMOD_ChannelGroup_SetMute (FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL mute);
FMOD_RESULT F_API FMOD_ChannelGroup_GetMute (FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL *mute);
FMOD_RESULT F_API FMOD_ChannelGroup_SetReverbProperties (FMOD_CHANNELGROUP *channelgroup, int instance, float wet);
FMOD_RESULT F_API FMOD_ChannelGroup_GetReverbProperties (FMOD_CHANNELGROUP *channelgroup, int instance, float *wet);
FMOD_RESULT F_API FMOD_ChannelGroup_SetLowPassGain (FMOD_CHANNELGROUP *channelgroup, float gain);
FMOD_RESULT F_API FMOD_ChannelGroup_GetLowPassGain (FMOD_CHANNELGROUP *channelgroup, float *gain);
FMOD_RESULT F_API FMOD_ChannelGroup_SetMode (FMOD_CHANNELGROUP *channelgroup, FMOD_MODE mode);
FMOD_RESULT F_API FMOD_ChannelGroup_GetMode (FMOD_CHANNELGROUP *channelgroup, FMOD_MODE *mode);
FMOD_RESULT F_API FMOD_ChannelGroup_SetCallback (FMOD_CHANNELGROUP *channelgroup, FMOD_CHANNELCONTROL_CALLBACK callback);
FMOD_RESULT F_API FMOD_ChannelGroup_IsPlaying (FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL *isplaying);
/*
Note all 'set' functions alter a final matrix, this is why the only get function is getMixMatrix, to avoid other get functions returning incorrect/obsolete values.
*/
FMOD_RESULT F_API FMOD_ChannelGroup_SetPan (FMOD_CHANNELGROUP *channelgroup, float pan);
FMOD_RESULT F_API FMOD_ChannelGroup_SetMixLevelsOutput (FMOD_CHANNELGROUP *channelgroup, float frontleft, float frontright, float center, float lfe, float surroundleft, float surroundright, float backleft, float backright);
FMOD_RESULT F_API FMOD_ChannelGroup_SetMixLevelsInput (FMOD_CHANNELGROUP *channelgroup, float *levels, int numlevels);
FMOD_RESULT F_API FMOD_ChannelGroup_SetMixMatrix (FMOD_CHANNELGROUP *channelgroup, float *matrix, int outchannels, int inchannels, int inchannel_hop);
FMOD_RESULT F_API FMOD_ChannelGroup_GetMixMatrix (FMOD_CHANNELGROUP *channelgroup, float *matrix, int *outchannels, int *inchannels, int inchannel_hop);
/*
Clock based functionality.
*/
FMOD_RESULT F_API FMOD_ChannelGroup_GetDSPClock (FMOD_CHANNELGROUP *channelgroup, unsigned long long *dspclock, unsigned long long *parentclock);
FMOD_RESULT F_API FMOD_ChannelGroup_SetDelay (FMOD_CHANNELGROUP *channelgroup, unsigned long long dspclock_start, unsigned long long dspclock_end, FMOD_BOOL stopchannels);
FMOD_RESULT F_API FMOD_ChannelGroup_GetDelay (FMOD_CHANNELGROUP *channelgroup, unsigned long long *dspclock_start, unsigned long long *dspclock_end, FMOD_BOOL *stopchannels);
FMOD_RESULT F_API FMOD_ChannelGroup_AddFadePoint (FMOD_CHANNELGROUP *channelgroup, unsigned long long dspclock, float volume);
FMOD_RESULT F_API FMOD_ChannelGroup_SetFadePointRamp (FMOD_CHANNELGROUP *channelgroup, unsigned long long dspclock, float volume);
FMOD_RESULT F_API FMOD_ChannelGroup_RemoveFadePoints (FMOD_CHANNELGROUP *channelgroup, unsigned long long dspclock_start, unsigned long long dspclock_end);
FMOD_RESULT F_API FMOD_ChannelGroup_GetFadePoints (FMOD_CHANNELGROUP *channelgroup, unsigned int *numpoints, unsigned long long *point_dspclock, float *point_volume);
/*
DSP effects.
*/
FMOD_RESULT F_API FMOD_ChannelGroup_GetDSP (FMOD_CHANNELGROUP *channelgroup, int index, FMOD_DSP **dsp);
FMOD_RESULT F_API FMOD_ChannelGroup_AddDSP (FMOD_CHANNELGROUP *channelgroup, int index, FMOD_DSP *dsp);
FMOD_RESULT F_API FMOD_ChannelGroup_RemoveDSP (FMOD_CHANNELGROUP *channelgroup, FMOD_DSP *dsp);
FMOD_RESULT F_API FMOD_ChannelGroup_GetNumDSPs (FMOD_CHANNELGROUP *channelgroup, int *numdsps);
FMOD_RESULT F_API FMOD_ChannelGroup_SetDSPIndex (FMOD_CHANNELGROUP *channelgroup, FMOD_DSP *dsp, int index);
FMOD_RESULT F_API FMOD_ChannelGroup_GetDSPIndex (FMOD_CHANNELGROUP *channelgroup, FMOD_DSP *dsp, int *index);
/*
3D functionality.
*/
FMOD_RESULT F_API FMOD_ChannelGroup_Set3DAttributes (FMOD_CHANNELGROUP *channelgroup, const FMOD_VECTOR *pos, const FMOD_VECTOR *vel);
FMOD_RESULT F_API FMOD_ChannelGroup_Get3DAttributes (FMOD_CHANNELGROUP *channelgroup, FMOD_VECTOR *pos, FMOD_VECTOR *vel);
FMOD_RESULT F_API FMOD_ChannelGroup_Set3DMinMaxDistance (FMOD_CHANNELGROUP *channelgroup, float mindistance, float maxdistance);
FMOD_RESULT F_API FMOD_ChannelGroup_Get3DMinMaxDistance (FMOD_CHANNELGROUP *channelgroup, float *mindistance, float *maxdistance);
FMOD_RESULT F_API FMOD_ChannelGroup_Set3DConeSettings (FMOD_CHANNELGROUP *channelgroup, float insideconeangle, float outsideconeangle, float outsidevolume);
FMOD_RESULT F_API FMOD_ChannelGroup_Get3DConeSettings (FMOD_CHANNELGROUP *channelgroup, float *insideconeangle, float *outsideconeangle, float *outsidevolume);
FMOD_RESULT F_API FMOD_ChannelGroup_Set3DConeOrientation(FMOD_CHANNELGROUP *channelgroup, FMOD_VECTOR *orientation);
FMOD_RESULT F_API FMOD_ChannelGroup_Get3DConeOrientation(FMOD_CHANNELGROUP *channelgroup, FMOD_VECTOR *orientation);
FMOD_RESULT F_API FMOD_ChannelGroup_Set3DCustomRolloff (FMOD_CHANNELGROUP *channelgroup, FMOD_VECTOR *points, int numpoints);
FMOD_RESULT F_API FMOD_ChannelGroup_Get3DCustomRolloff (FMOD_CHANNELGROUP *channelgroup, FMOD_VECTOR **points, int *numpoints);
FMOD_RESULT F_API FMOD_ChannelGroup_Set3DOcclusion (FMOD_CHANNELGROUP *channelgroup, float directocclusion, float reverbocclusion);
FMOD_RESULT F_API FMOD_ChannelGroup_Get3DOcclusion (FMOD_CHANNELGROUP *channelgroup, float *directocclusion, float *reverbocclusion);
FMOD_RESULT F_API FMOD_ChannelGroup_Set3DSpread (FMOD_CHANNELGROUP *channelgroup, float angle);
FMOD_RESULT F_API FMOD_ChannelGroup_Get3DSpread (FMOD_CHANNELGROUP *channelgroup, float *angle);
FMOD_RESULT F_API FMOD_ChannelGroup_Set3DLevel (FMOD_CHANNELGROUP *channelgroup, float level);
FMOD_RESULT F_API FMOD_ChannelGroup_Get3DLevel (FMOD_CHANNELGROUP *channelgroup, float *level);
FMOD_RESULT F_API FMOD_ChannelGroup_Set3DDopplerLevel (FMOD_CHANNELGROUP *channelgroup, float level);
FMOD_RESULT F_API FMOD_ChannelGroup_Get3DDopplerLevel (FMOD_CHANNELGROUP *channelgroup, float *level);
FMOD_RESULT F_API FMOD_ChannelGroup_Set3DDistanceFilter (FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL custom, float customLevel, float centerFreq);
FMOD_RESULT F_API FMOD_ChannelGroup_Get3DDistanceFilter (FMOD_CHANNELGROUP *channelgroup, FMOD_BOOL *custom, float *customLevel, float *centerFreq);
/*
Userdata set/get.
*/
FMOD_RESULT F_API FMOD_ChannelGroup_SetUserData (FMOD_CHANNELGROUP *channelgroup, void *userdata);
FMOD_RESULT F_API FMOD_ChannelGroup_GetUserData (FMOD_CHANNELGROUP *channelgroup, void **userdata);
FMOD_RESULT F_API FMOD_ChannelGroup_Release (FMOD_CHANNELGROUP *channelgroup);
/*
Nested channel groups.
*/
FMOD_RESULT F_API FMOD_ChannelGroup_AddGroup (FMOD_CHANNELGROUP *channelgroup, FMOD_CHANNELGROUP *group, FMOD_BOOL propagatedspclock, FMOD_DSPCONNECTION **connection);
FMOD_RESULT F_API FMOD_ChannelGroup_GetNumGroups (FMOD_CHANNELGROUP *channelgroup, int *numgroups);
FMOD_RESULT F_API FMOD_ChannelGroup_GetGroup (FMOD_CHANNELGROUP *channelgroup, int index, FMOD_CHANNELGROUP **group);
FMOD_RESULT F_API FMOD_ChannelGroup_GetParentGroup (FMOD_CHANNELGROUP *channelgroup, FMOD_CHANNELGROUP **group);
/*
Information only functions.
*/
FMOD_RESULT F_API FMOD_ChannelGroup_GetName (FMOD_CHANNELGROUP *channelgroup, char *name, int namelen);
FMOD_RESULT F_API FMOD_ChannelGroup_GetNumChannels (FMOD_CHANNELGROUP *channelgroup, int *numchannels);
FMOD_RESULT F_API FMOD_ChannelGroup_GetChannel (FMOD_CHANNELGROUP *channelgroup, int index, FMOD_CHANNEL **channel);
/*
'SoundGroup' API
*/
FMOD_RESULT F_API FMOD_SoundGroup_Release (FMOD_SOUNDGROUP *soundgroup);
FMOD_RESULT F_API FMOD_SoundGroup_GetSystemObject (FMOD_SOUNDGROUP *soundgroup, FMOD_SYSTEM **system);
/*
SoundGroup control functions.
*/
FMOD_RESULT F_API FMOD_SoundGroup_SetMaxAudible (FMOD_SOUNDGROUP *soundgroup, int maxaudible);
FMOD_RESULT F_API FMOD_SoundGroup_GetMaxAudible (FMOD_SOUNDGROUP *soundgroup, int *maxaudible);
FMOD_RESULT F_API FMOD_SoundGroup_SetMaxAudibleBehavior (FMOD_SOUNDGROUP *soundgroup, FMOD_SOUNDGROUP_BEHAVIOR behavior);
FMOD_RESULT F_API FMOD_SoundGroup_GetMaxAudibleBehavior (FMOD_SOUNDGROUP *soundgroup, FMOD_SOUNDGROUP_BEHAVIOR *behavior);
FMOD_RESULT F_API FMOD_SoundGroup_SetMuteFadeSpeed (FMOD_SOUNDGROUP *soundgroup, float speed);
FMOD_RESULT F_API FMOD_SoundGroup_GetMuteFadeSpeed (FMOD_SOUNDGROUP *soundgroup, float *speed);
FMOD_RESULT F_API FMOD_SoundGroup_SetVolume (FMOD_SOUNDGROUP *soundgroup, float volume);
FMOD_RESULT F_API FMOD_SoundGroup_GetVolume (FMOD_SOUNDGROUP *soundgroup, float *volume);
FMOD_RESULT F_API FMOD_SoundGroup_Stop (FMOD_SOUNDGROUP *soundgroup);
/*
Information only functions.
*/
FMOD_RESULT F_API FMOD_SoundGroup_GetName (FMOD_SOUNDGROUP *soundgroup, char *name, int namelen);
FMOD_RESULT F_API FMOD_SoundGroup_GetNumSounds (FMOD_SOUNDGROUP *soundgroup, int *numsounds);
FMOD_RESULT F_API FMOD_SoundGroup_GetSound (FMOD_SOUNDGROUP *soundgroup, int index, FMOD_SOUND **sound);
FMOD_RESULT F_API FMOD_SoundGroup_GetNumPlaying (FMOD_SOUNDGROUP *soundgroup, int *numplaying);
/*
Userdata set/get.
*/
FMOD_RESULT F_API FMOD_SoundGroup_SetUserData (FMOD_SOUNDGROUP *soundgroup, void *userdata);
FMOD_RESULT F_API FMOD_SoundGroup_GetUserData (FMOD_SOUNDGROUP *soundgroup, void **userdata);
/*
'DSP' API
*/
FMOD_RESULT F_API FMOD_DSP_Release (FMOD_DSP *dsp);
FMOD_RESULT F_API FMOD_DSP_GetSystemObject (FMOD_DSP *dsp, FMOD_SYSTEM **system);
/*
Connection / disconnection / input and output enumeration.
*/
FMOD_RESULT F_API FMOD_DSP_AddInput (FMOD_DSP *dsp, FMOD_DSP *input, FMOD_DSPCONNECTION **connection, FMOD_DSPCONNECTION_TYPE type);
FMOD_RESULT F_API FMOD_DSP_DisconnectFrom (FMOD_DSP *dsp, FMOD_DSP *target, FMOD_DSPCONNECTION *connection);
FMOD_RESULT F_API FMOD_DSP_DisconnectAll (FMOD_DSP *dsp, FMOD_BOOL inputs, FMOD_BOOL outputs);
FMOD_RESULT F_API FMOD_DSP_GetNumInputs (FMOD_DSP *dsp, int *numinputs);
FMOD_RESULT F_API FMOD_DSP_GetNumOutputs (FMOD_DSP *dsp, int *numoutputs);
FMOD_RESULT F_API FMOD_DSP_GetInput (FMOD_DSP *dsp, int index, FMOD_DSP **input, FMOD_DSPCONNECTION **inputconnection);
FMOD_RESULT F_API FMOD_DSP_GetOutput (FMOD_DSP *dsp, int index, FMOD_DSP **output, FMOD_DSPCONNECTION **outputconnection);
/*
DSP unit control.
*/
FMOD_RESULT F_API FMOD_DSP_SetActive (FMOD_DSP *dsp, FMOD_BOOL active);
FMOD_RESULT F_API FMOD_DSP_GetActive (FMOD_DSP *dsp, FMOD_BOOL *active);
FMOD_RESULT F_API FMOD_DSP_SetBypass (FMOD_DSP *dsp, FMOD_BOOL bypass);
FMOD_RESULT F_API FMOD_DSP_GetBypass (FMOD_DSP *dsp, FMOD_BOOL *bypass);
FMOD_RESULT F_API FMOD_DSP_SetWetDryMix (FMOD_DSP *dsp, float prewet, float postwet, float dry);
FMOD_RESULT F_API FMOD_DSP_GetWetDryMix (FMOD_DSP *dsp, float *prewet, float *postwet, float *dry);
FMOD_RESULT F_API FMOD_DSP_SetChannelFormat (FMOD_DSP *dsp, FMOD_CHANNELMASK channelmask, int numchannels, FMOD_SPEAKERMODE source_speakermode);
FMOD_RESULT F_API FMOD_DSP_GetChannelFormat (FMOD_DSP *dsp, FMOD_CHANNELMASK *channelmask, int *numchannels, FMOD_SPEAKERMODE *source_speakermode);
FMOD_RESULT F_API FMOD_DSP_GetOutputChannelFormat (FMOD_DSP *dsp, FMOD_CHANNELMASK inmask, int inchannels, FMOD_SPEAKERMODE inspeakermode, FMOD_CHANNELMASK *outmask, int *outchannels, FMOD_SPEAKERMODE *outspeakermode);
FMOD_RESULT F_API FMOD_DSP_Reset (FMOD_DSP *dsp);
FMOD_RESULT F_API FMOD_DSP_SetCallback (FMOD_DSP *dsp, FMOD_DSP_CALLBACK callback);
/*
DSP parameter control.
*/
FMOD_RESULT F_API FMOD_DSP_SetParameterFloat (FMOD_DSP *dsp, int index, float value);
FMOD_RESULT F_API FMOD_DSP_SetParameterInt (FMOD_DSP *dsp, int index, int value);
FMOD_RESULT F_API FMOD_DSP_SetParameterBool (FMOD_DSP *dsp, int index, FMOD_BOOL value);
FMOD_RESULT F_API FMOD_DSP_SetParameterData (FMOD_DSP *dsp, int index, void *data, unsigned int length);
FMOD_RESULT F_API FMOD_DSP_GetParameterFloat (FMOD_DSP *dsp, int index, float *value, char *valuestr, int valuestrlen);
FMOD_RESULT F_API FMOD_DSP_GetParameterInt (FMOD_DSP *dsp, int index, int *value, char *valuestr, int valuestrlen);
FMOD_RESULT F_API FMOD_DSP_GetParameterBool (FMOD_DSP *dsp, int index, FMOD_BOOL *value, char *valuestr, int valuestrlen);
FMOD_RESULT F_API FMOD_DSP_GetParameterData (FMOD_DSP *dsp, int index, void **data, unsigned int *length, char *valuestr, int valuestrlen);
FMOD_RESULT F_API FMOD_DSP_GetNumParameters (FMOD_DSP *dsp, int *numparams);
FMOD_RESULT F_API FMOD_DSP_GetParameterInfo (FMOD_DSP *dsp, int index, FMOD_DSP_PARAMETER_DESC **desc);
FMOD_RESULT F_API FMOD_DSP_GetDataParameterIndex (FMOD_DSP *dsp, int datatype, int *index);
FMOD_RESULT F_API FMOD_DSP_ShowConfigDialog (FMOD_DSP *dsp, void *hwnd, FMOD_BOOL show);
/*
DSP attributes.
*/
FMOD_RESULT F_API FMOD_DSP_GetInfo (FMOD_DSP *dsp, char *name, unsigned int *version, int *channels, int *configwidth, int *configheight);
FMOD_RESULT F_API FMOD_DSP_GetType (FMOD_DSP *dsp, FMOD_DSP_TYPE *type);
FMOD_RESULT F_API FMOD_DSP_GetIdle (FMOD_DSP *dsp, FMOD_BOOL *idle);
/*
Userdata set/get.
*/
FMOD_RESULT F_API FMOD_DSP_SetUserData (FMOD_DSP *dsp, void *userdata);
FMOD_RESULT F_API FMOD_DSP_GetUserData (FMOD_DSP *dsp, void **userdata);
/*
Metering.
*/
FMOD_RESULT F_API FMOD_DSP_SetMeteringEnabled (FMOD_DSP *dsp, FMOD_BOOL inputEnabled, FMOD_BOOL outputEnabled);
FMOD_RESULT F_API FMOD_DSP_GetMeteringEnabled (FMOD_DSP *dsp, FMOD_BOOL *inputEnabled, FMOD_BOOL *outputEnabled);
FMOD_RESULT F_API FMOD_DSP_GetMeteringInfo (FMOD_DSP *dsp, FMOD_DSP_METERING_INFO *inputInfo, FMOD_DSP_METERING_INFO *outputInfo);
FMOD_RESULT F_API FMOD_DSP_GetCPUUsage (FMOD_DSP *dsp, unsigned int *exclusive, unsigned int *inclusive);
/*
'DSPConnection' API
*/
FMOD_RESULT F_API FMOD_DSPConnection_GetInput (FMOD_DSPCONNECTION *dspconnection, FMOD_DSP **input);
FMOD_RESULT F_API FMOD_DSPConnection_GetOutput (FMOD_DSPCONNECTION *dspconnection, FMOD_DSP **output);
FMOD_RESULT F_API FMOD_DSPConnection_SetMix (FMOD_DSPCONNECTION *dspconnection, float volume);
FMOD_RESULT F_API FMOD_DSPConnection_GetMix (FMOD_DSPCONNECTION *dspconnection, float *volume);
FMOD_RESULT F_API FMOD_DSPConnection_SetMixMatrix (FMOD_DSPCONNECTION *dspconnection, float *matrix, int outchannels, int inchannels, int inchannel_hop);
FMOD_RESULT F_API FMOD_DSPConnection_GetMixMatrix (FMOD_DSPCONNECTION *dspconnection, float *matrix, int *outchannels, int *inchannels, int inchannel_hop);
FMOD_RESULT F_API FMOD_DSPConnection_GetType (FMOD_DSPCONNECTION *dspconnection, FMOD_DSPCONNECTION_TYPE *type);
/*
Userdata set/get.
*/
FMOD_RESULT F_API FMOD_DSPConnection_SetUserData (FMOD_DSPCONNECTION *dspconnection, void *userdata);
FMOD_RESULT F_API FMOD_DSPConnection_GetUserData (FMOD_DSPCONNECTION *dspconnection, void **userdata);
/*
'Geometry' API
*/
FMOD_RESULT F_API FMOD_Geometry_Release (FMOD_GEOMETRY *geometry);
/*
Polygon manipulation.
*/
FMOD_RESULT F_API FMOD_Geometry_AddPolygon (FMOD_GEOMETRY *geometry, float directocclusion, float reverbocclusion, FMOD_BOOL doublesided, int numvertices, const FMOD_VECTOR *vertices, int *polygonindex);
FMOD_RESULT F_API FMOD_Geometry_GetNumPolygons (FMOD_GEOMETRY *geometry, int *numpolygons);
FMOD_RESULT F_API FMOD_Geometry_GetMaxPolygons (FMOD_GEOMETRY *geometry, int *maxpolygons, int *maxvertices);
FMOD_RESULT F_API FMOD_Geometry_GetPolygonNumVertices (FMOD_GEOMETRY *geometry, int index, int *numvertices);
FMOD_RESULT F_API FMOD_Geometry_SetPolygonVertex (FMOD_GEOMETRY *geometry, int index, int vertexindex, const FMOD_VECTOR *vertex);
FMOD_RESULT F_API FMOD_Geometry_GetPolygonVertex (FMOD_GEOMETRY *geometry, int index, int vertexindex, FMOD_VECTOR *vertex);
FMOD_RESULT F_API FMOD_Geometry_SetPolygonAttributes (FMOD_GEOMETRY *geometry, int index, float directocclusion, float reverbocclusion, FMOD_BOOL doublesided);
FMOD_RESULT F_API FMOD_Geometry_GetPolygonAttributes (FMOD_GEOMETRY *geometry, int index, float *directocclusion, float *reverbocclusion, FMOD_BOOL *doublesided);
/*
Object manipulation.
*/
FMOD_RESULT F_API FMOD_Geometry_SetActive (FMOD_GEOMETRY *geometry, FMOD_BOOL active);
FMOD_RESULT F_API FMOD_Geometry_GetActive (FMOD_GEOMETRY *geometry, FMOD_BOOL *active);
FMOD_RESULT F_API FMOD_Geometry_SetRotation (FMOD_GEOMETRY *geometry, const FMOD_VECTOR *forward, const FMOD_VECTOR *up);
FMOD_RESULT F_API FMOD_Geometry_GetRotation (FMOD_GEOMETRY *geometry, FMOD_VECTOR *forward, FMOD_VECTOR *up);
FMOD_RESULT F_API FMOD_Geometry_SetPosition (FMOD_GEOMETRY *geometry, const FMOD_VECTOR *position);
FMOD_RESULT F_API FMOD_Geometry_GetPosition (FMOD_GEOMETRY *geometry, FMOD_VECTOR *position);
FMOD_RESULT F_API FMOD_Geometry_SetScale (FMOD_GEOMETRY *geometry, const FMOD_VECTOR *scale);
FMOD_RESULT F_API FMOD_Geometry_GetScale (FMOD_GEOMETRY *geometry, FMOD_VECTOR *scale);
FMOD_RESULT F_API FMOD_Geometry_Save (FMOD_GEOMETRY *geometry, void *data, int *datasize);
/*
Userdata set/get.
*/
FMOD_RESULT F_API FMOD_Geometry_SetUserData (FMOD_GEOMETRY *geometry, void *userdata);
FMOD_RESULT F_API FMOD_Geometry_GetUserData (FMOD_GEOMETRY *geometry, void **userdata);
/*
'Reverb3D' API
*/
FMOD_RESULT F_API FMOD_Reverb3D_Release (FMOD_REVERB3D *reverb3d);
/*
Reverb manipulation.
*/
FMOD_RESULT F_API FMOD_Reverb3D_Set3DAttributes (FMOD_REVERB3D *reverb3d, const FMOD_VECTOR *position, float mindistance, float maxdistance);
FMOD_RESULT F_API FMOD_Reverb3D_Get3DAttributes (FMOD_REVERB3D *reverb3d, FMOD_VECTOR *position, float *mindistance, float *maxdistance);
FMOD_RESULT F_API FMOD_Reverb3D_SetProperties (FMOD_REVERB3D *reverb3d, const FMOD_REVERB_PROPERTIES *properties);
FMOD_RESULT F_API FMOD_Reverb3D_GetProperties (FMOD_REVERB3D *reverb3d, FMOD_REVERB_PROPERTIES *properties);
FMOD_RESULT F_API FMOD_Reverb3D_SetActive (FMOD_REVERB3D *reverb3d, FMOD_BOOL active);
FMOD_RESULT F_API FMOD_Reverb3D_GetActive (FMOD_REVERB3D *reverb3d, FMOD_BOOL *active);
/*
Userdata set/get.
*/
FMOD_RESULT F_API FMOD_Reverb3D_SetUserData (FMOD_REVERB3D *reverb3d, void *userdata);
FMOD_RESULT F_API FMOD_Reverb3D_GetUserData (FMOD_REVERB3D *reverb3d, void **userdata);
#ifdef __cplusplus
}
#endif
#endif /* _FMOD_H */
3rdparty/fmod/include/fmod_codec.h
Vendored
+136
View File
@@ -0,0 +1,136 @@
/* ======================================================================================== */
/* FMOD Core API - Codec development header file. */
/* Copyright (c), Firelight Technologies Pty, Ltd. 2004-2023. */
/* */
/* Use this header if you are wanting to develop your own file format plugin to use with */
/* FMOD's codec system. With this header you can make your own fileformat plugin that FMOD */
/* can register and use. See the documentation and examples on how to make a working */
/* plugin. */
/* */
/* For more detail visit: */
/* https://fmod.com/docs/2.02/api/core-api.html */
/* ======================================================================================== */
#ifndef _FMOD_CODEC_H
#define _FMOD_CODEC_H
/*
Codec types
*/
typedef struct FMOD_CODEC_STATE FMOD_CODEC_STATE;
typedef struct FMOD_CODEC_WAVEFORMAT FMOD_CODEC_WAVEFORMAT;
/*
Codec constants
*/
#define FMOD_CODEC_PLUGIN_VERSION 1
typedef int FMOD_CODEC_SEEK_METHOD;
#define FMOD_CODEC_SEEK_METHOD_SET 0
#define FMOD_CODEC_SEEK_METHOD_CURRENT 1
#define FMOD_CODEC_SEEK_METHOD_END 2
/*
Codec callbacks
*/
typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_OPEN_CALLBACK) (FMOD_CODEC_STATE *codec_state, FMOD_MODE usermode, FMOD_CREATESOUNDEXINFO *userexinfo);
typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_CLOSE_CALLBACK) (FMOD_CODEC_STATE *codec_state);
typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_READ_CALLBACK) (FMOD_CODEC_STATE *codec_state, void *buffer, unsigned int samples_in, unsigned int *samples_out);
typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_GETLENGTH_CALLBACK) (FMOD_CODEC_STATE *codec_state, unsigned int *length, FMOD_TIMEUNIT lengthtype);
typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_SETPOSITION_CALLBACK) (FMOD_CODEC_STATE *codec_state, int subsound, unsigned int position, FMOD_TIMEUNIT postype);
typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_GETPOSITION_CALLBACK) (FMOD_CODEC_STATE *codec_state, unsigned int *position, FMOD_TIMEUNIT postype);
typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_SOUNDCREATE_CALLBACK) (FMOD_CODEC_STATE *codec_state, int subsound, FMOD_SOUND *sound);
typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_GETWAVEFORMAT_CALLBACK)(FMOD_CODEC_STATE *codec_state, int index, FMOD_CODEC_WAVEFORMAT *waveformat);
/*
Codec functions
*/
typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_METADATA_FUNC) (FMOD_CODEC_STATE *codec_state, FMOD_TAGTYPE tagtype, char *name, void *data, unsigned int datalen, FMOD_TAGDATATYPE datatype, int unique);
typedef void * (F_CALLBACK *FMOD_CODEC_ALLOC_FUNC) (unsigned int size, unsigned int align, const char *file, int line);
typedef void (F_CALLBACK *FMOD_CODEC_FREE_FUNC) (void *ptr, const char *file, int line);
typedef void (F_CALLBACK *FMOD_CODEC_LOG_FUNC) (FMOD_DEBUG_FLAGS level, const char *file, int line, const char *function, const char *string, ...);
typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_FILE_READ_FUNC) (FMOD_CODEC_STATE *codec_state, void *buffer, unsigned int sizebytes, unsigned int *bytesread);
typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_FILE_SEEK_FUNC) (FMOD_CODEC_STATE *codec_state, unsigned int pos, FMOD_CODEC_SEEK_METHOD method);
typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_FILE_TELL_FUNC) (FMOD_CODEC_STATE *codec_state, unsigned int *pos);
typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_FILE_SIZE_FUNC) (FMOD_CODEC_STATE *codec_state, unsigned int *size);
/*
Codec structures
*/
typedef struct FMOD_CODEC_DESCRIPTION
{
unsigned int apiversion;
const char *name;
unsigned int version;
int defaultasstream;
FMOD_TIMEUNIT timeunits;
FMOD_CODEC_OPEN_CALLBACK open;
FMOD_CODEC_CLOSE_CALLBACK close;
FMOD_CODEC_READ_CALLBACK read;
FMOD_CODEC_GETLENGTH_CALLBACK getlength;
FMOD_CODEC_SETPOSITION_CALLBACK setposition;
FMOD_CODEC_GETPOSITION_CALLBACK getposition;
FMOD_CODEC_SOUNDCREATE_CALLBACK soundcreate;
FMOD_CODEC_GETWAVEFORMAT_CALLBACK getwaveformat;
} FMOD_CODEC_DESCRIPTION;
struct FMOD_CODEC_WAVEFORMAT
{
const char* name;
FMOD_SOUND_FORMAT format;
int channels;
int frequency;
unsigned int lengthbytes;
unsigned int lengthpcm;
unsigned int pcmblocksize;
int loopstart;
int loopend;
FMOD_MODE mode;
FMOD_CHANNELMASK channelmask;
FMOD_CHANNELORDER channelorder;
float peakvolume;
};
typedef struct FMOD_CODEC_STATE_FUNCTIONS
{
FMOD_CODEC_METADATA_FUNC metadata;
FMOD_CODEC_ALLOC_FUNC alloc;
FMOD_CODEC_FREE_FUNC free;
FMOD_CODEC_LOG_FUNC log;
FMOD_CODEC_FILE_READ_FUNC read;
FMOD_CODEC_FILE_SEEK_FUNC seek;
FMOD_CODEC_FILE_TELL_FUNC tell;
FMOD_CODEC_FILE_SIZE_FUNC size;
} FMOD_CODEC_STATE_FUNCTIONS;
struct FMOD_CODEC_STATE
{
void *plugindata;
FMOD_CODEC_WAVEFORMAT *waveformat;
FMOD_CODEC_STATE_FUNCTIONS *functions;
int numsubsounds;
};
/*
Codec macros
*/
#define FMOD_CODEC_METADATA(_state, _tagtype, _name, _data, _datalen, _datatype, _unique) \
(_state)->functions->metadata(_state, _tagtype, _name, _data, _datalen, _datatype, _unique)
#define FMOD_CODEC_ALLOC(_state, _size, _align) \
(_state)->functions->alloc(_size, _align, __FILE__, __LINE__)
#define FMOD_CODEC_FREE(_state, _ptr) \
(_state)->functions->free(_ptr, __FILE__, __LINE__)
#define FMOD_CODEC_LOG(_state, _level, _location, _format, ...) \
(_state)->functions->log(_level, __FILE__, __LINE__, _location, _format, __VA_ARGS__)
#define FMOD_CODEC_FILE_READ(_state, _buffer, _sizebytes, _bytesread) \
(_state)->functions->read(_state, _buffer, _sizebytes, _bytesread)
#define FMOD_CODEC_FILE_SEEK(_state, _pos, _method) \
(_state)->functions->seek(_state, _pos, _method)
#define FMOD_CODEC_FILE_TELL(_state, _pos) \
(_state)->functions->tell(_state, _pos)
#define FMOD_CODEC_FILE_SIZE(_state, _size) \
(_state)->functions->size(_state, _size)
#endif
3rdparty/fmod/include/fmod_common.h
Vendored
+899
View File
@@ -0,0 +1,899 @@
/* ======================================================================================== */
/* FMOD Core API - Common C/C++ header file. */
/* Copyright (c), Firelight Technologies Pty, Ltd. 2004-2023. */
/* */
/* This header is included by fmod.hpp (C++ interface) and fmod.h (C interface) */
/* */
/* For more detail visit: */
/* https://fmod.com/docs/2.02/api/core-api-common.html */
/* ======================================================================================== */
#ifndef _FMOD_COMMON_H
#define _FMOD_COMMON_H
/*
Library import helpers
*/
#if defined(_WIN32) || defined(__CYGWIN__)
#define F_CALL __stdcall
#else
#define F_CALL
#endif
#if defined(_WIN32) || defined(__CYGWIN__) || defined(__ORBIS__) || defined(F_USE_DECLSPEC)
#define F_EXPORT __declspec(dllexport)
#elif defined(__APPLE__) || defined(__ANDROID__) || defined(__linux__) || defined(F_USE_ATTRIBUTE)
#define F_EXPORT __attribute__((visibility("default")))
#else
#define F_EXPORT
#endif
#ifdef DLL_EXPORTS
#define F_API F_EXPORT F_CALL
#else
#define F_API F_CALL
#endif
#define F_CALLBACK F_CALL
/*
FMOD core types
*/
typedef int FMOD_BOOL;
typedef struct FMOD_SYSTEM FMOD_SYSTEM;
typedef struct FMOD_SOUND FMOD_SOUND;
typedef struct FMOD_CHANNELCONTROL FMOD_CHANNELCONTROL;
typedef struct FMOD_CHANNEL FMOD_CHANNEL;
typedef struct FMOD_CHANNELGROUP FMOD_CHANNELGROUP;
typedef struct FMOD_SOUNDGROUP FMOD_SOUNDGROUP;
typedef struct FMOD_REVERB3D FMOD_REVERB3D;
typedef struct FMOD_DSP FMOD_DSP;
typedef struct FMOD_DSPCONNECTION FMOD_DSPCONNECTION;
typedef struct FMOD_POLYGON FMOD_POLYGON;
typedef struct FMOD_GEOMETRY FMOD_GEOMETRY;
typedef struct FMOD_SYNCPOINT FMOD_SYNCPOINT;
typedef struct FMOD_ASYNCREADINFO FMOD_ASYNCREADINFO;
/*
FMOD constants
*/
#define FMOD_VERSION 0x00020218 /* 0xaaaabbcc -> aaaa = product version, bb = major version, cc = minor version.*/
typedef unsigned int FMOD_DEBUG_FLAGS;
#define FMOD_DEBUG_LEVEL_NONE 0x00000000
#define FMOD_DEBUG_LEVEL_ERROR 0x00000001
#define FMOD_DEBUG_LEVEL_WARNING 0x00000002
#define FMOD_DEBUG_LEVEL_LOG 0x00000004
#define FMOD_DEBUG_TYPE_MEMORY 0x00000100
#define FMOD_DEBUG_TYPE_FILE 0x00000200
#define FMOD_DEBUG_TYPE_CODEC 0x00000400
#define FMOD_DEBUG_TYPE_TRACE 0x00000800
#define FMOD_DEBUG_DISPLAY_TIMESTAMPS 0x00010000
#define FMOD_DEBUG_DISPLAY_LINENUMBERS 0x00020000
#define FMOD_DEBUG_DISPLAY_THREAD 0x00040000
typedef unsigned int FMOD_MEMORY_TYPE;
#define FMOD_MEMORY_NORMAL 0x00000000
#define FMOD_MEMORY_STREAM_FILE 0x00000001
#define FMOD_MEMORY_STREAM_DECODE 0x00000002
#define FMOD_MEMORY_SAMPLEDATA 0x00000004
#define FMOD_MEMORY_DSP_BUFFER 0x00000008
#define FMOD_MEMORY_PLUGIN 0x00000010
#define FMOD_MEMORY_PERSISTENT 0x00200000
#define FMOD_MEMORY_ALL 0xFFFFFFFF
typedef unsigned int FMOD_INITFLAGS;
#define FMOD_INIT_NORMAL 0x00000000
#define FMOD_INIT_STREAM_FROM_UPDATE 0x00000001
#define FMOD_INIT_MIX_FROM_UPDATE 0x00000002
#define FMOD_INIT_3D_RIGHTHANDED 0x00000004
#define FMOD_INIT_CLIP_OUTPUT 0x00000008
#define FMOD_INIT_CHANNEL_LOWPASS 0x00000100
#define FMOD_INIT_CHANNEL_DISTANCEFILTER 0x00000200
#define FMOD_INIT_PROFILE_ENABLE 0x00010000
#define FMOD_INIT_VOL0_BECOMES_VIRTUAL 0x00020000
#define FMOD_INIT_GEOMETRY_USECLOSEST 0x00040000
#define FMOD_INIT_PREFER_DOLBY_DOWNMIX 0x00080000
#define FMOD_INIT_THREAD_UNSAFE 0x00100000
#define FMOD_INIT_PROFILE_METER_ALL 0x00200000
#define FMOD_INIT_MEMORY_TRACKING 0x00400000
typedef unsigned int FMOD_DRIVER_STATE;
#define FMOD_DRIVER_STATE_CONNECTED 0x00000001
#define FMOD_DRIVER_STATE_DEFAULT 0x00000002
typedef unsigned int FMOD_TIMEUNIT;
#define FMOD_TIMEUNIT_MS 0x00000001
#define FMOD_TIMEUNIT_PCM 0x00000002
#define FMOD_TIMEUNIT_PCMBYTES 0x00000004
#define FMOD_TIMEUNIT_RAWBYTES 0x00000008
#define FMOD_TIMEUNIT_PCMFRACTION 0x00000010
#define FMOD_TIMEUNIT_MODORDER 0x00000100
#define FMOD_TIMEUNIT_MODROW 0x00000200
#define FMOD_TIMEUNIT_MODPATTERN 0x00000400
typedef unsigned int FMOD_SYSTEM_CALLBACK_TYPE;
#define FMOD_SYSTEM_CALLBACK_DEVICELISTCHANGED 0x00000001
#define FMOD_SYSTEM_CALLBACK_DEVICELOST 0x00000002
#define FMOD_SYSTEM_CALLBACK_MEMORYALLOCATIONFAILED 0x00000004
#define FMOD_SYSTEM_CALLBACK_THREADCREATED 0x00000008
#define FMOD_SYSTEM_CALLBACK_BADDSPCONNECTION 0x00000010
#define FMOD_SYSTEM_CALLBACK_PREMIX 0x00000020
#define FMOD_SYSTEM_CALLBACK_POSTMIX 0x00000040
#define FMOD_SYSTEM_CALLBACK_ERROR 0x00000080
#define FMOD_SYSTEM_CALLBACK_MIDMIX 0x00000100
#define FMOD_SYSTEM_CALLBACK_THREADDESTROYED 0x00000200
#define FMOD_SYSTEM_CALLBACK_PREUPDATE 0x00000400
#define FMOD_SYSTEM_CALLBACK_POSTUPDATE 0x00000800
#define FMOD_SYSTEM_CALLBACK_RECORDLISTCHANGED 0x00001000
#define FMOD_SYSTEM_CALLBACK_BUFFEREDNOMIX 0x00002000
#define FMOD_SYSTEM_CALLBACK_DEVICEREINITIALIZE 0x00004000
#define FMOD_SYSTEM_CALLBACK_OUTPUTUNDERRUN 0x00008000
#define FMOD_SYSTEM_CALLBACK_RECORDPOSITIONCHANGED 0x00010000
#define FMOD_SYSTEM_CALLBACK_ALL 0xFFFFFFFF
typedef unsigned int FMOD_MODE;
#define FMOD_DEFAULT 0x00000000
#define FMOD_LOOP_OFF 0x00000001
#define FMOD_LOOP_NORMAL 0x00000002
#define FMOD_LOOP_BIDI 0x00000004
#define FMOD_2D 0x00000008
#define FMOD_3D 0x00000010
#define FMOD_CREATESTREAM 0x00000080
#define FMOD_CREATESAMPLE 0x00000100
#define FMOD_CREATECOMPRESSEDSAMPLE 0x00000200
#define FMOD_OPENUSER 0x00000400
#define FMOD_OPENMEMORY 0x00000800
#define FMOD_OPENMEMORY_POINT 0x10000000
#define FMOD_OPENRAW 0x00001000
#define FMOD_OPENONLY 0x00002000
#define FMOD_ACCURATETIME 0x00004000
#define FMOD_MPEGSEARCH 0x00008000
#define FMOD_NONBLOCKING 0x00010000
#define FMOD_UNIQUE 0x00020000
#define FMOD_3D_HEADRELATIVE 0x00040000
#define FMOD_3D_WORLDRELATIVE 0x00080000
#define FMOD_3D_INVERSEROLLOFF 0x00100000
#define FMOD_3D_LINEARROLLOFF 0x00200000
#define FMOD_3D_LINEARSQUAREROLLOFF 0x00400000
#define FMOD_3D_INVERSETAPEREDROLLOFF 0x00800000
#define FMOD_3D_CUSTOMROLLOFF 0x04000000
#define FMOD_3D_IGNOREGEOMETRY 0x40000000
#define FMOD_IGNORETAGS 0x02000000
#define FMOD_LOWMEM 0x08000000
#define FMOD_VIRTUAL_PLAYFROMSTART 0x80000000
typedef unsigned int FMOD_CHANNELMASK;
#define FMOD_CHANNELMASK_FRONT_LEFT 0x00000001
#define FMOD_CHANNELMASK_FRONT_RIGHT 0x00000002
#define FMOD_CHANNELMASK_FRONT_CENTER 0x00000004
#define FMOD_CHANNELMASK_LOW_FREQUENCY 0x00000008
#define FMOD_CHANNELMASK_SURROUND_LEFT 0x00000010
#define FMOD_CHANNELMASK_SURROUND_RIGHT 0x00000020
#define FMOD_CHANNELMASK_BACK_LEFT 0x00000040
#define FMOD_CHANNELMASK_BACK_RIGHT 0x00000080
#define FMOD_CHANNELMASK_BACK_CENTER 0x00000100
#define FMOD_CHANNELMASK_MONO (FMOD_CHANNELMASK_FRONT_LEFT)
#define FMOD_CHANNELMASK_STEREO (FMOD_CHANNELMASK_FRONT_LEFT | FMOD_CHANNELMASK_FRONT_RIGHT)
#define FMOD_CHANNELMASK_LRC (FMOD_CHANNELMASK_FRONT_LEFT | FMOD_CHANNELMASK_FRONT_RIGHT | FMOD_CHANNELMASK_FRONT_CENTER)
#define FMOD_CHANNELMASK_QUAD (FMOD_CHANNELMASK_FRONT_LEFT | FMOD_CHANNELMASK_FRONT_RIGHT | FMOD_CHANNELMASK_SURROUND_LEFT | FMOD_CHANNELMASK_SURROUND_RIGHT)
#define FMOD_CHANNELMASK_SURROUND (FMOD_CHANNELMASK_FRONT_LEFT | FMOD_CHANNELMASK_FRONT_RIGHT | FMOD_CHANNELMASK_FRONT_CENTER | FMOD_CHANNELMASK_SURROUND_LEFT | FMOD_CHANNELMASK_SURROUND_RIGHT)
#define FMOD_CHANNELMASK_5POINT1 (FMOD_CHANNELMASK_FRONT_LEFT | FMOD_CHANNELMASK_FRONT_RIGHT | FMOD_CHANNELMASK_FRONT_CENTER | FMOD_CHANNELMASK_LOW_FREQUENCY | FMOD_CHANNELMASK_SURROUND_LEFT | FMOD_CHANNELMASK_SURROUND_RIGHT)
#define FMOD_CHANNELMASK_5POINT1_REARS (FMOD_CHANNELMASK_FRONT_LEFT | FMOD_CHANNELMASK_FRONT_RIGHT | FMOD_CHANNELMASK_FRONT_CENTER | FMOD_CHANNELMASK_LOW_FREQUENCY | FMOD_CHANNELMASK_BACK_LEFT | FMOD_CHANNELMASK_BACK_RIGHT)
#define FMOD_CHANNELMASK_7POINT0 (FMOD_CHANNELMASK_FRONT_LEFT | FMOD_CHANNELMASK_FRONT_RIGHT | FMOD_CHANNELMASK_FRONT_CENTER | FMOD_CHANNELMASK_SURROUND_LEFT | FMOD_CHANNELMASK_SURROUND_RIGHT | FMOD_CHANNELMASK_BACK_LEFT | FMOD_CHANNELMASK_BACK_RIGHT)
#define FMOD_CHANNELMASK_7POINT1 (FMOD_CHANNELMASK_FRONT_LEFT | FMOD_CHANNELMASK_FRONT_RIGHT | FMOD_CHANNELMASK_FRONT_CENTER | FMOD_CHANNELMASK_LOW_FREQUENCY | FMOD_CHANNELMASK_SURROUND_LEFT | FMOD_CHANNELMASK_SURROUND_RIGHT | FMOD_CHANNELMASK_BACK_LEFT | FMOD_CHANNELMASK_BACK_RIGHT)
typedef unsigned long long FMOD_PORT_INDEX;
#define FMOD_PORT_INDEX_NONE 0xFFFFFFFFFFFFFFFF
#define FMOD_PORT_INDEX_FLAG_VR_CONTROLLER 0x1000000000000000
typedef int FMOD_THREAD_PRIORITY;
/* Platform specific priority range */
#define FMOD_THREAD_PRIORITY_PLATFORM_MIN (-32 * 1024)
#define FMOD_THREAD_PRIORITY_PLATFORM_MAX ( 32 * 1024)
/* Platform agnostic priorities, maps internally to platform specific value */
#define FMOD_THREAD_PRIORITY_DEFAULT (FMOD_THREAD_PRIORITY_PLATFORM_MIN - 1)
#define FMOD_THREAD_PRIORITY_LOW (FMOD_THREAD_PRIORITY_PLATFORM_MIN - 2)
#define FMOD_THREAD_PRIORITY_MEDIUM (FMOD_THREAD_PRIORITY_PLATFORM_MIN - 3)
#define FMOD_THREAD_PRIORITY_HIGH (FMOD_THREAD_PRIORITY_PLATFORM_MIN - 4)
#define FMOD_THREAD_PRIORITY_VERY_HIGH (FMOD_THREAD_PRIORITY_PLATFORM_MIN - 5)
#define FMOD_THREAD_PRIORITY_EXTREME (FMOD_THREAD_PRIORITY_PLATFORM_MIN - 6)
#define FMOD_THREAD_PRIORITY_CRITICAL (FMOD_THREAD_PRIORITY_PLATFORM_MIN - 7)
/* Thread defaults */
#define FMOD_THREAD_PRIORITY_MIXER FMOD_THREAD_PRIORITY_EXTREME
#define FMOD_THREAD_PRIORITY_FEEDER FMOD_THREAD_PRIORITY_CRITICAL
#define FMOD_THREAD_PRIORITY_STREAM FMOD_THREAD_PRIORITY_VERY_HIGH
#define FMOD_THREAD_PRIORITY_FILE FMOD_THREAD_PRIORITY_HIGH
#define FMOD_THREAD_PRIORITY_NONBLOCKING FMOD_THREAD_PRIORITY_HIGH
#define FMOD_THREAD_PRIORITY_RECORD FMOD_THREAD_PRIORITY_HIGH
#define FMOD_THREAD_PRIORITY_GEOMETRY FMOD_THREAD_PRIORITY_LOW
#define FMOD_THREAD_PRIORITY_PROFILER FMOD_THREAD_PRIORITY_MEDIUM
#define FMOD_THREAD_PRIORITY_STUDIO_UPDATE FMOD_THREAD_PRIORITY_MEDIUM
#define FMOD_THREAD_PRIORITY_STUDIO_LOAD_BANK FMOD_THREAD_PRIORITY_MEDIUM
#define FMOD_THREAD_PRIORITY_STUDIO_LOAD_SAMPLE FMOD_THREAD_PRIORITY_MEDIUM
#define FMOD_THREAD_PRIORITY_CONVOLUTION1 FMOD_THREAD_PRIORITY_VERY_HIGH
#define FMOD_THREAD_PRIORITY_CONVOLUTION2 FMOD_THREAD_PRIORITY_VERY_HIGH
typedef unsigned int FMOD_THREAD_STACK_SIZE;
#define FMOD_THREAD_STACK_SIZE_DEFAULT 0
#define FMOD_THREAD_STACK_SIZE_MIXER (80 * 1024)
#define FMOD_THREAD_STACK_SIZE_FEEDER (16 * 1024)
#define FMOD_THREAD_STACK_SIZE_STREAM (96 * 1024)
#define FMOD_THREAD_STACK_SIZE_FILE (64 * 1024)
#define FMOD_THREAD_STACK_SIZE_NONBLOCKING (112 * 1024)
#define FMOD_THREAD_STACK_SIZE_RECORD (16 * 1024)
#define FMOD_THREAD_STACK_SIZE_GEOMETRY (48 * 1024)
#define FMOD_THREAD_STACK_SIZE_PROFILER (128 * 1024)
#define FMOD_THREAD_STACK_SIZE_STUDIO_UPDATE (96 * 1024)
#define FMOD_THREAD_STACK_SIZE_STUDIO_LOAD_BANK (96 * 1024)
#define FMOD_THREAD_STACK_SIZE_STUDIO_LOAD_SAMPLE (96 * 1024)
#define FMOD_THREAD_STACK_SIZE_CONVOLUTION1 (16 * 1024)
#define FMOD_THREAD_STACK_SIZE_CONVOLUTION2 (16 * 1024)
typedef long long FMOD_THREAD_AFFINITY;
/* Platform agnostic thread groupings */
#define FMOD_THREAD_AFFINITY_GROUP_DEFAULT 0x4000000000000000
#define FMOD_THREAD_AFFINITY_GROUP_A 0x4000000000000001
#define FMOD_THREAD_AFFINITY_GROUP_B 0x4000000000000002
#define FMOD_THREAD_AFFINITY_GROUP_C 0x4000000000000003
/* Thread defaults */
#define FMOD_THREAD_AFFINITY_MIXER FMOD_THREAD_AFFINITY_GROUP_A
#define FMOD_THREAD_AFFINITY_FEEDER FMOD_THREAD_AFFINITY_GROUP_C
#define FMOD_THREAD_AFFINITY_STREAM FMOD_THREAD_AFFINITY_GROUP_C
#define FMOD_THREAD_AFFINITY_FILE FMOD_THREAD_AFFINITY_GROUP_C
#define FMOD_THREAD_AFFINITY_NONBLOCKING FMOD_THREAD_AFFINITY_GROUP_C
#define FMOD_THREAD_AFFINITY_RECORD FMOD_THREAD_AFFINITY_GROUP_C
#define FMOD_THREAD_AFFINITY_GEOMETRY FMOD_THREAD_AFFINITY_GROUP_C
#define FMOD_THREAD_AFFINITY_PROFILER FMOD_THREAD_AFFINITY_GROUP_C
#define FMOD_THREAD_AFFINITY_STUDIO_UPDATE FMOD_THREAD_AFFINITY_GROUP_B
#define FMOD_THREAD_AFFINITY_STUDIO_LOAD_BANK FMOD_THREAD_AFFINITY_GROUP_C
#define FMOD_THREAD_AFFINITY_STUDIO_LOAD_SAMPLE FMOD_THREAD_AFFINITY_GROUP_C
#define FMOD_THREAD_AFFINITY_CONVOLUTION1 FMOD_THREAD_AFFINITY_GROUP_C
#define FMOD_THREAD_AFFINITY_CONVOLUTION2 FMOD_THREAD_AFFINITY_GROUP_C
/* Core mask, valid up to 1 << 62 */
#define FMOD_THREAD_AFFINITY_CORE_ALL 0
#define FMOD_THREAD_AFFINITY_CORE_0 (1 << 0)
#define FMOD_THREAD_AFFINITY_CORE_1 (1 << 1)
#define FMOD_THREAD_AFFINITY_CORE_2 (1 << 2)
#define FMOD_THREAD_AFFINITY_CORE_3 (1 << 3)
#define FMOD_THREAD_AFFINITY_CORE_4 (1 << 4)
#define FMOD_THREAD_AFFINITY_CORE_5 (1 << 5)
#define FMOD_THREAD_AFFINITY_CORE_6 (1 << 6)
#define FMOD_THREAD_AFFINITY_CORE_7 (1 << 7)
#define FMOD_THREAD_AFFINITY_CORE_8 (1 << 8)
#define FMOD_THREAD_AFFINITY_CORE_9 (1 << 9)
#define FMOD_THREAD_AFFINITY_CORE_10 (1 << 10)
#define FMOD_THREAD_AFFINITY_CORE_11 (1 << 11)
#define FMOD_THREAD_AFFINITY_CORE_12 (1 << 12)
#define FMOD_THREAD_AFFINITY_CORE_13 (1 << 13)
#define FMOD_THREAD_AFFINITY_CORE_14 (1 << 14)
#define FMOD_THREAD_AFFINITY_CORE_15 (1 << 15)
/* Preset for FMOD_REVERB_PROPERTIES */
#define FMOD_PRESET_OFF { 1000, 7, 11, 5000, 100, 100, 100, 250, 0, 20, 96, -80.0f }
#define FMOD_PRESET_GENERIC { 1500, 7, 11, 5000, 83, 100, 100, 250, 0, 14500, 96, -8.0f }
#define FMOD_PRESET_PADDEDCELL { 170, 1, 2, 5000, 10, 100, 100, 250, 0, 160, 84, -7.8f }
#define FMOD_PRESET_ROOM { 400, 2, 3, 5000, 83, 100, 100, 250, 0, 6050, 88, -9.4f }
#define FMOD_PRESET_BATHROOM { 1500, 7, 11, 5000, 54, 100, 60, 250, 0, 2900, 83, 0.5f }
#define FMOD_PRESET_LIVINGROOM { 500, 3, 4, 5000, 10, 100, 100, 250, 0, 160, 58, -19.0f }
#define FMOD_PRESET_STONEROOM { 2300, 12, 17, 5000, 64, 100, 100, 250, 0, 7800, 71, -8.5f }
#define FMOD_PRESET_AUDITORIUM { 4300, 20, 30, 5000, 59, 100, 100, 250, 0, 5850, 64, -11.7f }
#define FMOD_PRESET_CONCERTHALL { 3900, 20, 29, 5000, 70, 100, 100, 250, 0, 5650, 80, -9.8f }
#define FMOD_PRESET_CAVE { 2900, 15, 22, 5000, 100, 100, 100, 250, 0, 20000, 59, -11.3f }
#define FMOD_PRESET_ARENA { 7200, 20, 30, 5000, 33, 100, 100, 250, 0, 4500, 80, -9.6f }
#define FMOD_PRESET_HANGAR { 10000, 20, 30, 5000, 23, 100, 100, 250, 0, 3400, 72, -7.4f }
#define FMOD_PRESET_CARPETTEDHALLWAY { 300, 2, 30, 5000, 10, 100, 100, 250, 0, 500, 56, -24.0f }
#define FMOD_PRESET_HALLWAY { 1500, 7, 11, 5000, 59, 100, 100, 250, 0, 7800, 87, -5.5f }
#define FMOD_PRESET_STONECORRIDOR { 270, 13, 20, 5000, 79, 100, 100, 250, 0, 9000, 86, -6.0f }
#define FMOD_PRESET_ALLEY { 1500, 7, 11, 5000, 86, 100, 100, 250, 0, 8300, 80, -9.8f }
#define FMOD_PRESET_FOREST { 1500, 162, 88, 5000, 54, 79, 100, 250, 0, 760, 94, -12.3f }
#define FMOD_PRESET_CITY { 1500, 7, 11, 5000, 67, 50, 100, 250, 0, 4050, 66, -26.0f }
#define FMOD_PRESET_MOUNTAINS { 1500, 300, 100, 5000, 21, 27, 100, 250, 0, 1220, 82, -24.0f }
#define FMOD_PRESET_QUARRY { 1500, 61, 25, 5000, 83, 100, 100, 250, 0, 3400, 100, -5.0f }
#define FMOD_PRESET_PLAIN { 1500, 179, 100, 5000, 50, 21, 100, 250, 0, 1670, 65, -28.0f }
#define FMOD_PRESET_PARKINGLOT { 1700, 8, 12, 5000, 100, 100, 100, 250, 0, 20000, 56, -19.5f }
#define FMOD_PRESET_SEWERPIPE { 2800, 14, 21, 5000, 14, 80, 60, 250, 0, 3400, 66, 1.2f }
#define FMOD_PRESET_UNDERWATER { 1500, 7, 11, 5000, 10, 100, 100, 250, 0, 500, 92, 7.0f }
#define FMOD_MAX_CHANNEL_WIDTH 32
#define FMOD_MAX_SYSTEMS 8
#define FMOD_MAX_LISTENERS 8
#define FMOD_REVERB_MAXINSTANCES 4
typedef enum FMOD_THREAD_TYPE
{
FMOD_THREAD_TYPE_MIXER,
FMOD_THREAD_TYPE_FEEDER,
FMOD_THREAD_TYPE_STREAM,
FMOD_THREAD_TYPE_FILE,
FMOD_THREAD_TYPE_NONBLOCKING,
FMOD_THREAD_TYPE_RECORD,
FMOD_THREAD_TYPE_GEOMETRY,
FMOD_THREAD_TYPE_PROFILER,
FMOD_THREAD_TYPE_STUDIO_UPDATE,
FMOD_THREAD_TYPE_STUDIO_LOAD_BANK,
FMOD_THREAD_TYPE_STUDIO_LOAD_SAMPLE,
FMOD_THREAD_TYPE_CONVOLUTION1,
FMOD_THREAD_TYPE_CONVOLUTION2,
FMOD_THREAD_TYPE_MAX,
FMOD_THREAD_TYPE_FORCEINT = 65536
} FMOD_THREAD_TYPE;
typedef enum FMOD_RESULT
{
FMOD_OK,
FMOD_ERR_BADCOMMAND,
FMOD_ERR_CHANNEL_ALLOC,
FMOD_ERR_CHANNEL_STOLEN,
FMOD_ERR_DMA,
FMOD_ERR_DSP_CONNECTION,
FMOD_ERR_DSP_DONTPROCESS,
FMOD_ERR_DSP_FORMAT,
FMOD_ERR_DSP_INUSE,
FMOD_ERR_DSP_NOTFOUND,
FMOD_ERR_DSP_RESERVED,
FMOD_ERR_DSP_SILENCE,
FMOD_ERR_DSP_TYPE,
FMOD_ERR_FILE_BAD,
FMOD_ERR_FILE_COULDNOTSEEK,
FMOD_ERR_FILE_DISKEJECTED,
FMOD_ERR_FILE_EOF,
FMOD_ERR_FILE_ENDOFDATA,
FMOD_ERR_FILE_NOTFOUND,
FMOD_ERR_FORMAT,
FMOD_ERR_HEADER_MISMATCH,
FMOD_ERR_HTTP,
FMOD_ERR_HTTP_ACCESS,
FMOD_ERR_HTTP_PROXY_AUTH,
FMOD_ERR_HTTP_SERVER_ERROR,
FMOD_ERR_HTTP_TIMEOUT,
FMOD_ERR_INITIALIZATION,
FMOD_ERR_INITIALIZED,
FMOD_ERR_INTERNAL,
FMOD_ERR_INVALID_FLOAT,
FMOD_ERR_INVALID_HANDLE,
FMOD_ERR_INVALID_PARAM,
FMOD_ERR_INVALID_POSITION,
FMOD_ERR_INVALID_SPEAKER,
FMOD_ERR_INVALID_SYNCPOINT,
FMOD_ERR_INVALID_THREAD,
FMOD_ERR_INVALID_VECTOR,
FMOD_ERR_MAXAUDIBLE,
FMOD_ERR_MEMORY,
FMOD_ERR_MEMORY_CANTPOINT,
FMOD_ERR_NEEDS3D,
FMOD_ERR_NEEDSHARDWARE,
FMOD_ERR_NET_CONNECT,
FMOD_ERR_NET_SOCKET_ERROR,
FMOD_ERR_NET_URL,
FMOD_ERR_NET_WOULD_BLOCK,
FMOD_ERR_NOTREADY,
FMOD_ERR_OUTPUT_ALLOCATED,
FMOD_ERR_OUTPUT_CREATEBUFFER,
FMOD_ERR_OUTPUT_DRIVERCALL,
FMOD_ERR_OUTPUT_FORMAT,
FMOD_ERR_OUTPUT_INIT,
FMOD_ERR_OUTPUT_NODRIVERS,
FMOD_ERR_PLUGIN,
FMOD_ERR_PLUGIN_MISSING,
FMOD_ERR_PLUGIN_RESOURCE,
FMOD_ERR_PLUGIN_VERSION,
FMOD_ERR_RECORD,
FMOD_ERR_REVERB_CHANNELGROUP,
FMOD_ERR_REVERB_INSTANCE,
FMOD_ERR_SUBSOUNDS,
FMOD_ERR_SUBSOUND_ALLOCATED,
FMOD_ERR_SUBSOUND_CANTMOVE,
FMOD_ERR_TAGNOTFOUND,
FMOD_ERR_TOOMANYCHANNELS,
FMOD_ERR_TRUNCATED,
FMOD_ERR_UNIMPLEMENTED,
FMOD_ERR_UNINITIALIZED,
FMOD_ERR_UNSUPPORTED,
FMOD_ERR_VERSION,
FMOD_ERR_EVENT_ALREADY_LOADED,
FMOD_ERR_EVENT_LIVEUPDATE_BUSY,
FMOD_ERR_EVENT_LIVEUPDATE_MISMATCH,
FMOD_ERR_EVENT_LIVEUPDATE_TIMEOUT,
FMOD_ERR_EVENT_NOTFOUND,
FMOD_ERR_STUDIO_UNINITIALIZED,
FMOD_ERR_STUDIO_NOT_LOADED,
FMOD_ERR_INVALID_STRING,
FMOD_ERR_ALREADY_LOCKED,
FMOD_ERR_NOT_LOCKED,
FMOD_ERR_RECORD_DISCONNECTED,
FMOD_ERR_TOOMANYSAMPLES,
FMOD_RESULT_FORCEINT = 65536
} FMOD_RESULT;
typedef enum FMOD_CHANNELCONTROL_TYPE
{
FMOD_CHANNELCONTROL_CHANNEL,
FMOD_CHANNELCONTROL_CHANNELGROUP,
FMOD_CHANNELCONTROL_MAX,
FMOD_CHANNELCONTROL_FORCEINT = 65536
} FMOD_CHANNELCONTROL_TYPE;
typedef enum FMOD_OUTPUTTYPE
{
FMOD_OUTPUTTYPE_AUTODETECT,
FMOD_OUTPUTTYPE_UNKNOWN,
FMOD_OUTPUTTYPE_NOSOUND,
FMOD_OUTPUTTYPE_WAVWRITER,
FMOD_OUTPUTTYPE_NOSOUND_NRT,
FMOD_OUTPUTTYPE_WAVWRITER_NRT,
FMOD_OUTPUTTYPE_WASAPI,
FMOD_OUTPUTTYPE_ASIO,
FMOD_OUTPUTTYPE_PULSEAUDIO,
FMOD_OUTPUTTYPE_ALSA,
FMOD_OUTPUTTYPE_COREAUDIO,
FMOD_OUTPUTTYPE_AUDIOTRACK,
FMOD_OUTPUTTYPE_OPENSL,
FMOD_OUTPUTTYPE_AUDIOOUT,
FMOD_OUTPUTTYPE_AUDIO3D,
FMOD_OUTPUTTYPE_WEBAUDIO,
FMOD_OUTPUTTYPE_NNAUDIO,
FMOD_OUTPUTTYPE_WINSONIC,
FMOD_OUTPUTTYPE_AAUDIO,
FMOD_OUTPUTTYPE_AUDIOWORKLET,
FMOD_OUTPUTTYPE_PHASE,
FMOD_OUTPUTTYPE_MAX,
FMOD_OUTPUTTYPE_FORCEINT = 65536
} FMOD_OUTPUTTYPE;
typedef enum FMOD_DEBUG_MODE
{
FMOD_DEBUG_MODE_TTY,
FMOD_DEBUG_MODE_FILE,
FMOD_DEBUG_MODE_CALLBACK,
FMOD_DEBUG_MODE_FORCEINT = 65536
} FMOD_DEBUG_MODE;
typedef enum FMOD_SPEAKERMODE
{
FMOD_SPEAKERMODE_DEFAULT,
FMOD_SPEAKERMODE_RAW,
FMOD_SPEAKERMODE_MONO,
FMOD_SPEAKERMODE_STEREO,
FMOD_SPEAKERMODE_QUAD,
FMOD_SPEAKERMODE_SURROUND,
FMOD_SPEAKERMODE_5POINT1,
FMOD_SPEAKERMODE_7POINT1,
FMOD_SPEAKERMODE_7POINT1POINT4,
FMOD_SPEAKERMODE_MAX,
FMOD_SPEAKERMODE_FORCEINT = 65536
} FMOD_SPEAKERMODE;
typedef enum FMOD_SPEAKER
{
FMOD_SPEAKER_NONE = -1,
FMOD_SPEAKER_FRONT_LEFT = 0,
FMOD_SPEAKER_FRONT_RIGHT,
FMOD_SPEAKER_FRONT_CENTER,
FMOD_SPEAKER_LOW_FREQUENCY,
FMOD_SPEAKER_SURROUND_LEFT,
FMOD_SPEAKER_SURROUND_RIGHT,
FMOD_SPEAKER_BACK_LEFT,
FMOD_SPEAKER_BACK_RIGHT,
FMOD_SPEAKER_TOP_FRONT_LEFT,
FMOD_SPEAKER_TOP_FRONT_RIGHT,
FMOD_SPEAKER_TOP_BACK_LEFT,
FMOD_SPEAKER_TOP_BACK_RIGHT,
FMOD_SPEAKER_MAX,
FMOD_SPEAKER_FORCEINT = 65536
} FMOD_SPEAKER;
typedef enum FMOD_CHANNELORDER
{
FMOD_CHANNELORDER_DEFAULT,
FMOD_CHANNELORDER_WAVEFORMAT,
FMOD_CHANNELORDER_PROTOOLS,
FMOD_CHANNELORDER_ALLMONO,
FMOD_CHANNELORDER_ALLSTEREO,
FMOD_CHANNELORDER_ALSA,
FMOD_CHANNELORDER_MAX,
FMOD_CHANNELORDER_FORCEINT = 65536
} FMOD_CHANNELORDER;
typedef enum FMOD_PLUGINTYPE
{
FMOD_PLUGINTYPE_OUTPUT,
FMOD_PLUGINTYPE_CODEC,
FMOD_PLUGINTYPE_DSP,
FMOD_PLUGINTYPE_MAX,
FMOD_PLUGINTYPE_FORCEINT = 65536
} FMOD_PLUGINTYPE;
typedef enum FMOD_SOUND_TYPE
{
FMOD_SOUND_TYPE_UNKNOWN,
FMOD_SOUND_TYPE_AIFF,
FMOD_SOUND_TYPE_ASF,
FMOD_SOUND_TYPE_DLS,
FMOD_SOUND_TYPE_FLAC,
FMOD_SOUND_TYPE_FSB,
FMOD_SOUND_TYPE_IT,
FMOD_SOUND_TYPE_MIDI,
FMOD_SOUND_TYPE_MOD,
FMOD_SOUND_TYPE_MPEG,
FMOD_SOUND_TYPE_OGGVORBIS,
FMOD_SOUND_TYPE_PLAYLIST,
FMOD_SOUND_TYPE_RAW,
FMOD_SOUND_TYPE_S3M,
FMOD_SOUND_TYPE_USER,
FMOD_SOUND_TYPE_WAV,
FMOD_SOUND_TYPE_XM,
FMOD_SOUND_TYPE_XMA,
FMOD_SOUND_TYPE_AUDIOQUEUE,
FMOD_SOUND_TYPE_AT9,
FMOD_SOUND_TYPE_VORBIS,
FMOD_SOUND_TYPE_MEDIA_FOUNDATION,
FMOD_SOUND_TYPE_MEDIACODEC,
FMOD_SOUND_TYPE_FADPCM,
FMOD_SOUND_TYPE_OPUS,
FMOD_SOUND_TYPE_MAX,
FMOD_SOUND_TYPE_FORCEINT = 65536
} FMOD_SOUND_TYPE;
typedef enum FMOD_SOUND_FORMAT
{
FMOD_SOUND_FORMAT_NONE,
FMOD_SOUND_FORMAT_PCM8,
FMOD_SOUND_FORMAT_PCM16,
FMOD_SOUND_FORMAT_PCM24,
FMOD_SOUND_FORMAT_PCM32,
FMOD_SOUND_FORMAT_PCMFLOAT,
FMOD_SOUND_FORMAT_BITSTREAM,
FMOD_SOUND_FORMAT_MAX,
FMOD_SOUND_FORMAT_FORCEINT = 65536
} FMOD_SOUND_FORMAT;
typedef enum FMOD_OPENSTATE
{
FMOD_OPENSTATE_READY,
FMOD_OPENSTATE_LOADING,
FMOD_OPENSTATE_ERROR,
FMOD_OPENSTATE_CONNECTING,
FMOD_OPENSTATE_BUFFERING,
FMOD_OPENSTATE_SEEKING,
FMOD_OPENSTATE_PLAYING,
FMOD_OPENSTATE_SETPOSITION,
FMOD_OPENSTATE_MAX,
FMOD_OPENSTATE_FORCEINT = 65536
} FMOD_OPENSTATE;
typedef enum FMOD_SOUNDGROUP_BEHAVIOR
{
FMOD_SOUNDGROUP_BEHAVIOR_FAIL,
FMOD_SOUNDGROUP_BEHAVIOR_MUTE,
FMOD_SOUNDGROUP_BEHAVIOR_STEALLOWEST,
FMOD_SOUNDGROUP_BEHAVIOR_MAX,
FMOD_SOUNDGROUP_BEHAVIOR_FORCEINT = 65536
} FMOD_SOUNDGROUP_BEHAVIOR;
typedef enum FMOD_CHANNELCONTROL_CALLBACK_TYPE
{
FMOD_CHANNELCONTROL_CALLBACK_END,
FMOD_CHANNELCONTROL_CALLBACK_VIRTUALVOICE,
FMOD_CHANNELCONTROL_CALLBACK_SYNCPOINT,
FMOD_CHANNELCONTROL_CALLBACK_OCCLUSION,
FMOD_CHANNELCONTROL_CALLBACK_MAX,
FMOD_CHANNELCONTROL_CALLBACK_FORCEINT = 65536
} FMOD_CHANNELCONTROL_CALLBACK_TYPE;
typedef enum FMOD_CHANNELCONTROL_DSP_INDEX
{
FMOD_CHANNELCONTROL_DSP_HEAD = -1,
FMOD_CHANNELCONTROL_DSP_FADER = -2,
FMOD_CHANNELCONTROL_DSP_TAIL = -3,
FMOD_CHANNELCONTROL_DSP_FORCEINT = 65536
} FMOD_CHANNELCONTROL_DSP_INDEX;
typedef enum FMOD_ERRORCALLBACK_INSTANCETYPE
{
FMOD_ERRORCALLBACK_INSTANCETYPE_NONE,
FMOD_ERRORCALLBACK_INSTANCETYPE_SYSTEM,
FMOD_ERRORCALLBACK_INSTANCETYPE_CHANNEL,
FMOD_ERRORCALLBACK_INSTANCETYPE_CHANNELGROUP,
FMOD_ERRORCALLBACK_INSTANCETYPE_CHANNELCONTROL,
FMOD_ERRORCALLBACK_INSTANCETYPE_SOUND,
FMOD_ERRORCALLBACK_INSTANCETYPE_SOUNDGROUP,
FMOD_ERRORCALLBACK_INSTANCETYPE_DSP,
FMOD_ERRORCALLBACK_INSTANCETYPE_DSPCONNECTION,
FMOD_ERRORCALLBACK_INSTANCETYPE_GEOMETRY,
FMOD_ERRORCALLBACK_INSTANCETYPE_REVERB3D,
FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_SYSTEM,
FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_EVENTDESCRIPTION,
FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_EVENTINSTANCE,
FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_PARAMETERINSTANCE,
FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_BUS,
FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_VCA,
FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_BANK,
FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_COMMANDREPLAY,
FMOD_ERRORCALLBACK_INSTANCETYPE_FORCEINT = 65536
} FMOD_ERRORCALLBACK_INSTANCETYPE;
typedef enum FMOD_DSP_RESAMPLER
{
FMOD_DSP_RESAMPLER_DEFAULT,
FMOD_DSP_RESAMPLER_NOINTERP,
FMOD_DSP_RESAMPLER_LINEAR,
FMOD_DSP_RESAMPLER_CUBIC,
FMOD_DSP_RESAMPLER_SPLINE,
FMOD_DSP_RESAMPLER_MAX,
FMOD_DSP_RESAMPLER_FORCEINT = 65536
} FMOD_DSP_RESAMPLER;
typedef enum FMOD_DSP_CALLBACK_TYPE
{
FMOD_DSP_CALLBACK_DATAPARAMETERRELEASE,
FMOD_DSP_CALLBACK_MAX,
FMOD_DSP_CALLBACK_FORCEINT = 65536
} FMOD_DSP_CALLBACK_TYPE;
typedef enum FMOD_DSPCONNECTION_TYPE
{
FMOD_DSPCONNECTION_TYPE_STANDARD,
FMOD_DSPCONNECTION_TYPE_SIDECHAIN,
FMOD_DSPCONNECTION_TYPE_SEND,
FMOD_DSPCONNECTION_TYPE_SEND_SIDECHAIN,
FMOD_DSPCONNECTION_TYPE_MAX,
FMOD_DSPCONNECTION_TYPE_FORCEINT = 65536
} FMOD_DSPCONNECTION_TYPE;
typedef enum FMOD_TAGTYPE
{
FMOD_TAGTYPE_UNKNOWN,
FMOD_TAGTYPE_ID3V1,
FMOD_TAGTYPE_ID3V2,
FMOD_TAGTYPE_VORBISCOMMENT,
FMOD_TAGTYPE_SHOUTCAST,
FMOD_TAGTYPE_ICECAST,
FMOD_TAGTYPE_ASF,
FMOD_TAGTYPE_MIDI,
FMOD_TAGTYPE_PLAYLIST,
FMOD_TAGTYPE_FMOD,
FMOD_TAGTYPE_USER,
FMOD_TAGTYPE_MAX,
FMOD_TAGTYPE_FORCEINT = 65536
} FMOD_TAGTYPE;
typedef enum FMOD_TAGDATATYPE
{
FMOD_TAGDATATYPE_BINARY,
FMOD_TAGDATATYPE_INT,
FMOD_TAGDATATYPE_FLOAT,
FMOD_TAGDATATYPE_STRING,
FMOD_TAGDATATYPE_STRING_UTF16,
FMOD_TAGDATATYPE_STRING_UTF16BE,
FMOD_TAGDATATYPE_STRING_UTF8,
FMOD_TAGDATATYPE_MAX,
FMOD_TAGDATATYPE_FORCEINT = 65536
} FMOD_TAGDATATYPE;
typedef enum FMOD_PORT_TYPE
{
FMOD_PORT_TYPE_MUSIC,
FMOD_PORT_TYPE_COPYRIGHT_MUSIC,
FMOD_PORT_TYPE_VOICE,
FMOD_PORT_TYPE_CONTROLLER,
FMOD_PORT_TYPE_PERSONAL,
FMOD_PORT_TYPE_VIBRATION,
FMOD_PORT_TYPE_AUX,
FMOD_PORT_TYPE_MAX,
FMOD_PORT_TYPE_FORCEINT = 65536
} FMOD_PORT_TYPE;
/*
FMOD callbacks
*/
typedef FMOD_RESULT (F_CALL *FMOD_DEBUG_CALLBACK) (FMOD_DEBUG_FLAGS flags, const char *file, int line, const char* func, const char* message);
typedef FMOD_RESULT (F_CALL *FMOD_SYSTEM_CALLBACK) (FMOD_SYSTEM *system, FMOD_SYSTEM_CALLBACK_TYPE type, void *commanddata1, void* commanddata2, void *userdata);
typedef FMOD_RESULT (F_CALL *FMOD_CHANNELCONTROL_CALLBACK) (FMOD_CHANNELCONTROL *channelcontrol, FMOD_CHANNELCONTROL_TYPE controltype, FMOD_CHANNELCONTROL_CALLBACK_TYPE callbacktype, void *commanddata1, void *commanddata2);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_CALLBACK) (FMOD_DSP *dsp, FMOD_DSP_CALLBACK_TYPE type, void *data);
typedef FMOD_RESULT (F_CALL *FMOD_SOUND_NONBLOCK_CALLBACK) (FMOD_SOUND *sound, FMOD_RESULT result);
typedef FMOD_RESULT (F_CALL *FMOD_SOUND_PCMREAD_CALLBACK) (FMOD_SOUND *sound, void *data, unsigned int datalen);
typedef FMOD_RESULT (F_CALL *FMOD_SOUND_PCMSETPOS_CALLBACK) (FMOD_SOUND *sound, int subsound, unsigned int position, FMOD_TIMEUNIT postype);
typedef FMOD_RESULT (F_CALL *FMOD_FILE_OPEN_CALLBACK) (const char *name, unsigned int *filesize, void **handle, void *userdata);
typedef FMOD_RESULT (F_CALL *FMOD_FILE_CLOSE_CALLBACK) (void *handle, void *userdata);
typedef FMOD_RESULT (F_CALL *FMOD_FILE_READ_CALLBACK) (void *handle, void *buffer, unsigned int sizebytes, unsigned int *bytesread, void *userdata);
typedef FMOD_RESULT (F_CALL *FMOD_FILE_SEEK_CALLBACK) (void *handle, unsigned int pos, void *userdata);
typedef FMOD_RESULT (F_CALL *FMOD_FILE_ASYNCREAD_CALLBACK) (FMOD_ASYNCREADINFO *info, void *userdata);
typedef FMOD_RESULT (F_CALL *FMOD_FILE_ASYNCCANCEL_CALLBACK)(FMOD_ASYNCREADINFO *info, void *userdata);
typedef void (F_CALL *FMOD_FILE_ASYNCDONE_FUNC) (FMOD_ASYNCREADINFO *info, FMOD_RESULT result);
typedef void* (F_CALL *FMOD_MEMORY_ALLOC_CALLBACK) (unsigned int size, FMOD_MEMORY_TYPE type, const char *sourcestr);
typedef void* (F_CALL *FMOD_MEMORY_REALLOC_CALLBACK) (void *ptr, unsigned int size, FMOD_MEMORY_TYPE type, const char *sourcestr);
typedef void (F_CALL *FMOD_MEMORY_FREE_CALLBACK) (void *ptr, FMOD_MEMORY_TYPE type, const char *sourcestr);
typedef float (F_CALL *FMOD_3D_ROLLOFF_CALLBACK) (FMOD_CHANNELCONTROL *channelcontrol, float distance);
/*
FMOD structs
*/
struct FMOD_ASYNCREADINFO
{
void *handle;
unsigned int offset;
unsigned int sizebytes;
int priority;
void *userdata;
void *buffer;
unsigned int bytesread;
FMOD_FILE_ASYNCDONE_FUNC done;
};
typedef struct FMOD_VECTOR
{
float x;
float y;
float z;
} FMOD_VECTOR;
typedef struct FMOD_3D_ATTRIBUTES
{
FMOD_VECTOR position;
FMOD_VECTOR velocity;
FMOD_VECTOR forward;
FMOD_VECTOR up;
} FMOD_3D_ATTRIBUTES;
typedef struct FMOD_GUID
{
unsigned int Data1;
unsigned short Data2;
unsigned short Data3;
unsigned char Data4[8];
} FMOD_GUID;
typedef struct FMOD_PLUGINLIST
{
FMOD_PLUGINTYPE type;
void *description;
} FMOD_PLUGINLIST;
typedef struct FMOD_ADVANCEDSETTINGS
{
int cbSize;
int maxMPEGCodecs;
int maxADPCMCodecs;
int maxXMACodecs;
int maxVorbisCodecs;
int maxAT9Codecs;
int maxFADPCMCodecs;
int maxPCMCodecs;
int ASIONumChannels;
char **ASIOChannelList;
FMOD_SPEAKER *ASIOSpeakerList;
float vol0virtualvol;
unsigned int defaultDecodeBufferSize;
unsigned short profilePort;
unsigned int geometryMaxFadeTime;
float distanceFilterCenterFreq;
int reverb3Dinstance;
int DSPBufferPoolSize;
FMOD_DSP_RESAMPLER resamplerMethod;
unsigned int randomSeed;
int maxConvolutionThreads;
int maxOpusCodecs;
} FMOD_ADVANCEDSETTINGS;
typedef struct FMOD_TAG
{
FMOD_TAGTYPE type;
FMOD_TAGDATATYPE datatype;
char *name;
void *data;
unsigned int datalen;
FMOD_BOOL updated;
} FMOD_TAG;
typedef struct FMOD_CREATESOUNDEXINFO
{
int cbsize;
unsigned int length;
unsigned int fileoffset;
int numchannels;
int defaultfrequency;
FMOD_SOUND_FORMAT format;
unsigned int decodebuffersize;
int initialsubsound;
int numsubsounds;
int *inclusionlist;
int inclusionlistnum;
FMOD_SOUND_PCMREAD_CALLBACK pcmreadcallback;
FMOD_SOUND_PCMSETPOS_CALLBACK pcmsetposcallback;
FMOD_SOUND_NONBLOCK_CALLBACK nonblockcallback;
const char *dlsname;
const char *encryptionkey;
int maxpolyphony;
void *userdata;
FMOD_SOUND_TYPE suggestedsoundtype;
FMOD_FILE_OPEN_CALLBACK fileuseropen;
FMOD_FILE_CLOSE_CALLBACK fileuserclose;
FMOD_FILE_READ_CALLBACK fileuserread;
FMOD_FILE_SEEK_CALLBACK fileuserseek;
FMOD_FILE_ASYNCREAD_CALLBACK fileuserasyncread;
FMOD_FILE_ASYNCCANCEL_CALLBACK fileuserasynccancel;
void *fileuserdata;
int filebuffersize;
FMOD_CHANNELORDER channelorder;
FMOD_SOUNDGROUP *initialsoundgroup;
unsigned int initialseekposition;
FMOD_TIMEUNIT initialseekpostype;
int ignoresetfilesystem;
unsigned int audioqueuepolicy;
unsigned int minmidigranularity;
int nonblockthreadid;
FMOD_GUID *fsbguid;
} FMOD_CREATESOUNDEXINFO;
typedef struct FMOD_REVERB_PROPERTIES
{
float DecayTime;
float EarlyDelay;
float LateDelay;
float HFReference;
float HFDecayRatio;
float Diffusion;
float Density;
float LowShelfFrequency;
float LowShelfGain;
float HighCut;
float EarlyLateMix;
float WetLevel;
} FMOD_REVERB_PROPERTIES;
typedef struct FMOD_ERRORCALLBACK_INFO
{
FMOD_RESULT result;
FMOD_ERRORCALLBACK_INSTANCETYPE instancetype;
void *instance;
const char *functionname;
const char *functionparams;
} FMOD_ERRORCALLBACK_INFO;
typedef struct FMOD_CPU_USAGE
{
float dsp;
float stream;
float geometry;
float update;
float convolution1;
float convolution2;
} FMOD_CPU_USAGE;
typedef struct FMOD_DSP_DATA_PARAMETER_INFO
{
void *data;
unsigned int length;
int index;
} FMOD_DSP_DATA_PARAMETER_INFO;
/*
FMOD optional headers for plugin development
*/
#include "fmod_codec.h"
#include "fmod_dsp.h"
#include "fmod_output.h"
#endif
3rdparty/fmod/include/fmod_dsp.h
Vendored
+421
View File
@@ -0,0 +1,421 @@
/* ======================================================================================== */
/* FMOD Core API - DSP header file. */
/* Copyright (c), Firelight Technologies Pty, Ltd. 2004-2023. */
/* */
/* Use this header if you are wanting to develop your own DSP plugin to use with FMODs */
/* dsp system. With this header you can make your own DSP plugin that FMOD can */
/* register and use. See the documentation and examples on how to make a working plugin. */
/* */
/* For more detail visit: */
/* https://fmod.com/docs/2.02/api/plugin-api-dsp.html */
/* =========================================================================================*/
#ifndef _FMOD_DSP_H
#define _FMOD_DSP_H
#include "fmod_dsp_effects.h"
typedef struct FMOD_DSP_STATE FMOD_DSP_STATE;
typedef struct FMOD_DSP_BUFFER_ARRAY FMOD_DSP_BUFFER_ARRAY;
typedef struct FMOD_COMPLEX FMOD_COMPLEX;
/*
DSP Constants
*/
#define FMOD_PLUGIN_SDK_VERSION 110
#define FMOD_DSP_GETPARAM_VALUESTR_LENGTH 32
typedef enum
{
FMOD_DSP_PROCESS_PERFORM,
FMOD_DSP_PROCESS_QUERY
} FMOD_DSP_PROCESS_OPERATION;
typedef enum FMOD_DSP_PAN_SURROUND_FLAGS
{
FMOD_DSP_PAN_SURROUND_DEFAULT = 0,
FMOD_DSP_PAN_SURROUND_ROTATION_NOT_BIASED = 1,
FMOD_DSP_PAN_SURROUND_FLAGS_FORCEINT = 65536
} FMOD_DSP_PAN_SURROUND_FLAGS;
typedef enum
{
FMOD_DSP_PARAMETER_TYPE_FLOAT,
FMOD_DSP_PARAMETER_TYPE_INT,
FMOD_DSP_PARAMETER_TYPE_BOOL,
FMOD_DSP_PARAMETER_TYPE_DATA,
FMOD_DSP_PARAMETER_TYPE_MAX,
FMOD_DSP_PARAMETER_TYPE_FORCEINT = 65536
} FMOD_DSP_PARAMETER_TYPE;
typedef enum
{
FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_LINEAR,
FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_AUTO,
FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_PIECEWISE_LINEAR,
FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_FORCEINT = 65536
} FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE;
typedef enum
{
FMOD_DSP_PARAMETER_DATA_TYPE_USER = 0,
FMOD_DSP_PARAMETER_DATA_TYPE_OVERALLGAIN = -1,
FMOD_DSP_PARAMETER_DATA_TYPE_3DATTRIBUTES = -2,
FMOD_DSP_PARAMETER_DATA_TYPE_SIDECHAIN = -3,
FMOD_DSP_PARAMETER_DATA_TYPE_FFT = -4,
FMOD_DSP_PARAMETER_DATA_TYPE_3DATTRIBUTES_MULTI = -5,
FMOD_DSP_PARAMETER_DATA_TYPE_ATTENUATION_RANGE = -6,
} FMOD_DSP_PARAMETER_DATA_TYPE;
/*
DSP Callbacks
*/
typedef FMOD_RESULT (F_CALL *FMOD_DSP_CREATE_CALLBACK) (FMOD_DSP_STATE *dsp_state);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_RELEASE_CALLBACK) (FMOD_DSP_STATE *dsp_state);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_RESET_CALLBACK) (FMOD_DSP_STATE *dsp_state);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_READ_CALLBACK) (FMOD_DSP_STATE *dsp_state, float *inbuffer, float *outbuffer, unsigned int length, int inchannels, int *outchannels);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_PROCESS_CALLBACK) (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);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_SETPOSITION_CALLBACK) (FMOD_DSP_STATE *dsp_state, unsigned int pos);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_SHOULDIPROCESS_CALLBACK) (FMOD_DSP_STATE *dsp_state, FMOD_BOOL inputsidle, unsigned int length, FMOD_CHANNELMASK inmask, int inchannels, FMOD_SPEAKERMODE speakermode);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_SETPARAM_FLOAT_CALLBACK) (FMOD_DSP_STATE *dsp_state, int index, float value);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_SETPARAM_INT_CALLBACK) (FMOD_DSP_STATE *dsp_state, int index, int value);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_SETPARAM_BOOL_CALLBACK) (FMOD_DSP_STATE *dsp_state, int index, FMOD_BOOL value);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_SETPARAM_DATA_CALLBACK) (FMOD_DSP_STATE *dsp_state, int index, void *data, unsigned int length);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_GETPARAM_FLOAT_CALLBACK) (FMOD_DSP_STATE *dsp_state, int index, float *value, char *valuestr);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_GETPARAM_INT_CALLBACK) (FMOD_DSP_STATE *dsp_state, int index, int *value, char *valuestr);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_GETPARAM_BOOL_CALLBACK) (FMOD_DSP_STATE *dsp_state, int index, FMOD_BOOL *value, char *valuestr);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_GETPARAM_DATA_CALLBACK) (FMOD_DSP_STATE *dsp_state, int index, void **data, unsigned int *length, char *valuestr);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_SYSTEM_REGISTER_CALLBACK) (FMOD_DSP_STATE *dsp_state);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_SYSTEM_DEREGISTER_CALLBACK) (FMOD_DSP_STATE *dsp_state);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_SYSTEM_MIX_CALLBACK) (FMOD_DSP_STATE *dsp_state, int stage);
/*
DSP Functions
*/
typedef void * (F_CALL *FMOD_DSP_ALLOC_FUNC) (unsigned int size, FMOD_MEMORY_TYPE type, const char *sourcestr);
typedef void * (F_CALL *FMOD_DSP_REALLOC_FUNC) (void *ptr, unsigned int size, FMOD_MEMORY_TYPE type, const char *sourcestr);
typedef void (F_CALL *FMOD_DSP_FREE_FUNC) (void *ptr, FMOD_MEMORY_TYPE type, const char *sourcestr);
typedef void (F_CALL *FMOD_DSP_LOG_FUNC) (FMOD_DEBUG_FLAGS level, const char *file, int line, const char *function, const char *str, ...);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_GETSAMPLERATE_FUNC) (FMOD_DSP_STATE *dsp_state, int *rate);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_GETBLOCKSIZE_FUNC) (FMOD_DSP_STATE *dsp_state, unsigned int *blocksize);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_GETSPEAKERMODE_FUNC) (FMOD_DSP_STATE *dsp_state, FMOD_SPEAKERMODE *speakermode_mixer, FMOD_SPEAKERMODE *speakermode_output);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_GETCLOCK_FUNC) (FMOD_DSP_STATE *dsp_state, unsigned long long *clock, unsigned int *offset, unsigned int *length);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_GETLISTENERATTRIBUTES_FUNC) (FMOD_DSP_STATE *dsp_state, int *numlisteners, FMOD_3D_ATTRIBUTES *attributes);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_GETUSERDATA_FUNC) (FMOD_DSP_STATE *dsp_state, void **userdata);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_DFT_FFTREAL_FUNC) (FMOD_DSP_STATE *dsp_state, int size, const float *signal, FMOD_COMPLEX* dft, const float *window, int signalhop);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_DFT_IFFTREAL_FUNC) (FMOD_DSP_STATE *dsp_state, int size, const FMOD_COMPLEX *dft, float* signal, const float *window, int signalhop);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_PAN_SUMMONOMATRIX_FUNC) (FMOD_DSP_STATE *dsp_state, FMOD_SPEAKERMODE sourceSpeakerMode, float lowFrequencyGain, float overallGain, float *matrix);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_PAN_SUMSTEREOMATRIX_FUNC) (FMOD_DSP_STATE *dsp_state, FMOD_SPEAKERMODE sourceSpeakerMode, float pan, float lowFrequencyGain, float overallGain, int matrixHop, float *matrix);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_PAN_SUMSURROUNDMATRIX_FUNC) (FMOD_DSP_STATE *dsp_state, FMOD_SPEAKERMODE sourceSpeakerMode, FMOD_SPEAKERMODE targetSpeakerMode, float direction, float extent, float rotation, float lowFrequencyGain, float overallGain, int matrixHop, float *matrix, FMOD_DSP_PAN_SURROUND_FLAGS flags);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_PAN_SUMMONOTOSURROUNDMATRIX_FUNC) (FMOD_DSP_STATE *dsp_state, FMOD_SPEAKERMODE targetSpeakerMode, float direction, float extent, float lowFrequencyGain, float overallGain, int matrixHop, float *matrix);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_PAN_SUMSTEREOTOSURROUNDMATRIX_FUNC) (FMOD_DSP_STATE *dsp_state, FMOD_SPEAKERMODE targetSpeakerMode, float direction, float extent, float rotation, float lowFrequencyGain, float overallGain, int matrixHop, float *matrix);
typedef FMOD_RESULT (F_CALL *FMOD_DSP_PAN_GETROLLOFFGAIN_FUNC) (FMOD_DSP_STATE *dsp_state, FMOD_DSP_PAN_3D_ROLLOFF_TYPE rolloff, float distance, float mindistance, float maxdistance, float *gain);
/*
DSP Structures
*/
struct FMOD_DSP_BUFFER_ARRAY
{
int numbuffers;
int *buffernumchannels;
FMOD_CHANNELMASK *bufferchannelmask;
float **buffers;
FMOD_SPEAKERMODE speakermode;
};
struct FMOD_COMPLEX
{
float real;
float imag;
};
typedef struct FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR
{
int numpoints;
float *pointparamvalues;
float *pointpositions;
} FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR;
typedef struct FMOD_DSP_PARAMETER_FLOAT_MAPPING
{
FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE type;
FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR piecewiselinearmapping;
} FMOD_DSP_PARAMETER_FLOAT_MAPPING;
typedef struct FMOD_DSP_PARAMETER_DESC_FLOAT
{
float min;
float max;
float defaultval;
FMOD_DSP_PARAMETER_FLOAT_MAPPING mapping;
} FMOD_DSP_PARAMETER_DESC_FLOAT;
typedef struct FMOD_DSP_PARAMETER_DESC_INT
{
int min;
int max;
int defaultval;
FMOD_BOOL goestoinf;
const char* const* valuenames;
} FMOD_DSP_PARAMETER_DESC_INT;
typedef struct FMOD_DSP_PARAMETER_DESC_BOOL
{
FMOD_BOOL defaultval;
const char* const* valuenames;
} FMOD_DSP_PARAMETER_DESC_BOOL;
typedef struct FMOD_DSP_PARAMETER_DESC_DATA
{
int datatype;
} FMOD_DSP_PARAMETER_DESC_DATA;
typedef struct FMOD_DSP_PARAMETER_DESC
{
FMOD_DSP_PARAMETER_TYPE type;
char name[16];
char label[16];
const char *description;
union
{
FMOD_DSP_PARAMETER_DESC_FLOAT floatdesc;
FMOD_DSP_PARAMETER_DESC_INT intdesc;
FMOD_DSP_PARAMETER_DESC_BOOL booldesc;
FMOD_DSP_PARAMETER_DESC_DATA datadesc;
};
} FMOD_DSP_PARAMETER_DESC;
typedef struct FMOD_DSP_PARAMETER_OVERALLGAIN
{
float linear_gain;
float linear_gain_additive;
} FMOD_DSP_PARAMETER_OVERALLGAIN;
typedef struct FMOD_DSP_PARAMETER_3DATTRIBUTES
{
FMOD_3D_ATTRIBUTES relative;
FMOD_3D_ATTRIBUTES absolute;
} FMOD_DSP_PARAMETER_3DATTRIBUTES;
typedef struct FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI
{
int numlisteners;
FMOD_3D_ATTRIBUTES relative[FMOD_MAX_LISTENERS];
float weight[FMOD_MAX_LISTENERS];
FMOD_3D_ATTRIBUTES absolute;
} FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI;
typedef struct FMOD_DSP_PARAMETER_ATTENUATION_RANGE
{
float min;
float max;
} FMOD_DSP_PARAMETER_ATTENUATION_RANGE;
typedef struct FMOD_DSP_PARAMETER_SIDECHAIN
{
FMOD_BOOL sidechainenable;
} FMOD_DSP_PARAMETER_SIDECHAIN;
typedef struct FMOD_DSP_PARAMETER_FFT
{
int length;
int numchannels;
float *spectrum[32];
} FMOD_DSP_PARAMETER_FFT;
typedef struct FMOD_DSP_DESCRIPTION
{
unsigned int pluginsdkversion;
char name[32];
unsigned int version;
int numinputbuffers;
int numoutputbuffers;
FMOD_DSP_CREATE_CALLBACK create;
FMOD_DSP_RELEASE_CALLBACK release;
FMOD_DSP_RESET_CALLBACK reset;
FMOD_DSP_READ_CALLBACK read;
FMOD_DSP_PROCESS_CALLBACK process;
FMOD_DSP_SETPOSITION_CALLBACK setposition;
int numparameters;
FMOD_DSP_PARAMETER_DESC **paramdesc;
FMOD_DSP_SETPARAM_FLOAT_CALLBACK setparameterfloat;
FMOD_DSP_SETPARAM_INT_CALLBACK setparameterint;
FMOD_DSP_SETPARAM_BOOL_CALLBACK setparameterbool;
FMOD_DSP_SETPARAM_DATA_CALLBACK setparameterdata;
FMOD_DSP_GETPARAM_FLOAT_CALLBACK getparameterfloat;
FMOD_DSP_GETPARAM_INT_CALLBACK getparameterint;
FMOD_DSP_GETPARAM_BOOL_CALLBACK getparameterbool;
FMOD_DSP_GETPARAM_DATA_CALLBACK getparameterdata;
FMOD_DSP_SHOULDIPROCESS_CALLBACK shouldiprocess;
void *userdata;
FMOD_DSP_SYSTEM_REGISTER_CALLBACK sys_register;
FMOD_DSP_SYSTEM_DEREGISTER_CALLBACK sys_deregister;
FMOD_DSP_SYSTEM_MIX_CALLBACK sys_mix;
} FMOD_DSP_DESCRIPTION;
typedef struct FMOD_DSP_STATE_DFT_FUNCTIONS
{
FMOD_DSP_DFT_FFTREAL_FUNC fftreal;
FMOD_DSP_DFT_IFFTREAL_FUNC inversefftreal;
} FMOD_DSP_STATE_DFT_FUNCTIONS;
typedef struct FMOD_DSP_STATE_PAN_FUNCTIONS
{
FMOD_DSP_PAN_SUMMONOMATRIX_FUNC summonomatrix;
FMOD_DSP_PAN_SUMSTEREOMATRIX_FUNC sumstereomatrix;
FMOD_DSP_PAN_SUMSURROUNDMATRIX_FUNC sumsurroundmatrix;
FMOD_DSP_PAN_SUMMONOTOSURROUNDMATRIX_FUNC summonotosurroundmatrix;
FMOD_DSP_PAN_SUMSTEREOTOSURROUNDMATRIX_FUNC sumstereotosurroundmatrix;
FMOD_DSP_PAN_GETROLLOFFGAIN_FUNC getrolloffgain;
} FMOD_DSP_STATE_PAN_FUNCTIONS;
typedef struct FMOD_DSP_STATE_FUNCTIONS
{
FMOD_DSP_ALLOC_FUNC alloc;
FMOD_DSP_REALLOC_FUNC realloc;
FMOD_DSP_FREE_FUNC free;
FMOD_DSP_GETSAMPLERATE_FUNC getsamplerate;
FMOD_DSP_GETBLOCKSIZE_FUNC getblocksize;
FMOD_DSP_STATE_DFT_FUNCTIONS *dft;
FMOD_DSP_STATE_PAN_FUNCTIONS *pan;
FMOD_DSP_GETSPEAKERMODE_FUNC getspeakermode;
FMOD_DSP_GETCLOCK_FUNC getclock;
FMOD_DSP_GETLISTENERATTRIBUTES_FUNC getlistenerattributes;
FMOD_DSP_LOG_FUNC log;
FMOD_DSP_GETUSERDATA_FUNC getuserdata;
} FMOD_DSP_STATE_FUNCTIONS;
struct FMOD_DSP_STATE
{
void *instance;
void *plugindata;
FMOD_CHANNELMASK channelmask;
FMOD_SPEAKERMODE source_speakermode;
float *sidechaindata;
int sidechainchannels;
FMOD_DSP_STATE_FUNCTIONS *functions;
int systemobject;
};
typedef struct FMOD_DSP_METERING_INFO
{
int numsamples;
float peaklevel[32];
float rmslevel[32];
short numchannels;
} FMOD_DSP_METERING_INFO;
/*
DSP Macros
*/
#define FMOD_DSP_INIT_PARAMDESC_FLOAT(_paramstruct, _name, _label, _description, _min, _max, _defaultval) \
memset(&(_paramstruct), 0, sizeof(_paramstruct)); \
(_paramstruct).type = FMOD_DSP_PARAMETER_TYPE_FLOAT; \
strncpy((_paramstruct).name, _name, 15); \
strncpy((_paramstruct).label, _label, 15); \
(_paramstruct).description = _description; \
(_paramstruct).floatdesc.min = _min; \
(_paramstruct).floatdesc.max = _max; \
(_paramstruct).floatdesc.defaultval = _defaultval; \
(_paramstruct).floatdesc.mapping.type = FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_AUTO;
#define FMOD_DSP_INIT_PARAMDESC_FLOAT_WITH_MAPPING(_paramstruct, _name, _label, _description, _defaultval, _values, _positions); \
memset(&(_paramstruct), 0, sizeof(_paramstruct)); \
(_paramstruct).type = FMOD_DSP_PARAMETER_TYPE_FLOAT; \
strncpy((_paramstruct).name, _name , 15); \
strncpy((_paramstruct).label, _label, 15); \
(_paramstruct).description = _description; \
(_paramstruct).floatdesc.min = _values[0]; \
(_paramstruct).floatdesc.max = _values[sizeof(_values) / sizeof(float) - 1]; \
(_paramstruct).floatdesc.defaultval = _defaultval; \
(_paramstruct).floatdesc.mapping.type = FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_PIECEWISE_LINEAR; \
(_paramstruct).floatdesc.mapping.piecewiselinearmapping.numpoints = sizeof(_values) / sizeof(float); \
(_paramstruct).floatdesc.mapping.piecewiselinearmapping.pointparamvalues = _values; \
(_paramstruct).floatdesc.mapping.piecewiselinearmapping.pointpositions = _positions;
#define FMOD_DSP_INIT_PARAMDESC_INT(_paramstruct, _name, _label, _description, _min, _max, _defaultval, _goestoinf, _valuenames) \
memset(&(_paramstruct), 0, sizeof(_paramstruct)); \
(_paramstruct).type = FMOD_DSP_PARAMETER_TYPE_INT; \
strncpy((_paramstruct).name, _name , 15); \
strncpy((_paramstruct).label, _label, 15); \
(_paramstruct).description = _description; \
(_paramstruct).intdesc.min = _min; \
(_paramstruct).intdesc.max = _max; \
(_paramstruct).intdesc.defaultval = _defaultval; \
(_paramstruct).intdesc.goestoinf = _goestoinf; \
(_paramstruct).intdesc.valuenames = _valuenames;
#define FMOD_DSP_INIT_PARAMDESC_INT_ENUMERATED(_paramstruct, _name, _label, _description, _defaultval, _valuenames) \
memset(&(_paramstruct), 0, sizeof(_paramstruct)); \
(_paramstruct).type = FMOD_DSP_PARAMETER_TYPE_INT; \
strncpy((_paramstruct).name, _name , 15); \
strncpy((_paramstruct).label, _label, 15); \
(_paramstruct).description = _description; \
(_paramstruct).intdesc.min = 0; \
(_paramstruct).intdesc.max = sizeof(_valuenames) / sizeof(char*) - 1; \
(_paramstruct).intdesc.defaultval = _defaultval; \
(_paramstruct).intdesc.goestoinf = false; \
(_paramstruct).intdesc.valuenames = _valuenames;
#define FMOD_DSP_INIT_PARAMDESC_BOOL(_paramstruct, _name, _label, _description, _defaultval, _valuenames) \
memset(&(_paramstruct), 0, sizeof(_paramstruct)); \
(_paramstruct).type = FMOD_DSP_PARAMETER_TYPE_BOOL; \
strncpy((_paramstruct).name, _name , 15); \
strncpy((_paramstruct).label, _label, 15); \
(_paramstruct).description = _description; \
(_paramstruct).booldesc.defaultval = _defaultval; \
(_paramstruct).booldesc.valuenames = _valuenames;
#define FMOD_DSP_INIT_PARAMDESC_DATA(_paramstruct, _name, _label, _description, _datatype) \
memset(&(_paramstruct), 0, sizeof(_paramstruct)); \
(_paramstruct).type = FMOD_DSP_PARAMETER_TYPE_DATA; \
strncpy((_paramstruct).name, _name , 15); \
strncpy((_paramstruct).label, _label, 15); \
(_paramstruct).description = _description; \
(_paramstruct).datadesc.datatype = _datatype;
#define FMOD_DSP_ALLOC(_state, _size) \
(_state)->functions->alloc(_size, FMOD_MEMORY_NORMAL, __FILE__)
#define FMOD_DSP_REALLOC(_state, _ptr, _size) \
(_state)->functions->realloc(_ptr, _size, FMOD_MEMORY_NORMAL, __FILE__)
#define FMOD_DSP_FREE(_state, _ptr) \
(_state)->functions->free(_ptr, FMOD_MEMORY_NORMAL, __FILE__)
#define FMOD_DSP_LOG(_state, _level, _location, _format, ...) \
(_state)->functions->log(_level, __FILE__, __LINE__, _location, _format, __VA_ARGS__)
#define FMOD_DSP_GETSAMPLERATE(_state, _rate) \
(_state)->functions->getsamplerate(_state, _rate)
#define FMOD_DSP_GETBLOCKSIZE(_state, _blocksize) \
(_state)->functions->getblocksize(_state, _blocksize)
#define FMOD_DSP_GETSPEAKERMODE(_state, _speakermodemix, _speakermodeout) \
(_state)->functions->getspeakermode(_state, _speakermodemix, _speakermodeout)
#define FMOD_DSP_GETCLOCK(_state, _clock, _offset, _length) \
(_state)->functions->getclock(_state, _clock, _offset, _length)
#define FMOD_DSP_GETLISTENERATTRIBUTES(_state, _numlisteners, _attributes) \
(_state)->functions->getlistenerattributes(_state, _numlisteners, _attributes)
#define FMOD_DSP_GETUSERDATA(_state, _userdata) \
(_state)->functions->getuserdata(_state, _userdata)
#define FMOD_DSP_DFT_FFTREAL(_state, _size, _signal, _dft, _window, _signalhop) \
(_state)->functions->dft->fftreal(_state, _size, _signal, _dft, _window, _signalhop)
#define FMOD_DSP_DFT_IFFTREAL(_state, _size, _dft, _signal, _window, _signalhop) \
(_state)->functions->dft->inversefftreal(_state, _size, _dft, _signal, _window, _signalhop)
#define FMOD_DSP_PAN_SUMMONOMATRIX(_state, _sourcespeakermode, _lowfrequencygain, _overallgain, _matrix) \
(_state)->functions->pan->summonomatrix(_state, _sourcespeakermode, _lowfrequencygain, _overallgain, _matrix)
#define FMOD_DSP_PAN_SUMSTEREOMATRIX(_state, _sourcespeakermode, _pan, _lowfrequencygain, _overallgain, _matrixhop, _matrix) \
(_state)->functions->pan->sumstereomatrix(_state, _sourcespeakermode, _pan, _lowfrequencygain, _overallgain, _matrixhop, _matrix)
#define FMOD_DSP_PAN_SUMSURROUNDMATRIX(_state, _sourcespeakermode, _targetspeakermode, _direction, _extent, _rotation, _lowfrequencygain, _overallgain, _matrixhop, _matrix, _flags) \
(_state)->functions->pan->sumsurroundmatrix(_state, _sourcespeakermode, _targetspeakermode, _direction, _extent, _rotation, _lowfrequencygain, _overallgain, _matrixhop, _matrix, _flags)
#define FMOD_DSP_PAN_SUMMONOTOSURROUNDMATRIX(_state, _targetspeakermode, _direction, _extent, _lowfrequencygain, _overallgain, _matrixhop, _matrix) \
(_state)->functions->pan->summonotosurroundmatrix(_state, _targetspeakermode, _direction, _extent, _lowfrequencygain, _overallgain, _matrixhop, _matrix)
#define FMOD_DSP_PAN_SUMSTEREOTOSURROUNDMATRIX(_state, _targetspeakermode, _direction, _extent, _rotation, _lowfrequencygain, _overallgain, matrixhop, _matrix) \
(_state)->functions->pan->sumstereotosurroundmatrix(_state, _targetspeakermode, _direction, _extent, _rotation, _lowfrequencygain, _overallgain, matrixhop, _matrix)
#define FMOD_DSP_PAN_GETROLLOFFGAIN(_state, _rolloff, _distance, _mindistance, _maxdistance, _gain) \
(_state)->functions->pan->getrolloffgain(_state, _rolloff, _distance, _mindistance, _maxdistance, _gain)
#endif
3rdparty/fmod/include/fmod_dsp_effects.h
Vendored
+577
View File
@@ -0,0 +1,577 @@
/* ============================================================================================================= */
/* FMOD Core API - Built-in effects header file. */
/* Copyright (c), Firelight Technologies Pty, Ltd. 2004-2023. */
/* */
/* In this header you can find parameter structures for FMOD system registered DSP effects */
/* and generators. */
/* */
/* For more detail visit: */
/* https://fmod.com/docs/2.02/api/core-api-common-dsp-effects.html#fmod_dsp_type */
/* ============================================================================================================= */
#ifndef _FMOD_DSP_EFFECTS_H
#define _FMOD_DSP_EFFECTS_H
typedef enum
{
FMOD_DSP_TYPE_UNKNOWN,
FMOD_DSP_TYPE_MIXER,
FMOD_DSP_TYPE_OSCILLATOR,
FMOD_DSP_TYPE_LOWPASS,
FMOD_DSP_TYPE_ITLOWPASS,
FMOD_DSP_TYPE_HIGHPASS,
FMOD_DSP_TYPE_ECHO,
FMOD_DSP_TYPE_FADER,
FMOD_DSP_TYPE_FLANGE,
FMOD_DSP_TYPE_DISTORTION,
FMOD_DSP_TYPE_NORMALIZE,
FMOD_DSP_TYPE_LIMITER,
FMOD_DSP_TYPE_PARAMEQ,
FMOD_DSP_TYPE_PITCHSHIFT,
FMOD_DSP_TYPE_CHORUS,
FMOD_DSP_TYPE_VSTPLUGIN,
FMOD_DSP_TYPE_WINAMPPLUGIN,
FMOD_DSP_TYPE_ITECHO,
FMOD_DSP_TYPE_COMPRESSOR,
FMOD_DSP_TYPE_SFXREVERB,
FMOD_DSP_TYPE_LOWPASS_SIMPLE,
FMOD_DSP_TYPE_DELAY,
FMOD_DSP_TYPE_TREMOLO,
FMOD_DSP_TYPE_LADSPAPLUGIN,
FMOD_DSP_TYPE_SEND,
FMOD_DSP_TYPE_RETURN,
FMOD_DSP_TYPE_HIGHPASS_SIMPLE,
FMOD_DSP_TYPE_PAN,
FMOD_DSP_TYPE_THREE_EQ,
FMOD_DSP_TYPE_FFT,
FMOD_DSP_TYPE_LOUDNESS_METER,
FMOD_DSP_TYPE_ENVELOPEFOLLOWER,
FMOD_DSP_TYPE_CONVOLUTIONREVERB,
FMOD_DSP_TYPE_CHANNELMIX,
FMOD_DSP_TYPE_TRANSCEIVER,
FMOD_DSP_TYPE_OBJECTPAN,
FMOD_DSP_TYPE_MULTIBAND_EQ,
FMOD_DSP_TYPE_MAX,
FMOD_DSP_TYPE_FORCEINT = 65536 /* Makes sure this enum is signed 32bit. */
} FMOD_DSP_TYPE;
/*
===================================================================================================
FMOD built in effect parameters.
Use DSP::setParameter with these enums for the 'index' parameter.
===================================================================================================
*/
typedef enum
{
FMOD_DSP_OSCILLATOR_TYPE,
FMOD_DSP_OSCILLATOR_RATE
} FMOD_DSP_OSCILLATOR;
typedef enum
{
FMOD_DSP_LOWPASS_CUTOFF,
FMOD_DSP_LOWPASS_RESONANCE
} FMOD_DSP_LOWPASS;
typedef enum
{
FMOD_DSP_ITLOWPASS_CUTOFF,
FMOD_DSP_ITLOWPASS_RESONANCE
} FMOD_DSP_ITLOWPASS;
typedef enum
{
FMOD_DSP_HIGHPASS_CUTOFF,
FMOD_DSP_HIGHPASS_RESONANCE
} FMOD_DSP_HIGHPASS;
typedef enum
{
FMOD_DSP_ECHO_DELAY,
FMOD_DSP_ECHO_FEEDBACK,
FMOD_DSP_ECHO_DRYLEVEL,
FMOD_DSP_ECHO_WETLEVEL
} FMOD_DSP_ECHO;
typedef enum FMOD_DSP_FADER
{
FMOD_DSP_FADER_GAIN,
FMOD_DSP_FADER_OVERALL_GAIN,
} FMOD_DSP_FADER;
typedef enum
{
FMOD_DSP_FLANGE_MIX,
FMOD_DSP_FLANGE_DEPTH,
FMOD_DSP_FLANGE_RATE
} FMOD_DSP_FLANGE;
typedef enum
{
FMOD_DSP_DISTORTION_LEVEL
} FMOD_DSP_DISTORTION;
typedef enum
{
FMOD_DSP_NORMALIZE_FADETIME,
FMOD_DSP_NORMALIZE_THRESHOLD,
FMOD_DSP_NORMALIZE_MAXAMP
} FMOD_DSP_NORMALIZE;
typedef enum
{
FMOD_DSP_LIMITER_RELEASETIME,
FMOD_DSP_LIMITER_CEILING,
FMOD_DSP_LIMITER_MAXIMIZERGAIN,
FMOD_DSP_LIMITER_MODE,
} FMOD_DSP_LIMITER;
typedef enum
{
FMOD_DSP_PARAMEQ_CENTER,
FMOD_DSP_PARAMEQ_BANDWIDTH,
FMOD_DSP_PARAMEQ_GAIN
} FMOD_DSP_PARAMEQ;
typedef enum FMOD_DSP_MULTIBAND_EQ
{
FMOD_DSP_MULTIBAND_EQ_A_FILTER,
FMOD_DSP_MULTIBAND_EQ_A_FREQUENCY,
FMOD_DSP_MULTIBAND_EQ_A_Q,
FMOD_DSP_MULTIBAND_EQ_A_GAIN,
FMOD_DSP_MULTIBAND_EQ_B_FILTER,
FMOD_DSP_MULTIBAND_EQ_B_FREQUENCY,
FMOD_DSP_MULTIBAND_EQ_B_Q,
FMOD_DSP_MULTIBAND_EQ_B_GAIN,
FMOD_DSP_MULTIBAND_EQ_C_FILTER,
FMOD_DSP_MULTIBAND_EQ_C_FREQUENCY,
FMOD_DSP_MULTIBAND_EQ_C_Q,
FMOD_DSP_MULTIBAND_EQ_C_GAIN,
FMOD_DSP_MULTIBAND_EQ_D_FILTER,
FMOD_DSP_MULTIBAND_EQ_D_FREQUENCY,
FMOD_DSP_MULTIBAND_EQ_D_Q,
FMOD_DSP_MULTIBAND_EQ_D_GAIN,
FMOD_DSP_MULTIBAND_EQ_E_FILTER,
FMOD_DSP_MULTIBAND_EQ_E_FREQUENCY,
FMOD_DSP_MULTIBAND_EQ_E_Q,
FMOD_DSP_MULTIBAND_EQ_E_GAIN,
} FMOD_DSP_MULTIBAND_EQ;
typedef enum FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE
{
FMOD_DSP_MULTIBAND_EQ_FILTER_DISABLED,
FMOD_DSP_MULTIBAND_EQ_FILTER_LOWPASS_12DB,
FMOD_DSP_MULTIBAND_EQ_FILTER_LOWPASS_24DB,
FMOD_DSP_MULTIBAND_EQ_FILTER_LOWPASS_48DB,
FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHPASS_12DB,
FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHPASS_24DB,
FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHPASS_48DB,
FMOD_DSP_MULTIBAND_EQ_FILTER_LOWSHELF,
FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHSHELF,
FMOD_DSP_MULTIBAND_EQ_FILTER_PEAKING,
FMOD_DSP_MULTIBAND_EQ_FILTER_BANDPASS,
FMOD_DSP_MULTIBAND_EQ_FILTER_NOTCH,
FMOD_DSP_MULTIBAND_EQ_FILTER_ALLPASS,
} FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE;
typedef enum
{
FMOD_DSP_PITCHSHIFT_PITCH,
FMOD_DSP_PITCHSHIFT_FFTSIZE,
FMOD_DSP_PITCHSHIFT_OVERLAP,
FMOD_DSP_PITCHSHIFT_MAXCHANNELS
} FMOD_DSP_PITCHSHIFT;
typedef enum
{
FMOD_DSP_CHORUS_MIX,
FMOD_DSP_CHORUS_RATE,
FMOD_DSP_CHORUS_DEPTH,
} FMOD_DSP_CHORUS;
typedef enum
{
FMOD_DSP_ITECHO_WETDRYMIX,
FMOD_DSP_ITECHO_FEEDBACK,
FMOD_DSP_ITECHO_LEFTDELAY,
FMOD_DSP_ITECHO_RIGHTDELAY,
FMOD_DSP_ITECHO_PANDELAY
} FMOD_DSP_ITECHO;
typedef enum
{
FMOD_DSP_COMPRESSOR_THRESHOLD,
FMOD_DSP_COMPRESSOR_RATIO,
FMOD_DSP_COMPRESSOR_ATTACK,
FMOD_DSP_COMPRESSOR_RELEASE,
FMOD_DSP_COMPRESSOR_GAINMAKEUP,
FMOD_DSP_COMPRESSOR_USESIDECHAIN,
FMOD_DSP_COMPRESSOR_LINKED
} FMOD_DSP_COMPRESSOR;
typedef enum
{
FMOD_DSP_SFXREVERB_DECAYTIME,
FMOD_DSP_SFXREVERB_EARLYDELAY,
FMOD_DSP_SFXREVERB_LATEDELAY,
FMOD_DSP_SFXREVERB_HFREFERENCE,
FMOD_DSP_SFXREVERB_HFDECAYRATIO,
FMOD_DSP_SFXREVERB_DIFFUSION,
FMOD_DSP_SFXREVERB_DENSITY,
FMOD_DSP_SFXREVERB_LOWSHELFFREQUENCY,
FMOD_DSP_SFXREVERB_LOWSHELFGAIN,
FMOD_DSP_SFXREVERB_HIGHCUT,
FMOD_DSP_SFXREVERB_EARLYLATEMIX,
FMOD_DSP_SFXREVERB_WETLEVEL,
FMOD_DSP_SFXREVERB_DRYLEVEL
} FMOD_DSP_SFXREVERB;
typedef enum
{
FMOD_DSP_LOWPASS_SIMPLE_CUTOFF
} FMOD_DSP_LOWPASS_SIMPLE;
typedef enum
{
FMOD_DSP_DELAY_CH0,
FMOD_DSP_DELAY_CH1,
FMOD_DSP_DELAY_CH2,
FMOD_DSP_DELAY_CH3,
FMOD_DSP_DELAY_CH4,
FMOD_DSP_DELAY_CH5,
FMOD_DSP_DELAY_CH6,
FMOD_DSP_DELAY_CH7,
FMOD_DSP_DELAY_CH8,
FMOD_DSP_DELAY_CH9,
FMOD_DSP_DELAY_CH10,
FMOD_DSP_DELAY_CH11,
FMOD_DSP_DELAY_CH12,
FMOD_DSP_DELAY_CH13,
FMOD_DSP_DELAY_CH14,
FMOD_DSP_DELAY_CH15,
FMOD_DSP_DELAY_MAXDELAY
} FMOD_DSP_DELAY;
typedef enum
{
FMOD_DSP_TREMOLO_FREQUENCY,
FMOD_DSP_TREMOLO_DEPTH,
FMOD_DSP_TREMOLO_SHAPE,
FMOD_DSP_TREMOLO_SKEW,
FMOD_DSP_TREMOLO_DUTY,
FMOD_DSP_TREMOLO_SQUARE,
FMOD_DSP_TREMOLO_PHASE,
FMOD_DSP_TREMOLO_SPREAD
} FMOD_DSP_TREMOLO;
typedef enum
{
FMOD_DSP_SEND_RETURNID,
FMOD_DSP_SEND_LEVEL,
} FMOD_DSP_SEND;
typedef enum
{
FMOD_DSP_RETURN_ID,
FMOD_DSP_RETURN_INPUT_SPEAKER_MODE
} FMOD_DSP_RETURN;
typedef enum
{
FMOD_DSP_HIGHPASS_SIMPLE_CUTOFF
} FMOD_DSP_HIGHPASS_SIMPLE;
typedef enum
{
FMOD_DSP_PAN_2D_STEREO_MODE_DISTRIBUTED,
FMOD_DSP_PAN_2D_STEREO_MODE_DISCRETE
} FMOD_DSP_PAN_2D_STEREO_MODE_TYPE;
typedef enum
{
FMOD_DSP_PAN_MODE_MONO,
FMOD_DSP_PAN_MODE_STEREO,
FMOD_DSP_PAN_MODE_SURROUND
} FMOD_DSP_PAN_MODE_TYPE;
typedef enum
{
FMOD_DSP_PAN_3D_ROLLOFF_LINEARSQUARED,
FMOD_DSP_PAN_3D_ROLLOFF_LINEAR,
FMOD_DSP_PAN_3D_ROLLOFF_INVERSE,
FMOD_DSP_PAN_3D_ROLLOFF_INVERSETAPERED,
FMOD_DSP_PAN_3D_ROLLOFF_CUSTOM
} FMOD_DSP_PAN_3D_ROLLOFF_TYPE;
typedef enum
{
FMOD_DSP_PAN_3D_EXTENT_MODE_AUTO,
FMOD_DSP_PAN_3D_EXTENT_MODE_USER,
FMOD_DSP_PAN_3D_EXTENT_MODE_OFF
} FMOD_DSP_PAN_3D_EXTENT_MODE_TYPE;
typedef enum
{
FMOD_DSP_PAN_MODE,
FMOD_DSP_PAN_2D_STEREO_POSITION,
FMOD_DSP_PAN_2D_DIRECTION,
FMOD_DSP_PAN_2D_EXTENT,
FMOD_DSP_PAN_2D_ROTATION,
FMOD_DSP_PAN_2D_LFE_LEVEL,
FMOD_DSP_PAN_2D_STEREO_MODE,
FMOD_DSP_PAN_2D_STEREO_SEPARATION,
FMOD_DSP_PAN_2D_STEREO_AXIS,
FMOD_DSP_PAN_ENABLED_SPEAKERS,
FMOD_DSP_PAN_3D_POSITION,
FMOD_DSP_PAN_3D_ROLLOFF,
FMOD_DSP_PAN_3D_MIN_DISTANCE,
FMOD_DSP_PAN_3D_MAX_DISTANCE,
FMOD_DSP_PAN_3D_EXTENT_MODE,
FMOD_DSP_PAN_3D_SOUND_SIZE,
FMOD_DSP_PAN_3D_MIN_EXTENT,
FMOD_DSP_PAN_3D_PAN_BLEND,
FMOD_DSP_PAN_LFE_UPMIX_ENABLED,
FMOD_DSP_PAN_OVERALL_GAIN,
FMOD_DSP_PAN_SURROUND_SPEAKER_MODE,
FMOD_DSP_PAN_2D_HEIGHT_BLEND,
FMOD_DSP_PAN_ATTENUATION_RANGE,
FMOD_DSP_PAN_OVERRIDE_RANGE
} FMOD_DSP_PAN;
typedef enum
{
FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_12DB,
FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_24DB,
FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_48DB
} FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_TYPE;
typedef enum
{
FMOD_DSP_THREE_EQ_LOWGAIN,
FMOD_DSP_THREE_EQ_MIDGAIN,
FMOD_DSP_THREE_EQ_HIGHGAIN,
FMOD_DSP_THREE_EQ_LOWCROSSOVER,
FMOD_DSP_THREE_EQ_HIGHCROSSOVER,
FMOD_DSP_THREE_EQ_CROSSOVERSLOPE
} FMOD_DSP_THREE_EQ;
typedef enum
{
FMOD_DSP_FFT_WINDOW_RECT,
FMOD_DSP_FFT_WINDOW_TRIANGLE,
FMOD_DSP_FFT_WINDOW_HAMMING,
FMOD_DSP_FFT_WINDOW_HANNING,
FMOD_DSP_FFT_WINDOW_BLACKMAN,
FMOD_DSP_FFT_WINDOW_BLACKMANHARRIS
} FMOD_DSP_FFT_WINDOW;
typedef enum
{
FMOD_DSP_FFT_WINDOWSIZE,
FMOD_DSP_FFT_WINDOWTYPE,
FMOD_DSP_FFT_SPECTRUMDATA,
FMOD_DSP_FFT_DOMINANT_FREQ
} FMOD_DSP_FFT;
#define FMOD_DSP_LOUDNESS_METER_HISTOGRAM_SAMPLES 66
typedef enum
{
FMOD_DSP_LOUDNESS_METER_STATE,
FMOD_DSP_LOUDNESS_METER_WEIGHTING,
FMOD_DSP_LOUDNESS_METER_INFO
} FMOD_DSP_LOUDNESS_METER;
typedef enum
{
FMOD_DSP_LOUDNESS_METER_STATE_RESET_INTEGRATED = -3,
FMOD_DSP_LOUDNESS_METER_STATE_RESET_MAXPEAK = -2,
FMOD_DSP_LOUDNESS_METER_STATE_RESET_ALL = -1,
FMOD_DSP_LOUDNESS_METER_STATE_PAUSED = 0,
FMOD_DSP_LOUDNESS_METER_STATE_ANALYZING = 1
} FMOD_DSP_LOUDNESS_METER_STATE_TYPE;
typedef struct FMOD_DSP_LOUDNESS_METER_INFO_TYPE
{
float momentaryloudness;
float shorttermloudness;
float integratedloudness;
float loudness10thpercentile;
float loudness95thpercentile;
float loudnesshistogram[FMOD_DSP_LOUDNESS_METER_HISTOGRAM_SAMPLES];
float maxtruepeak;
float maxmomentaryloudness;
} FMOD_DSP_LOUDNESS_METER_INFO_TYPE;
typedef struct FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE
{
float channelweight[32];
} FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE;
typedef enum
{
FMOD_DSP_ENVELOPEFOLLOWER_ATTACK,
FMOD_DSP_ENVELOPEFOLLOWER_RELEASE,
FMOD_DSP_ENVELOPEFOLLOWER_ENVELOPE,
FMOD_DSP_ENVELOPEFOLLOWER_USESIDECHAIN
} FMOD_DSP_ENVELOPEFOLLOWER;
typedef enum
{
FMOD_DSP_CONVOLUTION_REVERB_PARAM_IR,
FMOD_DSP_CONVOLUTION_REVERB_PARAM_WET,
FMOD_DSP_CONVOLUTION_REVERB_PARAM_DRY,
FMOD_DSP_CONVOLUTION_REVERB_PARAM_LINKED
} FMOD_DSP_CONVOLUTION_REVERB;
typedef enum
{
FMOD_DSP_CHANNELMIX_OUTPUT_DEFAULT,
FMOD_DSP_CHANNELMIX_OUTPUT_ALLMONO,
FMOD_DSP_CHANNELMIX_OUTPUT_ALLSTEREO,
FMOD_DSP_CHANNELMIX_OUTPUT_ALLQUAD,
FMOD_DSP_CHANNELMIX_OUTPUT_ALL5POINT1,
FMOD_DSP_CHANNELMIX_OUTPUT_ALL7POINT1,
FMOD_DSP_CHANNELMIX_OUTPUT_ALLLFE,
FMOD_DSP_CHANNELMIX_OUTPUT_ALL7POINT1POINT4
} FMOD_DSP_CHANNELMIX_OUTPUT;
typedef enum
{
FMOD_DSP_CHANNELMIX_OUTPUTGROUPING,
FMOD_DSP_CHANNELMIX_GAIN_CH0,
FMOD_DSP_CHANNELMIX_GAIN_CH1,
FMOD_DSP_CHANNELMIX_GAIN_CH2,
FMOD_DSP_CHANNELMIX_GAIN_CH3,
FMOD_DSP_CHANNELMIX_GAIN_CH4,
FMOD_DSP_CHANNELMIX_GAIN_CH5,
FMOD_DSP_CHANNELMIX_GAIN_CH6,
FMOD_DSP_CHANNELMIX_GAIN_CH7,
FMOD_DSP_CHANNELMIX_GAIN_CH8,
FMOD_DSP_CHANNELMIX_GAIN_CH9,
FMOD_DSP_CHANNELMIX_GAIN_CH10,
FMOD_DSP_CHANNELMIX_GAIN_CH11,
FMOD_DSP_CHANNELMIX_GAIN_CH12,
FMOD_DSP_CHANNELMIX_GAIN_CH13,
FMOD_DSP_CHANNELMIX_GAIN_CH14,
FMOD_DSP_CHANNELMIX_GAIN_CH15,
FMOD_DSP_CHANNELMIX_GAIN_CH16,
FMOD_DSP_CHANNELMIX_GAIN_CH17,
FMOD_DSP_CHANNELMIX_GAIN_CH18,
FMOD_DSP_CHANNELMIX_GAIN_CH19,
FMOD_DSP_CHANNELMIX_GAIN_CH20,
FMOD_DSP_CHANNELMIX_GAIN_CH21,
FMOD_DSP_CHANNELMIX_GAIN_CH22,
FMOD_DSP_CHANNELMIX_GAIN_CH23,
FMOD_DSP_CHANNELMIX_GAIN_CH24,
FMOD_DSP_CHANNELMIX_GAIN_CH25,
FMOD_DSP_CHANNELMIX_GAIN_CH26,
FMOD_DSP_CHANNELMIX_GAIN_CH27,
FMOD_DSP_CHANNELMIX_GAIN_CH28,
FMOD_DSP_CHANNELMIX_GAIN_CH29,
FMOD_DSP_CHANNELMIX_GAIN_CH30,
FMOD_DSP_CHANNELMIX_GAIN_CH31,
FMOD_DSP_CHANNELMIX_OUTPUT_CH0,
FMOD_DSP_CHANNELMIX_OUTPUT_CH1,
FMOD_DSP_CHANNELMIX_OUTPUT_CH2,
FMOD_DSP_CHANNELMIX_OUTPUT_CH3,
FMOD_DSP_CHANNELMIX_OUTPUT_CH4,
FMOD_DSP_CHANNELMIX_OUTPUT_CH5,
FMOD_DSP_CHANNELMIX_OUTPUT_CH6,
FMOD_DSP_CHANNELMIX_OUTPUT_CH7,
FMOD_DSP_CHANNELMIX_OUTPUT_CH8,
FMOD_DSP_CHANNELMIX_OUTPUT_CH9,
FMOD_DSP_CHANNELMIX_OUTPUT_CH10,
FMOD_DSP_CHANNELMIX_OUTPUT_CH11,
FMOD_DSP_CHANNELMIX_OUTPUT_CH12,
FMOD_DSP_CHANNELMIX_OUTPUT_CH13,
FMOD_DSP_CHANNELMIX_OUTPUT_CH14,
FMOD_DSP_CHANNELMIX_OUTPUT_CH15,
FMOD_DSP_CHANNELMIX_OUTPUT_CH16,
FMOD_DSP_CHANNELMIX_OUTPUT_CH17,
FMOD_DSP_CHANNELMIX_OUTPUT_CH18,
FMOD_DSP_CHANNELMIX_OUTPUT_CH19,
FMOD_DSP_CHANNELMIX_OUTPUT_CH20,
FMOD_DSP_CHANNELMIX_OUTPUT_CH21,
FMOD_DSP_CHANNELMIX_OUTPUT_CH22,
FMOD_DSP_CHANNELMIX_OUTPUT_CH23,
FMOD_DSP_CHANNELMIX_OUTPUT_CH24,
FMOD_DSP_CHANNELMIX_OUTPUT_CH25,
FMOD_DSP_CHANNELMIX_OUTPUT_CH26,
FMOD_DSP_CHANNELMIX_OUTPUT_CH27,
FMOD_DSP_CHANNELMIX_OUTPUT_CH28,
FMOD_DSP_CHANNELMIX_OUTPUT_CH29,
FMOD_DSP_CHANNELMIX_OUTPUT_CH30,
FMOD_DSP_CHANNELMIX_OUTPUT_CH31
} FMOD_DSP_CHANNELMIX;
typedef enum
{
FMOD_DSP_TRANSCEIVER_SPEAKERMODE_AUTO = -1,
FMOD_DSP_TRANSCEIVER_SPEAKERMODE_MONO = 0,
FMOD_DSP_TRANSCEIVER_SPEAKERMODE_STEREO,
FMOD_DSP_TRANSCEIVER_SPEAKERMODE_SURROUND,
} FMOD_DSP_TRANSCEIVER_SPEAKERMODE;
typedef enum
{
FMOD_DSP_TRANSCEIVER_TRANSMIT,
FMOD_DSP_TRANSCEIVER_GAIN,
FMOD_DSP_TRANSCEIVER_CHANNEL,
FMOD_DSP_TRANSCEIVER_TRANSMITSPEAKERMODE
} FMOD_DSP_TRANSCEIVER;
typedef enum
{
FMOD_DSP_OBJECTPAN_3D_POSITION,
FMOD_DSP_OBJECTPAN_3D_ROLLOFF,
FMOD_DSP_OBJECTPAN_3D_MIN_DISTANCE,
FMOD_DSP_OBJECTPAN_3D_MAX_DISTANCE,
FMOD_DSP_OBJECTPAN_3D_EXTENT_MODE,
FMOD_DSP_OBJECTPAN_3D_SOUND_SIZE,
FMOD_DSP_OBJECTPAN_3D_MIN_EXTENT,
FMOD_DSP_OBJECTPAN_OVERALL_GAIN,
FMOD_DSP_OBJECTPAN_OUTPUTGAIN,
FMOD_DSP_OBJECTPAN_ATTENUATION_RANGE,
FMOD_DSP_OBJECTPAN_OVERRIDE_RANGE
} FMOD_DSP_OBJECTPAN;
#endif
3rdparty/fmod/include/fmod_output.h
Vendored
+122
View File
@@ -0,0 +1,122 @@
/* ======================================================================================== */
/* FMOD Core API - output development header file. */
/* Copyright (c), Firelight Technologies Pty, Ltd. 2004-2023. */
/* */
/* Use this header if you are wanting to develop your own output plugin to use with */
/* FMOD's output system. With this header you can make your own output plugin that FMOD */
/* can register and use. See the documentation and examples on how to make a working */
/* plugin. */
/* */
/* For more detail visit: */
/* https://fmod.com/docs/2.02/api/plugin-api-output.html */
/* ======================================================================================== */
#ifndef _FMOD_OUTPUT_H
#define _FMOD_OUTPUT_H
typedef struct FMOD_OUTPUT_STATE FMOD_OUTPUT_STATE;
typedef struct FMOD_OUTPUT_OBJECT3DINFO FMOD_OUTPUT_OBJECT3DINFO;
/*
Output constants
*/
#define FMOD_OUTPUT_PLUGIN_VERSION 5
typedef unsigned int FMOD_OUTPUT_METHOD;
#define FMOD_OUTPUT_METHOD_MIX_DIRECT 0
#define FMOD_OUTPUT_METHOD_MIX_BUFFERED 1
/*
Output callbacks
*/
typedef FMOD_RESULT (F_CALL *FMOD_OUTPUT_GETNUMDRIVERS_CALLBACK) (FMOD_OUTPUT_STATE *output_state, int *numdrivers);
typedef FMOD_RESULT (F_CALL *FMOD_OUTPUT_GETDRIVERINFO_CALLBACK) (FMOD_OUTPUT_STATE *output_state, int id, char *name, int namelen, FMOD_GUID *guid, int *systemrate, FMOD_SPEAKERMODE *speakermode, int *speakermodechannels);
typedef FMOD_RESULT (F_CALL *FMOD_OUTPUT_INIT_CALLBACK) (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);
typedef FMOD_RESULT (F_CALL *FMOD_OUTPUT_START_CALLBACK) (FMOD_OUTPUT_STATE *output_state);
typedef FMOD_RESULT (F_CALL *FMOD_OUTPUT_STOP_CALLBACK) (FMOD_OUTPUT_STATE *output_state);
typedef FMOD_RESULT (F_CALL *FMOD_OUTPUT_CLOSE_CALLBACK) (FMOD_OUTPUT_STATE *output_state);
typedef FMOD_RESULT (F_CALL *FMOD_OUTPUT_UPDATE_CALLBACK) (FMOD_OUTPUT_STATE *output_state);
typedef FMOD_RESULT (F_CALL *FMOD_OUTPUT_GETHANDLE_CALLBACK) (FMOD_OUTPUT_STATE *output_state, void **handle);
typedef FMOD_RESULT (F_CALL *FMOD_OUTPUT_MIXER_CALLBACK) (FMOD_OUTPUT_STATE *output_state);
typedef FMOD_RESULT (F_CALL *FMOD_OUTPUT_OBJECT3DGETINFO_CALLBACK) (FMOD_OUTPUT_STATE *output_state, int *maxhardwareobjects);
typedef FMOD_RESULT (F_CALL *FMOD_OUTPUT_OBJECT3DALLOC_CALLBACK) (FMOD_OUTPUT_STATE *output_state, void **object3d);
typedef FMOD_RESULT (F_CALL *FMOD_OUTPUT_OBJECT3DFREE_CALLBACK) (FMOD_OUTPUT_STATE *output_state, void *object3d);
typedef FMOD_RESULT (F_CALL *FMOD_OUTPUT_OBJECT3DUPDATE_CALLBACK) (FMOD_OUTPUT_STATE *output_state, void *object3d, const FMOD_OUTPUT_OBJECT3DINFO *info);
typedef FMOD_RESULT (F_CALL *FMOD_OUTPUT_OPENPORT_CALLBACK) (FMOD_OUTPUT_STATE *output_state, FMOD_PORT_TYPE portType, FMOD_PORT_INDEX portIndex, int *portId, int *portRate, int *portChannels, FMOD_SOUND_FORMAT *portFormat);
typedef FMOD_RESULT (F_CALL *FMOD_OUTPUT_CLOSEPORT_CALLBACK) (FMOD_OUTPUT_STATE *output_state, int portId);
typedef FMOD_RESULT (F_CALL *FMOD_OUTPUT_DEVICELISTCHANGED_CALLBACK)(FMOD_OUTPUT_STATE *output_state);
/*
Output functions
*/
typedef FMOD_RESULT (F_CALL *FMOD_OUTPUT_READFROMMIXER_FUNC) (FMOD_OUTPUT_STATE *output_state, void *buffer, unsigned int length);
typedef FMOD_RESULT (F_CALL *FMOD_OUTPUT_COPYPORT_FUNC) (FMOD_OUTPUT_STATE *output_state, int portId, void *buffer, unsigned int length);
typedef FMOD_RESULT (F_CALL *FMOD_OUTPUT_REQUESTRESET_FUNC) (FMOD_OUTPUT_STATE *output_state);
typedef void * (F_CALL *FMOD_OUTPUT_ALLOC_FUNC) (unsigned int size, unsigned int align, const char *file, int line);
typedef void (F_CALL *FMOD_OUTPUT_FREE_FUNC) (void *ptr, const char *file, int line);
typedef void (F_CALL *FMOD_OUTPUT_LOG_FUNC) (FMOD_DEBUG_FLAGS level, const char *file, int line, const char *function, const char *string, ...);
/*
Output structures
*/
typedef struct FMOD_OUTPUT_DESCRIPTION
{
unsigned int apiversion;
const char *name;
unsigned int version;
FMOD_OUTPUT_METHOD method;
FMOD_OUTPUT_GETNUMDRIVERS_CALLBACK getnumdrivers;
FMOD_OUTPUT_GETDRIVERINFO_CALLBACK getdriverinfo;
FMOD_OUTPUT_INIT_CALLBACK init;
FMOD_OUTPUT_START_CALLBACK start;
FMOD_OUTPUT_STOP_CALLBACK stop;
FMOD_OUTPUT_CLOSE_CALLBACK close;
FMOD_OUTPUT_UPDATE_CALLBACK update;
FMOD_OUTPUT_GETHANDLE_CALLBACK gethandle;
FMOD_OUTPUT_MIXER_CALLBACK mixer;
FMOD_OUTPUT_OBJECT3DGETINFO_CALLBACK object3dgetinfo;
FMOD_OUTPUT_OBJECT3DALLOC_CALLBACK object3dalloc;
FMOD_OUTPUT_OBJECT3DFREE_CALLBACK object3dfree;
FMOD_OUTPUT_OBJECT3DUPDATE_CALLBACK object3dupdate;
FMOD_OUTPUT_OPENPORT_CALLBACK openport;
FMOD_OUTPUT_CLOSEPORT_CALLBACK closeport;
FMOD_OUTPUT_DEVICELISTCHANGED_CALLBACK devicelistchanged;
} FMOD_OUTPUT_DESCRIPTION;
struct FMOD_OUTPUT_STATE
{
void *plugindata;
FMOD_OUTPUT_READFROMMIXER_FUNC readfrommixer;
FMOD_OUTPUT_ALLOC_FUNC alloc;
FMOD_OUTPUT_FREE_FUNC free;
FMOD_OUTPUT_LOG_FUNC log;
FMOD_OUTPUT_COPYPORT_FUNC copyport;
FMOD_OUTPUT_REQUESTRESET_FUNC requestreset;
};
struct FMOD_OUTPUT_OBJECT3DINFO
{
float *buffer;
unsigned int bufferlength;
FMOD_VECTOR position;
float gain;
float spread;
float priority;
};
/*
Output macros
*/
#define FMOD_OUTPUT_READFROMMIXER(_state, _buffer, _length) \
(_state)->readfrommixer(_state, _buffer, _length)
#define FMOD_OUTPUT_ALLOC(_state, _size, _align) \
(_state)->alloc(_size, _align, __FILE__, __LINE__)
#define FMOD_OUTPUT_FREE(_state, _ptr) \
(_state)->free(_ptr, __FILE__, __LINE__)
#define FMOD_OUTPUT_LOG(_state, _level, _location, _format, ...) \
(_state)->log(_level, __FILE__, __LINE__, _location, _format, ##__VA_ARGS__)
#define FMOD_OUTPUT_COPYPORT(_state, _id, _buffer, _length) \
(_state)->copyport(_state, _id, _buffer, _length)
#define FMOD_OUTPUT_REQUESTRESET(_state) \
(_state)->requestreset(_state)
#endif /* _FMOD_OUTPUT_H */
3rdparty/fmod/lib/libfmod.so
Vendored Symlink
+1
View File
@@ -0,0 +1 @@
/home/illusion/Desktop/repos/cudoku/3rdparty/fmod/lib/libfmod.so.13.18
3rdparty/fmod/lib/libfmod.so.13
Vendored Symlink
+1
View File
@@ -0,0 +1 @@
/home/illusion/Desktop/repos/cudoku/3rdparty/fmod/lib/libfmod.so.13.18
3rdparty/fmod/lib/libfmod.so.13.18
Vendored Executable
BIN
View File
Binary file not shown.
3rdparty/glad/include/KHR/khrplatform.h
Vendored
+311
View File
@@ -0,0 +1,311 @@
#ifndef __khrplatform_h_
#define __khrplatform_h_
/*
** Copyright (c) 2008-2018 The Khronos Group Inc.
**
** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the
** "Materials"), to deal in the Materials without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Materials, and to
** permit persons to whom the Materials are furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Materials.
**
** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/
/* Khronos platform-specific types and definitions.
*
* The master copy of khrplatform.h is maintained in the Khronos EGL
* Registry repository at https://github.com/KhronosGroup/EGL-Registry
* The last semantic modification to khrplatform.h was at commit ID:
* 67a3e0864c2d75ea5287b9f3d2eb74a745936692
*
* Adopters may modify this file to suit their platform. Adopters are
* encouraged to submit platform specific modifications to the Khronos
* group so that they can be included in future versions of this file.
* Please submit changes by filing pull requests or issues on
* the EGL Registry repository linked above.
*
*
* See the Implementer's Guidelines for information about where this file
* should be located on your system and for more details of its use:
* http://www.khronos.org/registry/implementers_guide.pdf
*
* This file should be included as
* #include <KHR/khrplatform.h>
* by Khronos client API header files that use its types and defines.
*
* The types in khrplatform.h should only be used to define API-specific types.
*
* Types defined in khrplatform.h:
* khronos_int8_t signed 8 bit
* khronos_uint8_t unsigned 8 bit
* khronos_int16_t signed 16 bit
* khronos_uint16_t unsigned 16 bit
* khronos_int32_t signed 32 bit
* khronos_uint32_t unsigned 32 bit
* khronos_int64_t signed 64 bit
* khronos_uint64_t unsigned 64 bit
* khronos_intptr_t signed same number of bits as a pointer
* khronos_uintptr_t unsigned same number of bits as a pointer
* khronos_ssize_t signed size
* khronos_usize_t unsigned size
* khronos_float_t signed 32 bit floating point
* khronos_time_ns_t unsigned 64 bit time in nanoseconds
* khronos_utime_nanoseconds_t unsigned time interval or absolute time in
* nanoseconds
* khronos_stime_nanoseconds_t signed time interval in nanoseconds
* khronos_boolean_enum_t enumerated boolean type. This should
* only be used as a base type when a client API's boolean type is
* an enum. Client APIs which use an integer or other type for
* booleans cannot use this as the base type for their boolean.
*
* Tokens defined in khrplatform.h:
*
* KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
*
* KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
* KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
*
* Calling convention macros defined in this file:
* KHRONOS_APICALL
* KHRONOS_APIENTRY
* KHRONOS_APIATTRIBUTES
*
* These may be used in function prototypes as:
*
* KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
* int arg1,
* int arg2) KHRONOS_APIATTRIBUTES;
*/
#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
# define KHRONOS_STATIC 1
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APICALL
*-------------------------------------------------------------------------
* This precedes the return type of the function in the function prototype.
*/
#if defined(KHRONOS_STATIC)
/* If the preprocessor constant KHRONOS_STATIC is defined, make the
* header compatible with static linking. */
# define KHRONOS_APICALL
#elif defined(_WIN32)
# define KHRONOS_APICALL __declspec(dllimport)
#elif defined (__SYMBIAN32__)
# define KHRONOS_APICALL IMPORT_C
#elif defined(__ANDROID__)
# define KHRONOS_APICALL __attribute__((visibility("default")))
#else
# define KHRONOS_APICALL
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APIENTRY
*-------------------------------------------------------------------------
* This follows the return type of the function and precedes the function
* name in the function prototype.
*/
#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
/* Win32 but not WinCE */
# define KHRONOS_APIENTRY __stdcall
#else
# define KHRONOS_APIENTRY
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APIATTRIBUTES
*-------------------------------------------------------------------------
* This follows the closing parenthesis of the function prototype arguments.
*/
#if defined (__ARMCC_2__)
#define KHRONOS_APIATTRIBUTES __softfp
#else
#define KHRONOS_APIATTRIBUTES
#endif
/*-------------------------------------------------------------------------
* basic type definitions
*-----------------------------------------------------------------------*/
#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
/*
* Using <stdint.h>
*/
#include <stdint.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
/*
* To support platform where unsigned long cannot be used interchangeably with
* inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t.
* Ideally, we could just use (u)intptr_t everywhere, but this could result in
* ABI breakage if khronos_uintptr_t is changed from unsigned long to
* unsigned long long or similar (this results in different C++ name mangling).
* To avoid changes for existing platforms, we restrict usage of intptr_t to
* platforms where the size of a pointer is larger than the size of long.
*/
#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__)
#if __SIZEOF_POINTER__ > __SIZEOF_LONG__
#define KHRONOS_USE_INTPTR_T
#endif
#endif
#elif defined(__VMS ) || defined(__sgi)
/*
* Using <inttypes.h>
*/
#include <inttypes.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
/*
* Win32
*/
typedef __int32 khronos_int32_t;
typedef unsigned __int32 khronos_uint32_t;
typedef __int64 khronos_int64_t;
typedef unsigned __int64 khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(__sun__) || defined(__digital__)
/*
* Sun or Digital
*/
typedef int khronos_int32_t;
typedef unsigned int khronos_uint32_t;
#if defined(__arch64__) || defined(_LP64)
typedef long int khronos_int64_t;
typedef unsigned long int khronos_uint64_t;
#else
typedef long long int khronos_int64_t;
typedef unsigned long long int khronos_uint64_t;
#endif /* __arch64__ */
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif 0
/*
* Hypothetical platform with no float or int64 support
*/
typedef int khronos_int32_t;
typedef unsigned int khronos_uint32_t;
#define KHRONOS_SUPPORT_INT64 0
#define KHRONOS_SUPPORT_FLOAT 0
#else
/*
* Generic fallback
*/
#include <stdint.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#endif
/*
* Types that are (so far) the same on all platforms
*/
typedef signed char khronos_int8_t;
typedef unsigned char khronos_uint8_t;
typedef signed short int khronos_int16_t;
typedef unsigned short int khronos_uint16_t;
/*
* Types that differ between LLP64 and LP64 architectures - in LLP64,
* pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
* to be the only LLP64 architecture in current use.
*/
#ifdef KHRONOS_USE_INTPTR_T
typedef intptr_t khronos_intptr_t;
typedef uintptr_t khronos_uintptr_t;
#elif defined(_WIN64)
typedef signed long long int khronos_intptr_t;
typedef unsigned long long int khronos_uintptr_t;
#else
typedef signed long int khronos_intptr_t;
typedef unsigned long int khronos_uintptr_t;
#endif
#if defined(_WIN64)
typedef signed long long int khronos_ssize_t;
typedef unsigned long long int khronos_usize_t;
#else
typedef signed long int khronos_ssize_t;
typedef unsigned long int khronos_usize_t;
#endif
#if KHRONOS_SUPPORT_FLOAT
/*
* Float type
*/
typedef float khronos_float_t;
#endif
#if KHRONOS_SUPPORT_INT64
/* Time types
*
* These types can be used to represent a time interval in nanoseconds or
* an absolute Unadjusted System Time. Unadjusted System Time is the number
* of nanoseconds since some arbitrary system event (e.g. since the last
* time the system booted). The Unadjusted System Time is an unsigned
* 64 bit value that wraps back to 0 every 584 years. Time intervals
* may be either signed or unsigned.
*/
typedef khronos_uint64_t khronos_utime_nanoseconds_t;
typedef khronos_int64_t khronos_stime_nanoseconds_t;
#endif
/*
* Dummy value used to pad enum types to 32 bits.
*/
#ifndef KHRONOS_MAX_ENUM
#define KHRONOS_MAX_ENUM 0x7FFFFFFF
#endif
/*
* Enumerated boolean type
*
* Values other than zero should be considered to be true. Therefore
* comparisons should not be made against KHRONOS_TRUE.
*/
typedef enum {
KHRONOS_FALSE = 0,
KHRONOS_TRUE = 1,
KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
} khronos_boolean_enum_t;
#endif /* __khrplatform_h_ */
3rdparty/glad/include/glad/gl.h
Vendored
+15464
View File
File diff suppressed because one or more lines are too long
3rdparty/glad/include/glad/glx.h
Vendored
+1178
View File
File diff suppressed because it is too large Load Diff
3rdparty/glad/src/gl.c
Vendored
+9467
View File
File diff suppressed because it is too large Load Diff
3rdparty/glad/src/glx.c
Vendored
+795
View File
@@ -0,0 +1,795 @@
/**
* SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <glad/glx.h>
#ifndef GLAD_IMPL_UTIL_C_
#define GLAD_IMPL_UTIL_C_
#ifdef _MSC_VER
#define GLAD_IMPL_UTIL_SSCANF sscanf_s
#else
#define GLAD_IMPL_UTIL_SSCANF sscanf
#endif
#endif /* GLAD_IMPL_UTIL_C_ */
#ifdef __cplusplus
extern "C" {
#endif
int GLAD_GLX_VERSION_1_0 = 0;
int GLAD_GLX_VERSION_1_1 = 0;
int GLAD_GLX_VERSION_1_2 = 0;
int GLAD_GLX_VERSION_1_3 = 0;
int GLAD_GLX_VERSION_1_4 = 0;
int GLAD_GLX_3DFX_multisample = 0;
int GLAD_GLX_AMD_gpu_association = 0;
int GLAD_GLX_ARB_context_flush_control = 0;
int GLAD_GLX_ARB_create_context = 0;
int GLAD_GLX_ARB_create_context_no_error = 0;
int GLAD_GLX_ARB_create_context_profile = 0;
int GLAD_GLX_ARB_create_context_robustness = 0;
int GLAD_GLX_ARB_fbconfig_float = 0;
int GLAD_GLX_ARB_framebuffer_sRGB = 0;
int GLAD_GLX_ARB_get_proc_address = 0;
int GLAD_GLX_ARB_multisample = 0;
int GLAD_GLX_ARB_robustness_application_isolation = 0;
int GLAD_GLX_ARB_robustness_share_group_isolation = 0;
int GLAD_GLX_ARB_vertex_buffer_object = 0;
int GLAD_GLX_EXT_buffer_age = 0;
int GLAD_GLX_EXT_context_priority = 0;
int GLAD_GLX_EXT_create_context_es2_profile = 0;
int GLAD_GLX_EXT_create_context_es_profile = 0;
int GLAD_GLX_EXT_fbconfig_packed_float = 0;
int GLAD_GLX_EXT_framebuffer_sRGB = 0;
int GLAD_GLX_EXT_get_drawable_type = 0;
int GLAD_GLX_EXT_import_context = 0;
int GLAD_GLX_EXT_libglvnd = 0;
int GLAD_GLX_EXT_no_config_context = 0;
int GLAD_GLX_EXT_stereo_tree = 0;
int GLAD_GLX_EXT_swap_control = 0;
int GLAD_GLX_EXT_swap_control_tear = 0;
int GLAD_GLX_EXT_texture_from_pixmap = 0;
int GLAD_GLX_EXT_visual_info = 0;
int GLAD_GLX_EXT_visual_rating = 0;
int GLAD_GLX_INTEL_swap_event = 0;
int GLAD_GLX_MESA_agp_offset = 0;
int GLAD_GLX_MESA_copy_sub_buffer = 0;
int GLAD_GLX_MESA_pixmap_colormap = 0;
int GLAD_GLX_MESA_query_renderer = 0;
int GLAD_GLX_MESA_release_buffers = 0;
int GLAD_GLX_MESA_set_3dfx_mode = 0;
int GLAD_GLX_MESA_swap_control = 0;
int GLAD_GLX_NV_copy_buffer = 0;
int GLAD_GLX_NV_copy_image = 0;
int GLAD_GLX_NV_delay_before_swap = 0;
int GLAD_GLX_NV_float_buffer = 0;
int GLAD_GLX_NV_multigpu_context = 0;
int GLAD_GLX_NV_multisample_coverage = 0;
int GLAD_GLX_NV_present_video = 0;
int GLAD_GLX_NV_robustness_video_memory_purge = 0;
int GLAD_GLX_NV_swap_group = 0;
int GLAD_GLX_NV_video_capture = 0;
int GLAD_GLX_NV_video_out = 0;
int GLAD_GLX_OML_swap_method = 0;
int GLAD_GLX_OML_sync_control = 0;
int GLAD_GLX_SGIS_blended_overlay = 0;
int GLAD_GLX_SGIS_multisample = 0;
int GLAD_GLX_SGIS_shared_multisample = 0;
int GLAD_GLX_SGIX_fbconfig = 0;
int GLAD_GLX_SGIX_hyperpipe = 0;
int GLAD_GLX_SGIX_pbuffer = 0;
int GLAD_GLX_SGIX_swap_barrier = 0;
int GLAD_GLX_SGIX_swap_group = 0;
int GLAD_GLX_SGIX_video_resize = 0;
int GLAD_GLX_SGIX_visual_select_group = 0;
int GLAD_GLX_SGI_cushion = 0;
int GLAD_GLX_SGI_make_current_read = 0;
int GLAD_GLX_SGI_swap_control = 0;
int GLAD_GLX_SGI_video_sync = 0;
int GLAD_GLX_SUN_get_transparent_index = 0;
PFNGLXBINDCHANNELTOWINDOWSGIXPROC glad_glXBindChannelToWindowSGIX = NULL;
PFNGLXBINDHYPERPIPESGIXPROC glad_glXBindHyperpipeSGIX = NULL;
PFNGLXBINDSWAPBARRIERNVPROC glad_glXBindSwapBarrierNV = NULL;
PFNGLXBINDSWAPBARRIERSGIXPROC glad_glXBindSwapBarrierSGIX = NULL;
PFNGLXBINDTEXIMAGEEXTPROC glad_glXBindTexImageEXT = NULL;
PFNGLXBINDVIDEOCAPTUREDEVICENVPROC glad_glXBindVideoCaptureDeviceNV = NULL;
PFNGLXBINDVIDEODEVICENVPROC glad_glXBindVideoDeviceNV = NULL;
PFNGLXBINDVIDEOIMAGENVPROC glad_glXBindVideoImageNV = NULL;
PFNGLXBLITCONTEXTFRAMEBUFFERAMDPROC glad_glXBlitContextFramebufferAMD = NULL;
PFNGLXCHANNELRECTSGIXPROC glad_glXChannelRectSGIX = NULL;
PFNGLXCHANNELRECTSYNCSGIXPROC glad_glXChannelRectSyncSGIX = NULL;
PFNGLXCHOOSEFBCONFIGPROC glad_glXChooseFBConfig = NULL;
PFNGLXCHOOSEFBCONFIGSGIXPROC glad_glXChooseFBConfigSGIX = NULL;
PFNGLXCHOOSEVISUALPROC glad_glXChooseVisual = NULL;
PFNGLXCOPYBUFFERSUBDATANVPROC glad_glXCopyBufferSubDataNV = NULL;
PFNGLXCOPYCONTEXTPROC glad_glXCopyContext = NULL;
PFNGLXCOPYIMAGESUBDATANVPROC glad_glXCopyImageSubDataNV = NULL;
PFNGLXCOPYSUBBUFFERMESAPROC glad_glXCopySubBufferMESA = NULL;
PFNGLXCREATEASSOCIATEDCONTEXTAMDPROC glad_glXCreateAssociatedContextAMD = NULL;
PFNGLXCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC glad_glXCreateAssociatedContextAttribsAMD = NULL;
PFNGLXCREATECONTEXTPROC glad_glXCreateContext = NULL;
PFNGLXCREATECONTEXTATTRIBSARBPROC glad_glXCreateContextAttribsARB = NULL;
PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC glad_glXCreateContextWithConfigSGIX = NULL;
PFNGLXCREATEGLXPBUFFERSGIXPROC glad_glXCreateGLXPbufferSGIX = NULL;
PFNGLXCREATEGLXPIXMAPPROC glad_glXCreateGLXPixmap = NULL;
PFNGLXCREATEGLXPIXMAPMESAPROC glad_glXCreateGLXPixmapMESA = NULL;
PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC glad_glXCreateGLXPixmapWithConfigSGIX = NULL;
PFNGLXCREATENEWCONTEXTPROC glad_glXCreateNewContext = NULL;
PFNGLXCREATEPBUFFERPROC glad_glXCreatePbuffer = NULL;
PFNGLXCREATEPIXMAPPROC glad_glXCreatePixmap = NULL;
PFNGLXCREATEWINDOWPROC glad_glXCreateWindow = NULL;
PFNGLXCUSHIONSGIPROC glad_glXCushionSGI = NULL;
PFNGLXDELAYBEFORESWAPNVPROC glad_glXDelayBeforeSwapNV = NULL;
PFNGLXDELETEASSOCIATEDCONTEXTAMDPROC glad_glXDeleteAssociatedContextAMD = NULL;
PFNGLXDESTROYCONTEXTPROC glad_glXDestroyContext = NULL;
PFNGLXDESTROYGLXPBUFFERSGIXPROC glad_glXDestroyGLXPbufferSGIX = NULL;
PFNGLXDESTROYGLXPIXMAPPROC glad_glXDestroyGLXPixmap = NULL;
PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC glad_glXDestroyHyperpipeConfigSGIX = NULL;
PFNGLXDESTROYPBUFFERPROC glad_glXDestroyPbuffer = NULL;
PFNGLXDESTROYPIXMAPPROC glad_glXDestroyPixmap = NULL;
PFNGLXDESTROYWINDOWPROC glad_glXDestroyWindow = NULL;
PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC glad_glXEnumerateVideoCaptureDevicesNV = NULL;
PFNGLXENUMERATEVIDEODEVICESNVPROC glad_glXEnumerateVideoDevicesNV = NULL;
PFNGLXFREECONTEXTEXTPROC glad_glXFreeContextEXT = NULL;
PFNGLXGETAGPOFFSETMESAPROC glad_glXGetAGPOffsetMESA = NULL;
PFNGLXGETCLIENTSTRINGPROC glad_glXGetClientString = NULL;
PFNGLXGETCONFIGPROC glad_glXGetConfig = NULL;
PFNGLXGETCONTEXTGPUIDAMDPROC glad_glXGetContextGPUIDAMD = NULL;
PFNGLXGETCONTEXTIDEXTPROC glad_glXGetContextIDEXT = NULL;
PFNGLXGETCURRENTASSOCIATEDCONTEXTAMDPROC glad_glXGetCurrentAssociatedContextAMD = NULL;
PFNGLXGETCURRENTCONTEXTPROC glad_glXGetCurrentContext = NULL;
PFNGLXGETCURRENTDISPLAYPROC glad_glXGetCurrentDisplay = NULL;
PFNGLXGETCURRENTDISPLAYEXTPROC glad_glXGetCurrentDisplayEXT = NULL;
PFNGLXGETCURRENTDRAWABLEPROC glad_glXGetCurrentDrawable = NULL;
PFNGLXGETCURRENTREADDRAWABLEPROC glad_glXGetCurrentReadDrawable = NULL;
PFNGLXGETCURRENTREADDRAWABLESGIPROC glad_glXGetCurrentReadDrawableSGI = NULL;
PFNGLXGETFBCONFIGATTRIBPROC glad_glXGetFBConfigAttrib = NULL;
PFNGLXGETFBCONFIGATTRIBSGIXPROC glad_glXGetFBConfigAttribSGIX = NULL;
PFNGLXGETFBCONFIGFROMVISUALSGIXPROC glad_glXGetFBConfigFromVisualSGIX = NULL;
PFNGLXGETFBCONFIGSPROC glad_glXGetFBConfigs = NULL;
PFNGLXGETGPUIDSAMDPROC glad_glXGetGPUIDsAMD = NULL;
PFNGLXGETGPUINFOAMDPROC glad_glXGetGPUInfoAMD = NULL;
PFNGLXGETMSCRATEOMLPROC glad_glXGetMscRateOML = NULL;
PFNGLXGETPROCADDRESSPROC glad_glXGetProcAddress = NULL;
PFNGLXGETPROCADDRESSARBPROC glad_glXGetProcAddressARB = NULL;
PFNGLXGETSELECTEDEVENTPROC glad_glXGetSelectedEvent = NULL;
PFNGLXGETSELECTEDEVENTSGIXPROC glad_glXGetSelectedEventSGIX = NULL;
PFNGLXGETSWAPINTERVALMESAPROC glad_glXGetSwapIntervalMESA = NULL;
PFNGLXGETSYNCVALUESOMLPROC glad_glXGetSyncValuesOML = NULL;
PFNGLXGETTRANSPARENTINDEXSUNPROC glad_glXGetTransparentIndexSUN = NULL;
PFNGLXGETVIDEODEVICENVPROC glad_glXGetVideoDeviceNV = NULL;
PFNGLXGETVIDEOINFONVPROC glad_glXGetVideoInfoNV = NULL;
PFNGLXGETVIDEOSYNCSGIPROC glad_glXGetVideoSyncSGI = NULL;
PFNGLXGETVISUALFROMFBCONFIGPROC glad_glXGetVisualFromFBConfig = NULL;
PFNGLXGETVISUALFROMFBCONFIGSGIXPROC glad_glXGetVisualFromFBConfigSGIX = NULL;
PFNGLXHYPERPIPEATTRIBSGIXPROC glad_glXHyperpipeAttribSGIX = NULL;
PFNGLXHYPERPIPECONFIGSGIXPROC glad_glXHyperpipeConfigSGIX = NULL;
PFNGLXIMPORTCONTEXTEXTPROC glad_glXImportContextEXT = NULL;
PFNGLXISDIRECTPROC glad_glXIsDirect = NULL;
PFNGLXJOINSWAPGROUPNVPROC glad_glXJoinSwapGroupNV = NULL;
PFNGLXJOINSWAPGROUPSGIXPROC glad_glXJoinSwapGroupSGIX = NULL;
PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC glad_glXLockVideoCaptureDeviceNV = NULL;
PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC glad_glXMakeAssociatedContextCurrentAMD = NULL;
PFNGLXMAKECONTEXTCURRENTPROC glad_glXMakeContextCurrent = NULL;
PFNGLXMAKECURRENTPROC glad_glXMakeCurrent = NULL;
PFNGLXMAKECURRENTREADSGIPROC glad_glXMakeCurrentReadSGI = NULL;
PFNGLXNAMEDCOPYBUFFERSUBDATANVPROC glad_glXNamedCopyBufferSubDataNV = NULL;
PFNGLXQUERYCHANNELDELTASSGIXPROC glad_glXQueryChannelDeltasSGIX = NULL;
PFNGLXQUERYCHANNELRECTSGIXPROC glad_glXQueryChannelRectSGIX = NULL;
PFNGLXQUERYCONTEXTPROC glad_glXQueryContext = NULL;
PFNGLXQUERYCONTEXTINFOEXTPROC glad_glXQueryContextInfoEXT = NULL;
PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC glad_glXQueryCurrentRendererIntegerMESA = NULL;
PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC glad_glXQueryCurrentRendererStringMESA = NULL;
PFNGLXQUERYDRAWABLEPROC glad_glXQueryDrawable = NULL;
PFNGLXQUERYEXTENSIONPROC glad_glXQueryExtension = NULL;
PFNGLXQUERYEXTENSIONSSTRINGPROC glad_glXQueryExtensionsString = NULL;
PFNGLXQUERYFRAMECOUNTNVPROC glad_glXQueryFrameCountNV = NULL;
PFNGLXQUERYGLXPBUFFERSGIXPROC glad_glXQueryGLXPbufferSGIX = NULL;
PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC glad_glXQueryHyperpipeAttribSGIX = NULL;
PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC glad_glXQueryHyperpipeBestAttribSGIX = NULL;
PFNGLXQUERYHYPERPIPECONFIGSGIXPROC glad_glXQueryHyperpipeConfigSGIX = NULL;
PFNGLXQUERYHYPERPIPENETWORKSGIXPROC glad_glXQueryHyperpipeNetworkSGIX = NULL;
PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC glad_glXQueryMaxSwapBarriersSGIX = NULL;
PFNGLXQUERYMAXSWAPGROUPSNVPROC glad_glXQueryMaxSwapGroupsNV = NULL;
PFNGLXQUERYRENDERERINTEGERMESAPROC glad_glXQueryRendererIntegerMESA = NULL;
PFNGLXQUERYRENDERERSTRINGMESAPROC glad_glXQueryRendererStringMESA = NULL;
PFNGLXQUERYSERVERSTRINGPROC glad_glXQueryServerString = NULL;
PFNGLXQUERYSWAPGROUPNVPROC glad_glXQuerySwapGroupNV = NULL;
PFNGLXQUERYVERSIONPROC glad_glXQueryVersion = NULL;
PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC glad_glXQueryVideoCaptureDeviceNV = NULL;
PFNGLXRELEASEBUFFERSMESAPROC glad_glXReleaseBuffersMESA = NULL;
PFNGLXRELEASETEXIMAGEEXTPROC glad_glXReleaseTexImageEXT = NULL;
PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC glad_glXReleaseVideoCaptureDeviceNV = NULL;
PFNGLXRELEASEVIDEODEVICENVPROC glad_glXReleaseVideoDeviceNV = NULL;
PFNGLXRELEASEVIDEOIMAGENVPROC glad_glXReleaseVideoImageNV = NULL;
PFNGLXRESETFRAMECOUNTNVPROC glad_glXResetFrameCountNV = NULL;
PFNGLXSELECTEVENTPROC glad_glXSelectEvent = NULL;
PFNGLXSELECTEVENTSGIXPROC glad_glXSelectEventSGIX = NULL;
PFNGLXSENDPBUFFERTOVIDEONVPROC glad_glXSendPbufferToVideoNV = NULL;
PFNGLXSET3DFXMODEMESAPROC glad_glXSet3DfxModeMESA = NULL;
PFNGLXSWAPBUFFERSPROC glad_glXSwapBuffers = NULL;
PFNGLXSWAPBUFFERSMSCOMLPROC glad_glXSwapBuffersMscOML = NULL;
PFNGLXSWAPINTERVALEXTPROC glad_glXSwapIntervalEXT = NULL;
PFNGLXSWAPINTERVALMESAPROC glad_glXSwapIntervalMESA = NULL;
PFNGLXSWAPINTERVALSGIPROC glad_glXSwapIntervalSGI = NULL;
PFNGLXUSEXFONTPROC glad_glXUseXFont = NULL;
PFNGLXWAITFORMSCOMLPROC glad_glXWaitForMscOML = NULL;
PFNGLXWAITFORSBCOMLPROC glad_glXWaitForSbcOML = NULL;
PFNGLXWAITGLPROC glad_glXWaitGL = NULL;
PFNGLXWAITVIDEOSYNCSGIPROC glad_glXWaitVideoSyncSGI = NULL;
PFNGLXWAITXPROC glad_glXWaitX = NULL;
static void glad_glx_load_GLX_VERSION_1_0( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_VERSION_1_0) return;
glad_glXChooseVisual = (PFNGLXCHOOSEVISUALPROC) load(userptr, "glXChooseVisual");
glad_glXCopyContext = (PFNGLXCOPYCONTEXTPROC) load(userptr, "glXCopyContext");
glad_glXCreateContext = (PFNGLXCREATECONTEXTPROC) load(userptr, "glXCreateContext");
glad_glXCreateGLXPixmap = (PFNGLXCREATEGLXPIXMAPPROC) load(userptr, "glXCreateGLXPixmap");
glad_glXDestroyContext = (PFNGLXDESTROYCONTEXTPROC) load(userptr, "glXDestroyContext");
glad_glXDestroyGLXPixmap = (PFNGLXDESTROYGLXPIXMAPPROC) load(userptr, "glXDestroyGLXPixmap");
glad_glXGetConfig = (PFNGLXGETCONFIGPROC) load(userptr, "glXGetConfig");
glad_glXGetCurrentContext = (PFNGLXGETCURRENTCONTEXTPROC) load(userptr, "glXGetCurrentContext");
glad_glXGetCurrentDrawable = (PFNGLXGETCURRENTDRAWABLEPROC) load(userptr, "glXGetCurrentDrawable");
glad_glXIsDirect = (PFNGLXISDIRECTPROC) load(userptr, "glXIsDirect");
glad_glXMakeCurrent = (PFNGLXMAKECURRENTPROC) load(userptr, "glXMakeCurrent");
glad_glXQueryExtension = (PFNGLXQUERYEXTENSIONPROC) load(userptr, "glXQueryExtension");
glad_glXQueryVersion = (PFNGLXQUERYVERSIONPROC) load(userptr, "glXQueryVersion");
glad_glXSwapBuffers = (PFNGLXSWAPBUFFERSPROC) load(userptr, "glXSwapBuffers");
glad_glXUseXFont = (PFNGLXUSEXFONTPROC) load(userptr, "glXUseXFont");
glad_glXWaitGL = (PFNGLXWAITGLPROC) load(userptr, "glXWaitGL");
glad_glXWaitX = (PFNGLXWAITXPROC) load(userptr, "glXWaitX");
}
static void glad_glx_load_GLX_VERSION_1_1( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_VERSION_1_1) return;
glad_glXGetClientString = (PFNGLXGETCLIENTSTRINGPROC) load(userptr, "glXGetClientString");
glad_glXQueryExtensionsString = (PFNGLXQUERYEXTENSIONSSTRINGPROC) load(userptr, "glXQueryExtensionsString");
glad_glXQueryServerString = (PFNGLXQUERYSERVERSTRINGPROC) load(userptr, "glXQueryServerString");
}
static void glad_glx_load_GLX_VERSION_1_2( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_VERSION_1_2) return;
glad_glXGetCurrentDisplay = (PFNGLXGETCURRENTDISPLAYPROC) load(userptr, "glXGetCurrentDisplay");
}
static void glad_glx_load_GLX_VERSION_1_3( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_VERSION_1_3) return;
glad_glXChooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC) load(userptr, "glXChooseFBConfig");
glad_glXCreateNewContext = (PFNGLXCREATENEWCONTEXTPROC) load(userptr, "glXCreateNewContext");
glad_glXCreatePbuffer = (PFNGLXCREATEPBUFFERPROC) load(userptr, "glXCreatePbuffer");
glad_glXCreatePixmap = (PFNGLXCREATEPIXMAPPROC) load(userptr, "glXCreatePixmap");
glad_glXCreateWindow = (PFNGLXCREATEWINDOWPROC) load(userptr, "glXCreateWindow");
glad_glXDestroyPbuffer = (PFNGLXDESTROYPBUFFERPROC) load(userptr, "glXDestroyPbuffer");
glad_glXDestroyPixmap = (PFNGLXDESTROYPIXMAPPROC) load(userptr, "glXDestroyPixmap");
glad_glXDestroyWindow = (PFNGLXDESTROYWINDOWPROC) load(userptr, "glXDestroyWindow");
glad_glXGetCurrentReadDrawable = (PFNGLXGETCURRENTREADDRAWABLEPROC) load(userptr, "glXGetCurrentReadDrawable");
glad_glXGetFBConfigAttrib = (PFNGLXGETFBCONFIGATTRIBPROC) load(userptr, "glXGetFBConfigAttrib");
glad_glXGetFBConfigs = (PFNGLXGETFBCONFIGSPROC) load(userptr, "glXGetFBConfigs");
glad_glXGetSelectedEvent = (PFNGLXGETSELECTEDEVENTPROC) load(userptr, "glXGetSelectedEvent");
glad_glXGetVisualFromFBConfig = (PFNGLXGETVISUALFROMFBCONFIGPROC) load(userptr, "glXGetVisualFromFBConfig");
glad_glXMakeContextCurrent = (PFNGLXMAKECONTEXTCURRENTPROC) load(userptr, "glXMakeContextCurrent");
glad_glXQueryContext = (PFNGLXQUERYCONTEXTPROC) load(userptr, "glXQueryContext");
glad_glXQueryDrawable = (PFNGLXQUERYDRAWABLEPROC) load(userptr, "glXQueryDrawable");
glad_glXSelectEvent = (PFNGLXSELECTEVENTPROC) load(userptr, "glXSelectEvent");
}
static void glad_glx_load_GLX_VERSION_1_4( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_VERSION_1_4) return;
glad_glXGetProcAddress = (PFNGLXGETPROCADDRESSPROC) load(userptr, "glXGetProcAddress");
}
static void glad_glx_load_GLX_AMD_gpu_association( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_AMD_gpu_association) return;
glad_glXBlitContextFramebufferAMD = (PFNGLXBLITCONTEXTFRAMEBUFFERAMDPROC) load(userptr, "glXBlitContextFramebufferAMD");
glad_glXCreateAssociatedContextAMD = (PFNGLXCREATEASSOCIATEDCONTEXTAMDPROC) load(userptr, "glXCreateAssociatedContextAMD");
glad_glXCreateAssociatedContextAttribsAMD = (PFNGLXCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC) load(userptr, "glXCreateAssociatedContextAttribsAMD");
glad_glXDeleteAssociatedContextAMD = (PFNGLXDELETEASSOCIATEDCONTEXTAMDPROC) load(userptr, "glXDeleteAssociatedContextAMD");
glad_glXGetContextGPUIDAMD = (PFNGLXGETCONTEXTGPUIDAMDPROC) load(userptr, "glXGetContextGPUIDAMD");
glad_glXGetCurrentAssociatedContextAMD = (PFNGLXGETCURRENTASSOCIATEDCONTEXTAMDPROC) load(userptr, "glXGetCurrentAssociatedContextAMD");
glad_glXGetGPUIDsAMD = (PFNGLXGETGPUIDSAMDPROC) load(userptr, "glXGetGPUIDsAMD");
glad_glXGetGPUInfoAMD = (PFNGLXGETGPUINFOAMDPROC) load(userptr, "glXGetGPUInfoAMD");
glad_glXMakeAssociatedContextCurrentAMD = (PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC) load(userptr, "glXMakeAssociatedContextCurrentAMD");
}
static void glad_glx_load_GLX_ARB_create_context( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_ARB_create_context) return;
glad_glXCreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC) load(userptr, "glXCreateContextAttribsARB");
}
static void glad_glx_load_GLX_ARB_get_proc_address( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_ARB_get_proc_address) return;
glad_glXGetProcAddressARB = (PFNGLXGETPROCADDRESSARBPROC) load(userptr, "glXGetProcAddressARB");
}
static void glad_glx_load_GLX_EXT_import_context( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_EXT_import_context) return;
glad_glXFreeContextEXT = (PFNGLXFREECONTEXTEXTPROC) load(userptr, "glXFreeContextEXT");
glad_glXGetContextIDEXT = (PFNGLXGETCONTEXTIDEXTPROC) load(userptr, "glXGetContextIDEXT");
glad_glXGetCurrentDisplayEXT = (PFNGLXGETCURRENTDISPLAYEXTPROC) load(userptr, "glXGetCurrentDisplayEXT");
glad_glXImportContextEXT = (PFNGLXIMPORTCONTEXTEXTPROC) load(userptr, "glXImportContextEXT");
glad_glXQueryContextInfoEXT = (PFNGLXQUERYCONTEXTINFOEXTPROC) load(userptr, "glXQueryContextInfoEXT");
}
static void glad_glx_load_GLX_EXT_swap_control( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_EXT_swap_control) return;
glad_glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC) load(userptr, "glXSwapIntervalEXT");
}
static void glad_glx_load_GLX_EXT_texture_from_pixmap( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_EXT_texture_from_pixmap) return;
glad_glXBindTexImageEXT = (PFNGLXBINDTEXIMAGEEXTPROC) load(userptr, "glXBindTexImageEXT");
glad_glXReleaseTexImageEXT = (PFNGLXRELEASETEXIMAGEEXTPROC) load(userptr, "glXReleaseTexImageEXT");
}
static void glad_glx_load_GLX_MESA_agp_offset( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_MESA_agp_offset) return;
glad_glXGetAGPOffsetMESA = (PFNGLXGETAGPOFFSETMESAPROC) load(userptr, "glXGetAGPOffsetMESA");
}
static void glad_glx_load_GLX_MESA_copy_sub_buffer( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_MESA_copy_sub_buffer) return;
glad_glXCopySubBufferMESA = (PFNGLXCOPYSUBBUFFERMESAPROC) load(userptr, "glXCopySubBufferMESA");
}
static void glad_glx_load_GLX_MESA_pixmap_colormap( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_MESA_pixmap_colormap) return;
glad_glXCreateGLXPixmapMESA = (PFNGLXCREATEGLXPIXMAPMESAPROC) load(userptr, "glXCreateGLXPixmapMESA");
}
static void glad_glx_load_GLX_MESA_query_renderer( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_MESA_query_renderer) return;
glad_glXQueryCurrentRendererIntegerMESA = (PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC) load(userptr, "glXQueryCurrentRendererIntegerMESA");
glad_glXQueryCurrentRendererStringMESA = (PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC) load(userptr, "glXQueryCurrentRendererStringMESA");
glad_glXQueryRendererIntegerMESA = (PFNGLXQUERYRENDERERINTEGERMESAPROC) load(userptr, "glXQueryRendererIntegerMESA");
glad_glXQueryRendererStringMESA = (PFNGLXQUERYRENDERERSTRINGMESAPROC) load(userptr, "glXQueryRendererStringMESA");
}
static void glad_glx_load_GLX_MESA_release_buffers( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_MESA_release_buffers) return;
glad_glXReleaseBuffersMESA = (PFNGLXRELEASEBUFFERSMESAPROC) load(userptr, "glXReleaseBuffersMESA");
}
static void glad_glx_load_GLX_MESA_set_3dfx_mode( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_MESA_set_3dfx_mode) return;
glad_glXSet3DfxModeMESA = (PFNGLXSET3DFXMODEMESAPROC) load(userptr, "glXSet3DfxModeMESA");
}
static void glad_glx_load_GLX_MESA_swap_control( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_MESA_swap_control) return;
glad_glXGetSwapIntervalMESA = (PFNGLXGETSWAPINTERVALMESAPROC) load(userptr, "glXGetSwapIntervalMESA");
glad_glXSwapIntervalMESA = (PFNGLXSWAPINTERVALMESAPROC) load(userptr, "glXSwapIntervalMESA");
}
static void glad_glx_load_GLX_NV_copy_buffer( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_NV_copy_buffer) return;
glad_glXCopyBufferSubDataNV = (PFNGLXCOPYBUFFERSUBDATANVPROC) load(userptr, "glXCopyBufferSubDataNV");
glad_glXNamedCopyBufferSubDataNV = (PFNGLXNAMEDCOPYBUFFERSUBDATANVPROC) load(userptr, "glXNamedCopyBufferSubDataNV");
}
static void glad_glx_load_GLX_NV_copy_image( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_NV_copy_image) return;
glad_glXCopyImageSubDataNV = (PFNGLXCOPYIMAGESUBDATANVPROC) load(userptr, "glXCopyImageSubDataNV");
}
static void glad_glx_load_GLX_NV_delay_before_swap( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_NV_delay_before_swap) return;
glad_glXDelayBeforeSwapNV = (PFNGLXDELAYBEFORESWAPNVPROC) load(userptr, "glXDelayBeforeSwapNV");
}
static void glad_glx_load_GLX_NV_present_video( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_NV_present_video) return;
glad_glXBindVideoDeviceNV = (PFNGLXBINDVIDEODEVICENVPROC) load(userptr, "glXBindVideoDeviceNV");
glad_glXEnumerateVideoDevicesNV = (PFNGLXENUMERATEVIDEODEVICESNVPROC) load(userptr, "glXEnumerateVideoDevicesNV");
}
static void glad_glx_load_GLX_NV_swap_group( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_NV_swap_group) return;
glad_glXBindSwapBarrierNV = (PFNGLXBINDSWAPBARRIERNVPROC) load(userptr, "glXBindSwapBarrierNV");
glad_glXJoinSwapGroupNV = (PFNGLXJOINSWAPGROUPNVPROC) load(userptr, "glXJoinSwapGroupNV");
glad_glXQueryFrameCountNV = (PFNGLXQUERYFRAMECOUNTNVPROC) load(userptr, "glXQueryFrameCountNV");
glad_glXQueryMaxSwapGroupsNV = (PFNGLXQUERYMAXSWAPGROUPSNVPROC) load(userptr, "glXQueryMaxSwapGroupsNV");
glad_glXQuerySwapGroupNV = (PFNGLXQUERYSWAPGROUPNVPROC) load(userptr, "glXQuerySwapGroupNV");
glad_glXResetFrameCountNV = (PFNGLXRESETFRAMECOUNTNVPROC) load(userptr, "glXResetFrameCountNV");
}
static void glad_glx_load_GLX_NV_video_capture( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_NV_video_capture) return;
glad_glXBindVideoCaptureDeviceNV = (PFNGLXBINDVIDEOCAPTUREDEVICENVPROC) load(userptr, "glXBindVideoCaptureDeviceNV");
glad_glXEnumerateVideoCaptureDevicesNV = (PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC) load(userptr, "glXEnumerateVideoCaptureDevicesNV");
glad_glXLockVideoCaptureDeviceNV = (PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC) load(userptr, "glXLockVideoCaptureDeviceNV");
glad_glXQueryVideoCaptureDeviceNV = (PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC) load(userptr, "glXQueryVideoCaptureDeviceNV");
glad_glXReleaseVideoCaptureDeviceNV = (PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC) load(userptr, "glXReleaseVideoCaptureDeviceNV");
}
static void glad_glx_load_GLX_NV_video_out( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_NV_video_out) return;
glad_glXBindVideoImageNV = (PFNGLXBINDVIDEOIMAGENVPROC) load(userptr, "glXBindVideoImageNV");
glad_glXGetVideoDeviceNV = (PFNGLXGETVIDEODEVICENVPROC) load(userptr, "glXGetVideoDeviceNV");
glad_glXGetVideoInfoNV = (PFNGLXGETVIDEOINFONVPROC) load(userptr, "glXGetVideoInfoNV");
glad_glXReleaseVideoDeviceNV = (PFNGLXRELEASEVIDEODEVICENVPROC) load(userptr, "glXReleaseVideoDeviceNV");
glad_glXReleaseVideoImageNV = (PFNGLXRELEASEVIDEOIMAGENVPROC) load(userptr, "glXReleaseVideoImageNV");
glad_glXSendPbufferToVideoNV = (PFNGLXSENDPBUFFERTOVIDEONVPROC) load(userptr, "glXSendPbufferToVideoNV");
}
static void glad_glx_load_GLX_OML_sync_control( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_OML_sync_control) return;
glad_glXGetMscRateOML = (PFNGLXGETMSCRATEOMLPROC) load(userptr, "glXGetMscRateOML");
glad_glXGetSyncValuesOML = (PFNGLXGETSYNCVALUESOMLPROC) load(userptr, "glXGetSyncValuesOML");
glad_glXSwapBuffersMscOML = (PFNGLXSWAPBUFFERSMSCOMLPROC) load(userptr, "glXSwapBuffersMscOML");
glad_glXWaitForMscOML = (PFNGLXWAITFORMSCOMLPROC) load(userptr, "glXWaitForMscOML");
glad_glXWaitForSbcOML = (PFNGLXWAITFORSBCOMLPROC) load(userptr, "glXWaitForSbcOML");
}
static void glad_glx_load_GLX_SGIX_fbconfig( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_SGIX_fbconfig) return;
glad_glXChooseFBConfigSGIX = (PFNGLXCHOOSEFBCONFIGSGIXPROC) load(userptr, "glXChooseFBConfigSGIX");
glad_glXCreateContextWithConfigSGIX = (PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC) load(userptr, "glXCreateContextWithConfigSGIX");
glad_glXCreateGLXPixmapWithConfigSGIX = (PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC) load(userptr, "glXCreateGLXPixmapWithConfigSGIX");
glad_glXGetFBConfigAttribSGIX = (PFNGLXGETFBCONFIGATTRIBSGIXPROC) load(userptr, "glXGetFBConfigAttribSGIX");
glad_glXGetFBConfigFromVisualSGIX = (PFNGLXGETFBCONFIGFROMVISUALSGIXPROC) load(userptr, "glXGetFBConfigFromVisualSGIX");
glad_glXGetVisualFromFBConfigSGIX = (PFNGLXGETVISUALFROMFBCONFIGSGIXPROC) load(userptr, "glXGetVisualFromFBConfigSGIX");
}
static void glad_glx_load_GLX_SGIX_hyperpipe( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_SGIX_hyperpipe) return;
glad_glXBindHyperpipeSGIX = (PFNGLXBINDHYPERPIPESGIXPROC) load(userptr, "glXBindHyperpipeSGIX");
glad_glXDestroyHyperpipeConfigSGIX = (PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC) load(userptr, "glXDestroyHyperpipeConfigSGIX");
glad_glXHyperpipeAttribSGIX = (PFNGLXHYPERPIPEATTRIBSGIXPROC) load(userptr, "glXHyperpipeAttribSGIX");
glad_glXHyperpipeConfigSGIX = (PFNGLXHYPERPIPECONFIGSGIXPROC) load(userptr, "glXHyperpipeConfigSGIX");
glad_glXQueryHyperpipeAttribSGIX = (PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC) load(userptr, "glXQueryHyperpipeAttribSGIX");
glad_glXQueryHyperpipeBestAttribSGIX = (PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC) load(userptr, "glXQueryHyperpipeBestAttribSGIX");
glad_glXQueryHyperpipeConfigSGIX = (PFNGLXQUERYHYPERPIPECONFIGSGIXPROC) load(userptr, "glXQueryHyperpipeConfigSGIX");
glad_glXQueryHyperpipeNetworkSGIX = (PFNGLXQUERYHYPERPIPENETWORKSGIXPROC) load(userptr, "glXQueryHyperpipeNetworkSGIX");
}
static void glad_glx_load_GLX_SGIX_pbuffer( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_SGIX_pbuffer) return;
glad_glXCreateGLXPbufferSGIX = (PFNGLXCREATEGLXPBUFFERSGIXPROC) load(userptr, "glXCreateGLXPbufferSGIX");
glad_glXDestroyGLXPbufferSGIX = (PFNGLXDESTROYGLXPBUFFERSGIXPROC) load(userptr, "glXDestroyGLXPbufferSGIX");
glad_glXGetSelectedEventSGIX = (PFNGLXGETSELECTEDEVENTSGIXPROC) load(userptr, "glXGetSelectedEventSGIX");
glad_glXQueryGLXPbufferSGIX = (PFNGLXQUERYGLXPBUFFERSGIXPROC) load(userptr, "glXQueryGLXPbufferSGIX");
glad_glXSelectEventSGIX = (PFNGLXSELECTEVENTSGIXPROC) load(userptr, "glXSelectEventSGIX");
}
static void glad_glx_load_GLX_SGIX_swap_barrier( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_SGIX_swap_barrier) return;
glad_glXBindSwapBarrierSGIX = (PFNGLXBINDSWAPBARRIERSGIXPROC) load(userptr, "glXBindSwapBarrierSGIX");
glad_glXQueryMaxSwapBarriersSGIX = (PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC) load(userptr, "glXQueryMaxSwapBarriersSGIX");
}
static void glad_glx_load_GLX_SGIX_swap_group( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_SGIX_swap_group) return;
glad_glXJoinSwapGroupSGIX = (PFNGLXJOINSWAPGROUPSGIXPROC) load(userptr, "glXJoinSwapGroupSGIX");
}
static void glad_glx_load_GLX_SGIX_video_resize( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_SGIX_video_resize) return;
glad_glXBindChannelToWindowSGIX = (PFNGLXBINDCHANNELTOWINDOWSGIXPROC) load(userptr, "glXBindChannelToWindowSGIX");
glad_glXChannelRectSGIX = (PFNGLXCHANNELRECTSGIXPROC) load(userptr, "glXChannelRectSGIX");
glad_glXChannelRectSyncSGIX = (PFNGLXCHANNELRECTSYNCSGIXPROC) load(userptr, "glXChannelRectSyncSGIX");
glad_glXQueryChannelDeltasSGIX = (PFNGLXQUERYCHANNELDELTASSGIXPROC) load(userptr, "glXQueryChannelDeltasSGIX");
glad_glXQueryChannelRectSGIX = (PFNGLXQUERYCHANNELRECTSGIXPROC) load(userptr, "glXQueryChannelRectSGIX");
}
static void glad_glx_load_GLX_SGI_cushion( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_SGI_cushion) return;
glad_glXCushionSGI = (PFNGLXCUSHIONSGIPROC) load(userptr, "glXCushionSGI");
}
static void glad_glx_load_GLX_SGI_make_current_read( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_SGI_make_current_read) return;
glad_glXGetCurrentReadDrawableSGI = (PFNGLXGETCURRENTREADDRAWABLESGIPROC) load(userptr, "glXGetCurrentReadDrawableSGI");
glad_glXMakeCurrentReadSGI = (PFNGLXMAKECURRENTREADSGIPROC) load(userptr, "glXMakeCurrentReadSGI");
}
static void glad_glx_load_GLX_SGI_swap_control( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_SGI_swap_control) return;
glad_glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC) load(userptr, "glXSwapIntervalSGI");
}
static void glad_glx_load_GLX_SGI_video_sync( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_SGI_video_sync) return;
glad_glXGetVideoSyncSGI = (PFNGLXGETVIDEOSYNCSGIPROC) load(userptr, "glXGetVideoSyncSGI");
glad_glXWaitVideoSyncSGI = (PFNGLXWAITVIDEOSYNCSGIPROC) load(userptr, "glXWaitVideoSyncSGI");
}
static void glad_glx_load_GLX_SUN_get_transparent_index( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GLX_SUN_get_transparent_index) return;
glad_glXGetTransparentIndexSUN = (PFNGLXGETTRANSPARENTINDEXSUNPROC) load(userptr, "glXGetTransparentIndexSUN");
}
static int glad_glx_has_extension(Display *display, int screen, const char *ext) {
#ifndef GLX_VERSION_1_1
GLAD_UNUSED(display);
GLAD_UNUSED(screen);
GLAD_UNUSED(ext);
#else
const char *terminator;
const char *loc;
const char *extensions;
if (glXQueryExtensionsString == NULL) {
return 0;
}
extensions = glXQueryExtensionsString(display, screen);
if(extensions == NULL || ext == NULL) {
return 0;
}
while(1) {
loc = strstr(extensions, ext);
if(loc == NULL)
break;
terminator = loc + strlen(ext);
if((loc == extensions || *(loc - 1) == ' ') &&
(*terminator == ' ' || *terminator == '\0')) {
return 1;
}
extensions = terminator;
}
#endif
return 0;
}
static GLADapiproc glad_glx_get_proc_from_userptr(void *userptr, const char* name) {
return (GLAD_GNUC_EXTENSION (GLADapiproc (*)(const char *name)) userptr)(name);
}
static int glad_glx_find_extensions(Display *display, int screen) {
GLAD_GLX_3DFX_multisample = glad_glx_has_extension(display, screen, "GLX_3DFX_multisample");
GLAD_GLX_AMD_gpu_association = glad_glx_has_extension(display, screen, "GLX_AMD_gpu_association");
GLAD_GLX_ARB_context_flush_control = glad_glx_has_extension(display, screen, "GLX_ARB_context_flush_control");
GLAD_GLX_ARB_create_context = glad_glx_has_extension(display, screen, "GLX_ARB_create_context");
GLAD_GLX_ARB_create_context_no_error = glad_glx_has_extension(display, screen, "GLX_ARB_create_context_no_error");
GLAD_GLX_ARB_create_context_profile = glad_glx_has_extension(display, screen, "GLX_ARB_create_context_profile");
GLAD_GLX_ARB_create_context_robustness = glad_glx_has_extension(display, screen, "GLX_ARB_create_context_robustness");
GLAD_GLX_ARB_fbconfig_float = glad_glx_has_extension(display, screen, "GLX_ARB_fbconfig_float");
GLAD_GLX_ARB_framebuffer_sRGB = glad_glx_has_extension(display, screen, "GLX_ARB_framebuffer_sRGB");
GLAD_GLX_ARB_get_proc_address = glad_glx_has_extension(display, screen, "GLX_ARB_get_proc_address");
GLAD_GLX_ARB_multisample = glad_glx_has_extension(display, screen, "GLX_ARB_multisample");
GLAD_GLX_ARB_robustness_application_isolation = glad_glx_has_extension(display, screen, "GLX_ARB_robustness_application_isolation");
GLAD_GLX_ARB_robustness_share_group_isolation = glad_glx_has_extension(display, screen, "GLX_ARB_robustness_share_group_isolation");
GLAD_GLX_ARB_vertex_buffer_object = glad_glx_has_extension(display, screen, "GLX_ARB_vertex_buffer_object");
GLAD_GLX_EXT_buffer_age = glad_glx_has_extension(display, screen, "GLX_EXT_buffer_age");
GLAD_GLX_EXT_context_priority = glad_glx_has_extension(display, screen, "GLX_EXT_context_priority");
GLAD_GLX_EXT_create_context_es2_profile = glad_glx_has_extension(display, screen, "GLX_EXT_create_context_es2_profile");
GLAD_GLX_EXT_create_context_es_profile = glad_glx_has_extension(display, screen, "GLX_EXT_create_context_es_profile");
GLAD_GLX_EXT_fbconfig_packed_float = glad_glx_has_extension(display, screen, "GLX_EXT_fbconfig_packed_float");
GLAD_GLX_EXT_framebuffer_sRGB = glad_glx_has_extension(display, screen, "GLX_EXT_framebuffer_sRGB");
GLAD_GLX_EXT_get_drawable_type = glad_glx_has_extension(display, screen, "GLX_EXT_get_drawable_type");
GLAD_GLX_EXT_import_context = glad_glx_has_extension(display, screen, "GLX_EXT_import_context");
GLAD_GLX_EXT_libglvnd = glad_glx_has_extension(display, screen, "GLX_EXT_libglvnd");
GLAD_GLX_EXT_no_config_context = glad_glx_has_extension(display, screen, "GLX_EXT_no_config_context");
GLAD_GLX_EXT_stereo_tree = glad_glx_has_extension(display, screen, "GLX_EXT_stereo_tree");
GLAD_GLX_EXT_swap_control = glad_glx_has_extension(display, screen, "GLX_EXT_swap_control");
GLAD_GLX_EXT_swap_control_tear = glad_glx_has_extension(display, screen, "GLX_EXT_swap_control_tear");
GLAD_GLX_EXT_texture_from_pixmap = glad_glx_has_extension(display, screen, "GLX_EXT_texture_from_pixmap");
GLAD_GLX_EXT_visual_info = glad_glx_has_extension(display, screen, "GLX_EXT_visual_info");
GLAD_GLX_EXT_visual_rating = glad_glx_has_extension(display, screen, "GLX_EXT_visual_rating");
GLAD_GLX_INTEL_swap_event = glad_glx_has_extension(display, screen, "GLX_INTEL_swap_event");
GLAD_GLX_MESA_agp_offset = glad_glx_has_extension(display, screen, "GLX_MESA_agp_offset");
GLAD_GLX_MESA_copy_sub_buffer = glad_glx_has_extension(display, screen, "GLX_MESA_copy_sub_buffer");
GLAD_GLX_MESA_pixmap_colormap = glad_glx_has_extension(display, screen, "GLX_MESA_pixmap_colormap");
GLAD_GLX_MESA_query_renderer = glad_glx_has_extension(display, screen, "GLX_MESA_query_renderer");
GLAD_GLX_MESA_release_buffers = glad_glx_has_extension(display, screen, "GLX_MESA_release_buffers");
GLAD_GLX_MESA_set_3dfx_mode = glad_glx_has_extension(display, screen, "GLX_MESA_set_3dfx_mode");
GLAD_GLX_MESA_swap_control = glad_glx_has_extension(display, screen, "GLX_MESA_swap_control");
GLAD_GLX_NV_copy_buffer = glad_glx_has_extension(display, screen, "GLX_NV_copy_buffer");
GLAD_GLX_NV_copy_image = glad_glx_has_extension(display, screen, "GLX_NV_copy_image");
GLAD_GLX_NV_delay_before_swap = glad_glx_has_extension(display, screen, "GLX_NV_delay_before_swap");
GLAD_GLX_NV_float_buffer = glad_glx_has_extension(display, screen, "GLX_NV_float_buffer");
GLAD_GLX_NV_multigpu_context = glad_glx_has_extension(display, screen, "GLX_NV_multigpu_context");
GLAD_GLX_NV_multisample_coverage = glad_glx_has_extension(display, screen, "GLX_NV_multisample_coverage");
GLAD_GLX_NV_present_video = glad_glx_has_extension(display, screen, "GLX_NV_present_video");
GLAD_GLX_NV_robustness_video_memory_purge = glad_glx_has_extension(display, screen, "GLX_NV_robustness_video_memory_purge");
GLAD_GLX_NV_swap_group = glad_glx_has_extension(display, screen, "GLX_NV_swap_group");
GLAD_GLX_NV_video_capture = glad_glx_has_extension(display, screen, "GLX_NV_video_capture");
GLAD_GLX_NV_video_out = glad_glx_has_extension(display, screen, "GLX_NV_video_out");
GLAD_GLX_OML_swap_method = glad_glx_has_extension(display, screen, "GLX_OML_swap_method");
GLAD_GLX_OML_sync_control = glad_glx_has_extension(display, screen, "GLX_OML_sync_control");
GLAD_GLX_SGIS_blended_overlay = glad_glx_has_extension(display, screen, "GLX_SGIS_blended_overlay");
GLAD_GLX_SGIS_multisample = glad_glx_has_extension(display, screen, "GLX_SGIS_multisample");
GLAD_GLX_SGIS_shared_multisample = glad_glx_has_extension(display, screen, "GLX_SGIS_shared_multisample");
GLAD_GLX_SGIX_fbconfig = glad_glx_has_extension(display, screen, "GLX_SGIX_fbconfig");
GLAD_GLX_SGIX_hyperpipe = glad_glx_has_extension(display, screen, "GLX_SGIX_hyperpipe");
GLAD_GLX_SGIX_pbuffer = glad_glx_has_extension(display, screen, "GLX_SGIX_pbuffer");
GLAD_GLX_SGIX_swap_barrier = glad_glx_has_extension(display, screen, "GLX_SGIX_swap_barrier");
GLAD_GLX_SGIX_swap_group = glad_glx_has_extension(display, screen, "GLX_SGIX_swap_group");
GLAD_GLX_SGIX_video_resize = glad_glx_has_extension(display, screen, "GLX_SGIX_video_resize");
GLAD_GLX_SGIX_visual_select_group = glad_glx_has_extension(display, screen, "GLX_SGIX_visual_select_group");
GLAD_GLX_SGI_cushion = glad_glx_has_extension(display, screen, "GLX_SGI_cushion");
GLAD_GLX_SGI_make_current_read = glad_glx_has_extension(display, screen, "GLX_SGI_make_current_read");
GLAD_GLX_SGI_swap_control = glad_glx_has_extension(display, screen, "GLX_SGI_swap_control");
GLAD_GLX_SGI_video_sync = glad_glx_has_extension(display, screen, "GLX_SGI_video_sync");
GLAD_GLX_SUN_get_transparent_index = glad_glx_has_extension(display, screen, "GLX_SUN_get_transparent_index");
return 1;
}
static int glad_glx_find_core_glx(Display **display, int *screen) {
int major = 0, minor = 0;
if(*display == NULL) {
#ifdef GLAD_GLX_NO_X11
GLAD_UNUSED(screen);
return 0;
#else
*display = XOpenDisplay(0);
if (*display == NULL) {
return 0;
}
*screen = XScreenNumberOfScreen(XDefaultScreenOfDisplay(*display));
#endif
}
glXQueryVersion(*display, &major, &minor);
GLAD_GLX_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1;
GLAD_GLX_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1;
GLAD_GLX_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1;
GLAD_GLX_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1;
GLAD_GLX_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1;
return GLAD_MAKE_VERSION(major, minor);
}
int gladLoadGLXUserPtr(Display *display, int screen, GLADuserptrloadfunc load, void *userptr) {
int version;
glXQueryVersion = (PFNGLXQUERYVERSIONPROC) load(userptr, "glXQueryVersion");
if(glXQueryVersion == NULL) return 0;
version = glad_glx_find_core_glx(&display, &screen);
glad_glx_load_GLX_VERSION_1_0(load, userptr);
glad_glx_load_GLX_VERSION_1_1(load, userptr);
glad_glx_load_GLX_VERSION_1_2(load, userptr);
glad_glx_load_GLX_VERSION_1_3(load, userptr);
glad_glx_load_GLX_VERSION_1_4(load, userptr);
if (!glad_glx_find_extensions(display, screen)) return 0;
glad_glx_load_GLX_AMD_gpu_association(load, userptr);
glad_glx_load_GLX_ARB_create_context(load, userptr);
glad_glx_load_GLX_ARB_get_proc_address(load, userptr);
glad_glx_load_GLX_EXT_import_context(load, userptr);
glad_glx_load_GLX_EXT_swap_control(load, userptr);
glad_glx_load_GLX_EXT_texture_from_pixmap(load, userptr);
glad_glx_load_GLX_MESA_agp_offset(load, userptr);
glad_glx_load_GLX_MESA_copy_sub_buffer(load, userptr);
glad_glx_load_GLX_MESA_pixmap_colormap(load, userptr);
glad_glx_load_GLX_MESA_query_renderer(load, userptr);
glad_glx_load_GLX_MESA_release_buffers(load, userptr);
glad_glx_load_GLX_MESA_set_3dfx_mode(load, userptr);
glad_glx_load_GLX_MESA_swap_control(load, userptr);
glad_glx_load_GLX_NV_copy_buffer(load, userptr);
glad_glx_load_GLX_NV_copy_image(load, userptr);
glad_glx_load_GLX_NV_delay_before_swap(load, userptr);
glad_glx_load_GLX_NV_present_video(load, userptr);
glad_glx_load_GLX_NV_swap_group(load, userptr);
glad_glx_load_GLX_NV_video_capture(load, userptr);
glad_glx_load_GLX_NV_video_out(load, userptr);
glad_glx_load_GLX_OML_sync_control(load, userptr);
glad_glx_load_GLX_SGIX_fbconfig(load, userptr);
glad_glx_load_GLX_SGIX_hyperpipe(load, userptr);
glad_glx_load_GLX_SGIX_pbuffer(load, userptr);
glad_glx_load_GLX_SGIX_swap_barrier(load, userptr);
glad_glx_load_GLX_SGIX_swap_group(load, userptr);
glad_glx_load_GLX_SGIX_video_resize(load, userptr);
glad_glx_load_GLX_SGI_cushion(load, userptr);
glad_glx_load_GLX_SGI_make_current_read(load, userptr);
glad_glx_load_GLX_SGI_swap_control(load, userptr);
glad_glx_load_GLX_SGI_video_sync(load, userptr);
glad_glx_load_GLX_SUN_get_transparent_index(load, userptr);
return version;
}
int gladLoadGLX(Display *display, int screen, GLADloadfunc load) {
return gladLoadGLXUserPtr(display, screen, glad_glx_get_proc_from_userptr, GLAD_GNUC_EXTENSION (void*) load);
}
#ifdef GLAD_GLX
#ifndef GLAD_LOADER_LIBRARY_C_
#define GLAD_LOADER_LIBRARY_C_
#include <stddef.h>
#include <stdlib.h>
#if GLAD_PLATFORM_WIN32
#include <windows.h>
#else
#include <dlfcn.h>
#endif
static void* glad_get_dlopen_handle(const char *lib_names[], int length) {
void *handle = NULL;
int i;
for (i = 0; i < length; ++i) {
#if GLAD_PLATFORM_WIN32
#if GLAD_PLATFORM_UWP
size_t buffer_size = (strlen(lib_names[i]) + 1) * sizeof(WCHAR);
LPWSTR buffer = (LPWSTR) malloc(buffer_size);
if (buffer != NULL) {
int ret = MultiByteToWideChar(CP_ACP, 0, lib_names[i], -1, buffer, buffer_size);
if (ret != 0) {
handle = (void*) LoadPackagedLibrary(buffer, 0);
}
free((void*) buffer);
}
#else
handle = (void*) LoadLibraryA(lib_names[i]);
#endif
#else
handle = dlopen(lib_names[i], RTLD_LAZY | RTLD_LOCAL);
#endif
if (handle != NULL) {
return handle;
}
}
return NULL;
}
static void glad_close_dlopen_handle(void* handle) {
if (handle != NULL) {
#if GLAD_PLATFORM_WIN32
FreeLibrary((HMODULE) handle);
#else
dlclose(handle);
#endif
}
}
static GLADapiproc glad_dlsym_handle(void* handle, const char *name) {
if (handle == NULL) {
return NULL;
}
#if GLAD_PLATFORM_WIN32
return (GLADapiproc) GetProcAddress((HMODULE) handle, name);
#else
return GLAD_GNUC_EXTENSION (GLADapiproc) dlsym(handle, name);
#endif
}
#endif /* GLAD_LOADER_LIBRARY_C_ */
typedef void* (GLAD_API_PTR *GLADglxprocaddrfunc)(const char*);
static GLADapiproc glad_glx_get_proc(void *userptr, const char *name) {
return GLAD_GNUC_EXTENSION ((GLADapiproc (*)(const char *name)) userptr)(name);
}
static void* _glx_handle;
static void* glad_glx_dlopen_handle(void) {
static const char *NAMES[] = {
#if defined __CYGWIN__
"libGL-1.so",
#endif
"libGL.so.1",
"libGL.so"
};
if (_glx_handle == NULL) {
_glx_handle = glad_get_dlopen_handle(NAMES, sizeof(NAMES) / sizeof(NAMES[0]));
}
return _glx_handle;
}
int gladLoaderLoadGLX(Display *display, int screen) {
int version = 0;
void *handle = NULL;
int did_load = 0;
GLADglxprocaddrfunc loader;
did_load = _glx_handle == NULL;
handle = glad_glx_dlopen_handle();
if (handle != NULL) {
loader = (GLADglxprocaddrfunc) glad_dlsym_handle(handle, "glXGetProcAddressARB");
if (loader != NULL) {
version = gladLoadGLXUserPtr(display, screen, glad_glx_get_proc, GLAD_GNUC_EXTENSION (void*) loader);
}
if (!version && did_load) {
gladLoaderUnloadGLX();
}
}
return version;
}
void gladLoaderUnloadGLX() {
if (_glx_handle != NULL) {
glad_close_dlopen_handle(_glx_handle);
_glx_handle = NULL;
}
}
#endif /* GLAD_GLX */
#ifdef __cplusplus
}
#endif
Makefile
+15
View File
@@ -0,0 +1,15 @@
BIN=c2048
CC=gcc
CFLAGS=-Wall -Wextra -Werror -Wfloat-conversion -Wimplicit-fallthrough -pedantic -g `pkg-config --cflags freetype2` -I3rdparty/glad/include -I3rdparty/fmod/include
OBJ=main.o game.o core.o shader.o text.o audio.o timer.o ui.o zephr.o zephr_math.o 3rdparty/glad/src/gl.o 3rdparty/glad/src/glx.o
LDFLAGS=`pkg-config --libs x11 freetype2` -lm -L3rdparty/fmod/lib -Wl,-rpath=3rdparty/fmod/lib -lfmod
DEPS=3rdparty/glad/include/glad/gl.h 3rdparty/glad/include/glad/glx.h 3rdparty/fmod/include/fmod.h
%.o: %.c $(DEPS)
$(CC) -c -o $@ $< $(CFLAGS)
$(BIN): $(OBJ)
$(CC) -o $@ $(OBJ) $(LDFLAGS)
clean:
rm $(OBJ) $(BIN)
README.md
+1 -1
View File
@@ -1,2 +1,2 @@
# C2048
2048 in C from scratch
2048 in C
assets/fonts/Roboto/LICENSE.txt
+202
View File
@@ -0,0 +1,202 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
assets/fonts/Roboto/Roboto-Bold.ttf
BIN
View File
Binary file not shown.
assets/fonts/Rubik/OFL.txt
+93
View File
@@ -0,0 +1,93 @@
Copyright 2015 The Rubik Project Authors (https://github.com/googlefonts/rubik)
This Font Software is licensed under the SIL Open Font License, Version 1.1.
This license is copied below, and is also available with a FAQ at:
http://scripts.sil.org/OFL
-----------------------------------------------------------
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------
PREAMBLE
The goals of the Open Font License (OFL) are to stimulate worldwide
development of collaborative font projects, to support the font creation
efforts of academic and linguistic communities, and to provide a free and
open framework in which fonts may be shared and improved in partnership
with others.
The OFL allows the licensed fonts to be used, studied, modified and
redistributed freely as long as they are not sold by themselves. The
fonts, including any derivative works, can be bundled, embedded,
redistributed and/or sold with any software provided that any reserved
names are not used by derivative works. The fonts and derivatives,
however, cannot be released under any other type of license. The
requirement for fonts to remain under this license does not apply
to any document created using the fonts or their derivatives.
DEFINITIONS
"Font Software" refers to the set of files released by the Copyright
Holder(s) under this license and clearly marked as such. This may
include source files, build scripts and documentation.
"Reserved Font Name" refers to any names specified as such after the
copyright statement(s).
"Original Version" refers to the collection of Font Software components as
distributed by the Copyright Holder(s).
"Modified Version" refers to any derivative made by adding to, deleting,
or substituting -- in part or in whole -- any of the components of the
Original Version, by changing formats or by porting the Font Software to a
new environment.
"Author" refers to any designer, engineer, programmer, technical
writer or other person who contributed to the Font Software.
PERMISSION & CONDITIONS
Permission is hereby granted, free of charge, to any person obtaining
a copy of the Font Software, to use, study, copy, merge, embed, modify,
redistribute, and sell modified and unmodified copies of the Font
Software, subject to the following conditions:
1) Neither the Font Software nor any of its individual components,
in Original or Modified Versions, may be sold by itself.
2) Original or Modified Versions of the Font Software may be bundled,
redistributed and/or sold with any software, provided that each copy
contains the above copyright notice and this license. These can be
included either as stand-alone text files, human-readable headers or
in the appropriate machine-readable metadata fields within text or
binary files as long as those fields can be easily viewed by the user.
3) No Modified Version of the Font Software may use the Reserved Font
Name(s) unless explicit written permission is granted by the corresponding
Copyright Holder. This restriction only applies to the primary font name as
presented to the users.
4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
Software shall not be used to promote, endorse or advertise any
Modified Version, except to acknowledge the contribution(s) of the
Copyright Holder(s) and the Author(s) or with their explicit written
permission.
5) The Font Software, modified or unmodified, in part or in whole,
must be distributed entirely under this license, and must not be
distributed under any other license. The requirement for fonts to
remain under this license does not apply to any document created
using the Font Software.
TERMINATION
This license becomes null and void if any of the above conditions are
not met.
DISCLAIMER
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
OTHER DEALINGS IN THE FONT SOFTWARE.
assets/fonts/Rubik/Rubik-VariableFont_wght.ttf
BIN
View File
Binary file not shown.
audio.c
+53
View File
@@ -0,0 +1,53 @@
#include <stdio.h>
#include <stdbool.h>
#include "3rdparty/fmod/include/fmod.h"
FMOD_SYSTEM *fmod_system;
FMOD_CHANNELGROUP *sfx_channel_group;
/* FMOD_SOUND *scribble_sound; */
int audio_init(void) {
// create fmod_system
FMOD_RESULT fmod_res = FMOD_System_Create(&fmod_system, FMOD_VERSION);
if (fmod_res != FMOD_OK) {
printf("Failed to create FMOD system\n");
return 1;
};
// init FMOD
FMOD_System_Init(fmod_system, 512, FMOD_INIT_NORMAL, NULL);
// create channel group
fmod_res = FMOD_System_CreateChannelGroup(fmod_system, "SFX", &sfx_channel_group);
if (fmod_res != FMOD_OK) {
printf("Failed to create \"SFX\" channel group\n");
return 1;
};
/* fmod_res = FMOD_System_CreateSound(fmod_system, "./assets/audio/scribble.wav", FMOD_DEFAULT, NULL, &scribble_sound); */
/* if (fmod_res != FMOD_OK) { */
/* printf("Failed to create \"click\" sound\n"); */
/* return 1; */
/* }; */
return 0;
}
void audio_update(void) {
FMOD_System_Update(fmod_system);
}
/* void audio_play_scribble(void) { */
/* FMOD_RESULT fmod_res = FMOD_System_PlaySound(fmod_system, scribble_sound, sfx_channel_group, false, NULL); */
/* if (fmod_res != FMOD_OK) { */
/* printf("Failed to play \"scribble\" sound\n"); */
/* }; */
/* } */
void audio_close(void) {
/* FMOD_Sound_Release(win_sound); */
/* FMOD_Sound_Release(scribble_sound); */
FMOD_ChannelGroup_Release(sfx_channel_group);
FMOD_System_Release(fmod_system);
}
audio.h
+7
View File
@@ -0,0 +1,7 @@
#pragma once
int audio_init(void);
void audio_close(void);
void audio_update(void);
void audio_play_scribble(void);
void audio_play_win(void);
core.c
+33
View File
@@ -0,0 +1,33 @@
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include "core.h"
void _core_assert_failed(const char* cond, const char* file, int line, const char* message, ...) {
fprintf(stderr, "assertion failed: %s\nmessage: ", cond);
va_list va_args;
va_start(va_args, message);
vfprintf(stderr, message, va_args);
va_end(va_args);
fprintf(stderr, "\nfile: %s:%u\n", file, line);
/* char* stacktrace = core_get_stacktrace(); */
/* fprintf(stderr, "stacktrace:\n%s\n\n", stacktrace); */
abort();
}
_Noreturn uintptr_t _core_abort(const char* file, int line, const char* message, ...) {
fprintf(stderr, "abort: ");
va_list va_args;
va_start(va_args, message);
vfprintf(stderr, message, va_args);
va_end(va_args);
fprintf(stderr, "\nfile: %s:%u\n", file, line);
/* char* stacktrace = core_get_stacktrace(); */
/* fprintf(stderr, "stacktrace:\n%s\n\n", stacktrace); */
abort();
}
core.h
+126
View File
@@ -0,0 +1,126 @@
#pragma once
#include <stdbool.h>
#include <stdint.h>
#ifdef __GNUC__
#define CORE_LIKELY(expr) __builtin_expect((expr), 1)
#define CORE_UNLIKELY(expr) __builtin_expect((expr), 0)
#else
#define CORE_LIKELY(expr) expr
#define CORE_UNLIKELY(expr) expr
#endif
///////////////////////////
//
//
// Number and Pointer Utilities
//
//
///////////////////////////
#define CORE_MIN(a, b) (((a) < (b)) ? (a) : (b))
#define CORE_MAX(a, b) (((a) > (b)) ? (a) : (b))
#define CORE_CLAMP(v, min, max) (((v) > (max)) ? (max) : ((v) < (min)) ? (min) : (v))
#define CORE_UNUSED(expr) ((void)(expr))
// align must be a power of 2
#define CORE_INT_ROUND_UP_ALIGN(i, align) (((i) + ((align) - )) & ~((align) - 1))
// align must be a power of 2
#define CORE_INT_ROUND_DOWN_ALIGN(i, align) ((i) & ~((align) - 1))
#define CORE_ARRAY_COUNT(array) (sizeof(array) / sizeof(*(array)))
#define CORE_IS_POWER_OF_TWO_OR_ZERO(v) (((v) & ((v) - 1)) == 0)
#define CORE_IS_POWER_OF_TWO(v) (((v) != 0) && (((v) & ((v) - 1)) == 0))
#define CORE_PTR_ADD(ptr, by) (void*)((uintptr_t)(ptr) + (uintptr_t)(by))
#define CORE_PTR_SUB(ptr, by) (void*)((uintptr_t)(ptr) - (uintptr_t)(by))
#define CORE_PTR_DIFF(to, from) ((char*)(to) - (char*)(from))
// aling must be a power of 2
#define CORE_PTR_ROUND_UP_ALIGN(ptr, align) ((void*)CORE_INT_ROUND_UP_ALIGN((uintptr_t)(ptr), (uintptr_t)(align)))
// aling must be a power of 2
#define CORE_PTR_ROUND_DOWN_ALIGN(ptr, align) ((void*)CORE_INT_ROUND_DOWN_ALIGN((uintptr_t)(ptr), (uintptr_t)(align)))
#define CORE_ZERO_ELMT(ptr) memset(ptr, 0, sizeof(*(ptr)))
#define CORE_ONE_ELMT(ptr) memset(ptr, 0xff, sizeof(*(ptr)))
#define CORE_ZERO_ELMT_MANY(ptr, elmts_count) memset(ptr, 0, sizeof(*(ptr)) * (elmts_count))
#define CORE_ONE_ELMT_MANY(ptr, elmts_count) memset(ptr, 0xff, sizeof(*(ptr)) * (elmts_count))
#define CORE_ZERO_ARRAY(array) memset(array, 0, sizeof(array))
#define CORE_ONE_ARRAY(array) memset(array, 0xff, sizeof(array))
#define CORE_COPY_ARRAY(dst, src) memcpy(dst, src, sizeof(dst))
#define CORE_COPY_ELMT_MANY(dst, src, elmts_count) memcpy(dst, src, sizeof(*(dst)) * (elmts_count))
#define CORE_COPY_OVERLAP_ELMT_MANY(dst, src, elmts_count) memmove(dst, src, sizeof(*(dst)) * (elmts_count))
#define CORE_CMP_ARRAY(a, b) (memcmp(a, b, sizeof(a)) == 0)
#define CORE_CMP_ELMT(a, b) (memcmp(a, b, sizeof(*(a))) == 0)
#define CORE_CMP_ELMT_MANY(a, b, elmts_count) (memcmp(a, b, sizeof(*(a)) * elmts_count) == 0)
#define CORE_DIV_ROUND_UP(a, b) (((a) / (b)) + ((a) % (b) != 0))
typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;
typedef int8_t i8;
typedef int16_t i16;
typedef int32_t i32;
typedef int64_t i64;
typedef uint64_t uptr;
typedef int64_t sptr;
typedef float f32;
typedef double f64;
#define U8_MAX UINT8_MAX
#define U16_MAX UINT16_MAX
#define U32_MAX UINT32_MAX
#define U64_MAX UINT64_MAX
#define UPTR_MAX UINT64_MAX
#define I8_MIN INT8_MIN
#define I8_MAX INT8_MAX
#define I16_MIN INT16_MIN
#define I16_MAX INT16_MAX
#define I32_MIN INT32_MIN
#define I32_MAX INT32_MAX
#define I64_MIN INT64_MIN
#define I64_MAX INT64_MAX
///////////////////////////
//
//
// Abort and Assertions
//
//
///////////////////////////
#ifndef CORE_ENABLE_DEBUG_ASSERTIONS
#define CORE_ENABLE_DEBUG_ASSERTIONS 1
#endif
#ifndef CORE_ABORT
#define CORE_ABORT(...) _core_abort(__FILE__, __LINE__, __VA_ARGS__)
#endif
#ifndef CORE_ASSERT
#define CORE_ASSERT(cond, ...) if (CORE_UNLIKELY(!(cond))) _core_assert_failed(#cond, __FILE__, __LINE__, __VA_ARGS__)
#endif
#if CORE_ENABLE_DEBUG_ASSERTIONS
#define CORE_DEBUG_ASSERT CORE_ASSERT
#else
#define CORE_DEBUG_ASSERT(cond, ...) (void)(cond)
#endif
#define CORE_DEBUG_ASSERT_NON_ZERO(value) CORE_DEBUG_ASSERT(value, "'%s' must be a non zero value", #value)
#define CORE_DEBUG_ASSERT_ARRAY_BOUNDS(idx, count) (((idx) < (count)) ? (idx) : CORE_ABORT("idx %d out of bounds for array of size %d", idx, count))
#define CORE_DEBUG_ASSERT_ARRAY_RESIZE(count, cap) CORE_DEBUG_ASSERT((count) <= (cap), "cannot resize array to count '%zu' when it has a capacity of '%zu'", count, cap)
#define CORE_DEBUG_ASSERT_POWER_OF_TWO(v) CORE_DEBUG_ASSERT(CORE_IS_POWER_OF_TWO(v), #v "must be a power of two but got '%zu'", v)
#define CORE_BREAKPOINT() asm ("int $3") // x86 specific breakpoint instruction
void _core_assert_failed(const char* cond, const char* file, int line, const char* message, ...);
_Noreturn uintptr_t _core_abort(const char* file, int line, const char* message, ...);
/* static inline bool core_bitset_is_set(u64* bitset, uptr bit_idx) { */
/* return (bool)(bitset[bit_idx >> 6] & (1 << (bit_idx & 63))); */
/* } */
game.c
+571
View File
@@ -0,0 +1,571 @@
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "game.h"
#include "timer.h"
#include "zephr.h"
#define ANIM_SPEED 3.0f
// TODO: configurable color palette
Game game = {0};
///////////////////////////////////
//
//
// Utils
//
//
///////////////////////////////////
void print_board() {
printf("Board:\n");
for (int i = 0; i < 4; i++) {
printf(" ");
for (int j = 0; j < 4; j++) {
printf("%d ", game.board[i][j].value);
}
printf("\n");
}
}
void print_new_board() {
printf("New Board:\n");
for (int i = 0; i < 4; i++) {
printf(" ");
for (int j = 0; j < 4; j++) {
printf("%d ", game.board[i][j].new_value);
}
printf("\n");
}
}
Color get_color_from_tile(Tile tile) {
switch (tile.value) {
case 2:
return ColorRGBA(238, 228, 218, 255);
case 4:
return ColorRGBA(237, 224, 200, 255);
case 8:
return ColorRGBA(242, 177, 121, 255);
case 16:
return ColorRGBA(245, 149, 99, 255);
case 32:
return ColorRGBA(246, 124, 95, 255);
case 64:
return ColorRGBA(246, 94, 59, 255);
case 128:
return ColorRGBA(237, 207, 114, 255);
case 256:
return ColorRGBA(237, 204, 97, 255);
case 512:
return ColorRGBA(237, 200, 80, 255);
case 1024:
return ColorRGBA(237, 197, 63, 255);
case 2048:
return ColorRGBA(237, 194, 46, 255);
default:
return ColorRGBA(205, 193, 180, 255);
}
}
u8 get_tile_font_size(Tile tile) {
switch (tile.value) {
case 2:
case 4:
case 8:
return 60;
case 16:
case 32:
case 64:
return 55;
case 128:
case 256:
case 512:
return 50;
case 1024:
case 2048:
return 45;
default:
return 35;
}
}
///////////////////////////////////
//
//
// Drawing
//
//
///////////////////////////////////
void draw_board() {
Size window_size = zephr_get_window_size();
UIConstraints board_con = {0};
set_width_constraint(&board_con, window_size.width, UI_CONSTRAINT_FIXED);
set_height_constraint(&board_con, window_size.height, UI_CONSTRAINT_FIXED);
// bg
draw_quad(&board_con, ColorRGBA(248, 250, 230, 255), 0, ALIGN_TOP_LEFT);
// text
UIConstraints text_con = {0};
set_y_constraint(&text_con, 0.05f, UI_CONSTRAINT_RELATIVE);
set_width_constraint(&text_con, 1.5, UI_CONSTRAINT_RELATIVE_PIXELS);
draw_text("2048", 100, text_con, ColorRGBA(34, 234, 82, 155), ALIGN_TOP_CENTER);
// board
set_y_constraint(&board_con, 0.05f, UI_CONSTRAINT_RELATIVE);
set_height_constraint(&board_con, 0.6f, UI_CONSTRAINT_RELATIVE);
set_width_constraint(&board_con, 1, UI_CONSTRAINT_ASPECT_RATIO);
draw_quad(&board_con, ColorRGBA(140, 154, 147, 255), 8, ALIGN_CENTER);
// tiles
const float tile_padding = board_con.width * 0.02f;
const float tile_height = board_con.height * 0.225f;
UIConstraints empty_tile_con = {0};
set_parent_constraint(&empty_tile_con, &board_con);
set_height_constraint(&empty_tile_con, tile_height, UI_CONSTRAINT_FIXED);
set_width_constraint(&empty_tile_con, 1, UI_CONSTRAINT_ASPECT_RATIO);
for (int i = 0; i < 4; i++) {
set_y_constraint(&empty_tile_con, (tile_height + tile_padding) * i + tile_padding, UI_CONSTRAINT_FIXED);
for (int j = 0; j < 4; j++) {
set_x_constraint(&empty_tile_con, (tile_height + tile_padding) * j + tile_padding, UI_CONSTRAINT_FIXED);
draw_quad(&empty_tile_con, ColorRGBA(120, 133, 126, 255), 16, ALIGN_TOP_LEFT);
}
}
UIConstraints tile_con = {0};
set_parent_constraint(&tile_con, &board_con);
set_height_constraint(&tile_con, tile_height, UI_CONSTRAINT_FIXED);
set_width_constraint(&tile_con, 1, UI_CONSTRAINT_ASPECT_RATIO);
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
Tile *tile = &game.board[i][j];
Color tile_color = get_color_from_tile(*tile);
char value[16];
sprintf(value, "%d", tile->value);
set_y_constraint(&tile_con, (f32)((tile_height + tile_padding) * i + tile_padding + game.board[i][j].anim_y_offset_relative * board_con.height), UI_CONSTRAINT_FIXED);
set_x_constraint(&tile_con, (f32)((tile_height + tile_padding) * j + tile_padding + game.board[i][j].anim_x_offset_relative * board_con.height), UI_CONSTRAINT_FIXED);
if (tile->value > 0) {
draw_quad(&tile_con, tile_color, 16, ALIGN_TOP_LEFT);
// value text
set_parent_constraint(&text_con, &tile_con);
set_x_constraint(&text_con, 0, UI_CONSTRAINT_FIXED);
set_y_constraint(&text_con, 0, UI_CONSTRAINT_FIXED);
draw_text(value, get_tile_font_size(*tile), text_con, mul_color(tile_color, 0.5), ALIGN_CENTER);
}
}
}
}
///////////////////////////////////
//
//
// Game logic
//
//
///////////////////////////////////
// TODO: merging tiles still needs to be done, along with its animation
void move_right() {
if (game.animating) return;
game.last_move_dir = MOVE_DIR_RIGHT;
for (int i = 0; i < 4; i++) {
for (int j = 2; j >= 0; j--) {
if (game.board[i][j].value == 0) {
continue;
}
u8 tiles_to_move = 0;
u8 x = j;
printf("tile: %d,%d\n", i, j);
do {
x++;
// next tile is empty so we can move there
if (game.board[i][x].new_value == 0) {
printf("can move. empty\n");
tiles_to_move++;
continue;
}
// next tile has the same value so we can merge and move
if (game.board[i][x].new_value == game.board[i][j].new_value) {
printf("can move. merge\n");
tiles_to_move++;
break;
} else {
// next tile has a different value so we can't move there
x--;
break;
}
} while (x < 3);
printf("tiles to move: %d\n", tiles_to_move);
game.board[i][j].tiles_to_move = tiles_to_move;
if (tiles_to_move > 0) {
game.board[i][x].new_value = game.board[i][j].value;
game.board[i][j].new_value = 0;
game.animating = true;
}
}
}
}
void move_left() {
if (game.animating) return;
game.last_move_dir = MOVE_DIR_LEFT;
for (int i = 0; i < 4; i++) {
for (int j = 1; j < 4; j++) {
if (game.board[i][j].value == 0) {
continue;
}
u8 tiles_to_move = 0;
u8 x = j;
do {
x--;
// next tile is empty so we can move there
if (game.board[i][x].new_value == 0) {
tiles_to_move++;
continue;
}
// next tile has the same value so we can merge and move
if (game.board[i][x].new_value == game.board[i][j].new_value) {
tiles_to_move++;
break;
} else {
// next tile has a different value so we can't move there
x++;
break;
}
} while (x > 0);
game.board[i][j].tiles_to_move = tiles_to_move;
if (tiles_to_move > 0) {
game.board[i][x].new_value = game.board[i][j].value;
game.board[i][j].new_value = 0;
game.animating = true;
}
}
}
}
void move_down() {
if (game.animating) return;
game.last_move_dir = MOVE_DIR_DOWN;
for (int i = 2; i >= 0; i--) {
for (int j = 0; j < 4; j++) {
if (game.board[i][j].value == 0) {
continue;
}
u8 tiles_to_move = 0;
u8 y = i;
do {
y++;
if (game.board[y][j].new_value == 0) {
tiles_to_move++;
continue;
}
if (game.board[y][j].new_value == game.board[i][j].new_value) {
tiles_to_move++;
break;
} else {
y--;
break;
}
} while (y < 3);
game.board[i][j].tiles_to_move = tiles_to_move;
if (tiles_to_move > 0) {
game.board[y][j].new_value = game.board[i][j].value;
game.board[i][j].new_value = 0;
game.animating = true;
}
}
}
}
void move_up() {
if (game.animating) return;
game.last_move_dir = MOVE_DIR_UP;
for (int i = 1; i < 4; i++) {
for (int j = 0; j < 4; j++) {
if (game.board[i][j].value == 0) {
continue;
}
u8 tiles_to_move = 0;
u8 y = i;
do {
y--;
if (game.board[y][j].new_value == 0) {
tiles_to_move++;
continue;
}
if (game.board[y][j].new_value == game.board[i][j].new_value) {
tiles_to_move++;
break;
} else {
y++;
break;
}
} while (y > 0);
game.board[i][j].tiles_to_move = tiles_to_move;
if (tiles_to_move > 0) {
game.board[y][j].new_value = game.board[i][j].value;
game.board[i][j].new_value = 0;
game.animating = true;
}
}
}
}
void update_positions(f64 delta_t) {
if (game.animating) {
switch (game.last_move_dir) {
case MOVE_DIR_LEFT:
for (int i = 0; i < 4; i++) {
for (int j = 1; j < 4; j++) {
u8 tiles_to_move = game.board[i][j].tiles_to_move;
f32 speed = ANIM_SPEED * tiles_to_move;
if (game.board[i][j].tiles_to_move != 0) {
game.board[i][j].anim_x_offset_relative -= speed * delta_t;
if (game.board[i][j].anim_x_offset_relative <= -0.240f * (tiles_to_move + (tiles_to_move * 0.02f))) {
game.board[i][j].anim_x_offset_relative = -0.240f * (tiles_to_move + (tiles_to_move * 0.02f));
game.board[i][j - tiles_to_move].value = game.board[i][j].value;
game.board[i][j - tiles_to_move].new_value = game.board[i][j].value;
game.board[i][j].value = 0;
game.board[i][j].new_value = 0;
game.board[i][j].tiles_to_move = 0;
game.board[i][j].anim_x_offset_relative = 0;
game.animating = false;
}
}
}
}
break;
case MOVE_DIR_RIGHT:
for (int i = 0; i < 4; i++) {
for (int j = 2; j >= 0; j--) {
u8 tiles_to_move = game.board[i][j].tiles_to_move;
f32 speed = ANIM_SPEED * tiles_to_move;
if (game.board[i][j].tiles_to_move != 0) {
game.board[i][j].anim_x_offset_relative += speed * delta_t;
if (game.board[i][j].anim_x_offset_relative >= 0.240f * (tiles_to_move + (tiles_to_move * 0.02f))) {
game.board[i][j].anim_x_offset_relative = 0.240f * (tiles_to_move + (tiles_to_move * 0.02f));
game.board[i][j + tiles_to_move].value = game.board[i][j].value;
game.board[i][j + tiles_to_move].new_value = game.board[i][j].value;
game.board[i][j].value = 0;
game.board[i][j].new_value = 0;
game.board[i][j].tiles_to_move = 0;
game.board[i][j].anim_x_offset_relative = 0;
game.animating = false;
}
}
}
}
break;
case MOVE_DIR_UP:
for (int i = 1; i < 4; i++) {
for (int j = 0; j < 4; j++) {
u8 tiles_to_move = game.board[i][j].tiles_to_move;
f32 speed = ANIM_SPEED * tiles_to_move;
if (game.board[i][j].tiles_to_move != 0) {
game.board[i][j].anim_y_offset_relative -= speed * delta_t;
if (game.board[i][j].anim_y_offset_relative <= -0.240f * (tiles_to_move + (tiles_to_move * 0.02f))) {
game.board[i][j].anim_y_offset_relative = -0.240f * (tiles_to_move + (tiles_to_move * 0.02f));
game.board[i - tiles_to_move][j].value = game.board[i][j].value;
game.board[i - tiles_to_move][j].new_value = game.board[i][j].value;
game.board[i][j].value = 0;
game.board[i][j].new_value = 0;
game.board[i][j].tiles_to_move = 0;
game.board[i][j].anim_y_offset_relative = 0;
game.animating = false;
}
}
}
}
break;
case MOVE_DIR_DOWN:
for (int i = 2; i >= 0; i--) {
for (int j = 0; j < 4; j++) {
u8 tiles_to_move = game.board[i][j].tiles_to_move;
f32 speed = ANIM_SPEED * tiles_to_move;
if (game.board[i][j].tiles_to_move != 0) {
game.board[i][j].anim_y_offset_relative += speed * delta_t;
if (game.board[i][j].anim_y_offset_relative >= 0.240f * (tiles_to_move + (tiles_to_move * 0.02f))) {
game.board[i][j].anim_y_offset_relative = 0.240f * (tiles_to_move + (tiles_to_move * 0.02f));
game.board[i + tiles_to_move][j].value = game.board[i][j].value;
game.board[i + tiles_to_move][j].new_value = game.board[i][j].value;
game.board[i][j].value = 0;
game.board[i][j].new_value = 0;
game.board[i][j].tiles_to_move = 0;
game.board[i][j].anim_y_offset_relative = 0;
game.animating = false;
}
}
}
}
break;
}
}
}
void spawn_new_tile(u8 x, u8 y) {
if (rand() % 10 < 9) {
game.board[x][y].value = 2;
game.board[x][y].new_value = 2;
} else {
game.board[x][y].value = 4;
game.board[x][y].new_value = 4;
}
}
void spawn_random_tile() {
u8 available_tiles_count = 0;
u8 available_tiles[16];
for (int i = 0; i < 4; i++) {
for (int j = 0; j <= 3; j++) {
if (game.board[i][j].value == 0) {
available_tiles[available_tiles_count] = i * 4 + j;
available_tiles_count++;
}
}
}
u8 rand_idx = rand() % available_tiles_count;
u8 x = available_tiles[rand_idx] / 4;
u8 y = available_tiles[rand_idx] % 4;
spawn_new_tile(x, y);
}
void game_init(void) {
srand(time(NULL));
// TODO: this shouldn't merge all of them and instead should
// merge every 2 together
/* game.board[0][0].value = 2; */
/* game.board[0][1].value = 2; */
/* game.board[0][2].value = 2; */
/* game.board[0][3].value = 2; */
/* game.board[0][0].new_value = 2; */
/* game.board[0][1].new_value = 2; */
/* game.board[0][2].new_value = 2; */
/* game.board[0][3].new_value = 2; */
for (int i = 0; i < 2; i++) {
spawn_random_tile();
}
}
///////////////////////////////////
//
//
// Loop and input handling
//
//
///////////////////////////////////
void handle_keyboard_input(ZephrEvent e) {
if (
(e.key.mods & ZEPHR_KEY_MOD_CTRL && e.key.code == ZEPHR_KEYCODE_Q) ||
e.key.code == ZEPHR_KEYCODE_ESCAPE
) {
// TODO: show confirmation dialog
zephr_quit();
} else if (e.key.code == ZEPHR_KEYCODE_F11) {
zephr_toggle_fullscreen();
} else if (e.key.code == ZEPHR_KEYCODE_UP) {
move_up();
/* spawn_random_tile(); */
} else if (e.key.code == ZEPHR_KEYCODE_DOWN) {
move_down();
/* spawn_random_tile(); */
} else if (e.key.code == ZEPHR_KEYCODE_LEFT) {
move_left();
/* spawn_random_tile(); */
} else if (e.key.code == ZEPHR_KEYCODE_RIGHT) {
move_right();
/* spawn_random_tile(); */
}
}
void game_loop(void) {
game_init();
f64 last_frame = 0.0;
while (!zephr_should_quit()) {
ZephrEvent e;
while (zephr_iter_events(&e)) {
switch (e.type) {
case ZEPHR_EVENT_WINDOW_CLOSED:
zephr_quit();
break;
case ZEPHR_EVENT_KEY_PRESSED:
handle_keyboard_input(e);
break;
default:
break;
}
}
f64 now = get_time();
f64 delta_t = now - last_frame;
last_frame = now;
update_positions(delta_t);
draw_board();
zephr_swap_buffers();
}
}
game.h
+29
View File
@@ -0,0 +1,29 @@
#pragma once
#include "core.h"
#include "ui.h"
typedef enum MoveDir {
MOVE_DIR_UP,
MOVE_DIR_DOWN,
MOVE_DIR_LEFT,
MOVE_DIR_RIGHT,
} MoveDir;
typedef struct Tile {
u16 value;
u16 new_value;
f64 anim_x_offset_relative;
f64 anim_y_offset_relative;
u8 tiles_to_move;
} Tile;
typedef struct Game {
Tile board[4][4];
MoveDir last_move_dir;
bool animating;
} Game;
void draw_board(void);
void game_loop(void);
main.c
+20 -5
View File
@@ -1,8 +1,23 @@
#include <stdio.h>
#include "game.h"
#include "zephr.h"
const char *font_path = "assets/fonts/Rubik/Rubik-VariableFont_wght.ttf";
/* const char *font_path = "assets/fonts/Roboto/Roboto-Bold.ttf"; */
const char *title = "C2048";
int main(int argc, char *argv[]) {
// From scratch
// X11 for windowing
// OpenGL for rendering
// OpenAL for audio (maybe)
// Windows support when everything is fine on linux using winapi
CORE_UNUSED(argc);
CORE_UNUSED(argv);
zephr_init(font_path, title, (Size){1200, 800});
zephr_make_window_non_resizable();
/* zephr_toggle_fullscreen(); */
game_loop();
zephr_deinit();
return 0;
}
shader.c
+106
View File
@@ -0,0 +1,106 @@
#include <stdio.h>
#include <stdlib.h>
#include <glad/gl.h>
#include "core.h"
#include "shader.h"
void read_shader_file(const char *path, char **buf) {
FILE *fp = fopen(path, "rb");
if (!fp) {
printf("Could not open file \"%s\"\n", path);
exit(1);
}
fseek(fp, 0, SEEK_END);
u64 filesize = ftell(fp);
fseek(fp, 0, SEEK_SET);
*buf = malloc(filesize + 1);
(*buf)[filesize] = '\0';
u64 read = fread(*buf, filesize, 1, fp);
CORE_UNUSED(read);
fclose(fp);
}
Shader create_shader(const char *vertex_path, const char *fragment_path) {
Shader shader;
char *v_shader_source = NULL;
char *f_shader_source = NULL;
read_shader_file(vertex_path, &v_shader_source);
read_shader_file(fragment_path, &f_shader_source);
int v_shader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(v_shader, 1, (const char **)&v_shader_source, NULL);
glCompileShader(v_shader);
int success0 = 0;
glGetShaderiv(v_shader, GL_COMPILE_STATUS, &success0);
printf("vertex shader %s compiled with status: %d\n", vertex_path, success0);
if (!success0) {
char info_buf[512];
glGetShaderInfoLog(v_shader, 512, NULL, info_buf);
printf("vertex shader info: %s\n", info_buf);
}
int f_shader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(f_shader, 1, (const char **)&f_shader_source, NULL);
glCompileShader(f_shader);
int success1 = 0;
glGetShaderiv(f_shader, GL_COMPILE_STATUS, &success1);
printf("frag shader %s compiled with status: %d\n", fragment_path, success1);
if (!success1) {
char info_buf[512];
glGetShaderInfoLog(f_shader, 512, NULL, info_buf);
printf("frag shader info: %s\n", info_buf);
}
int program = glCreateProgram();
glAttachShader(program, v_shader);
glAttachShader(program, f_shader);
glLinkProgram(program);
glDeleteShader(v_shader);
glDeleteShader(f_shader);
free(v_shader_source);
free(f_shader_source);
shader.program = program;
return shader;
}
void use_shader(Shader shader) {
glUseProgram(shader.program);
}
void set_mat4f(Shader shader, const char *name, float *mat4) {
int loc = glGetUniformLocation(shader.program, name);
glUniformMatrix4fv(loc, 1, GL_FALSE, mat4);
}
void set_float(Shader shader, const char *name, float val) {
int loc = glGetUniformLocation(shader.program, name);
glUniform1f(loc, val);
}
void set_vec2f(Shader shader, const char *name, float val1, float val2) {
int loc = glGetUniformLocation(shader.program, name);
glUniform2f(loc, val1, val2);
}
void set_vec3f(Shader shader, const char *name, float val1, float val2, float val3) {
int loc = glGetUniformLocation(shader.program, name);
glUniform3f(loc, val1, val2, val3);
}
void set_vec4f(Shader shader, const char *name, float val1, float val2, float val3, float val4) {
int loc = glGetUniformLocation(shader.program, name);
glUniform4f(loc, val1, val2, val3, val4);
}
shader.h
+14
View File
@@ -0,0 +1,14 @@
#pragma once
typedef struct Shader {
int program;
} Shader;
void read_shader_file(const char *path, char **buf);
Shader create_shader(const char *vertex_path, const char *fragment_path);
void use_shader(Shader shader);
void set_mat4f(Shader shader, const char *name, float *mat);
void set_float(Shader shader, const char *name, float val);
void set_vec2f(Shader shader, const char *name, float val1, float val2);
void set_vec3f(Shader shader, const char *name, float val1, float val2, float val3);
void set_vec4f(Shader shader, const char *name, float val1, float val2, float val3, float val4);
shaders/font.frag
+21
View File
@@ -0,0 +1,21 @@
#version 330 core
in vec2 v_TexCoords;
in vec4 textColor;
out vec4 FragColor;
uniform sampler2D text;
const float smoothness = 0.05;
const float outlineDistance = 0.50;
const vec4 outlineColor = vec4(0.0, 0.0, 0.0, 1.0);
void main() {
//float distance = texture(text, v_TexCoords).r;
//float outlineFactor = smoothstep(0.5 - smoothness, 0.5 + smoothness, distance);
//vec4 color = mix(outlineColor, textColor, outlineFactor);
//float alpha = smoothstep(outlineDistance - smoothness, outlineDistance + smoothness, distance);
vec4 sampled = vec4(1.0, 1.0, 1.0, texture(text, v_TexCoords).r);
FragColor = textColor * sampled;
//FragColor = vec4(color.rgb, textColor.a * alpha);
}
shaders/font.vert
+21
View File
@@ -0,0 +1,21 @@
#version 330 core
layout (location = 0) in vec2 vertex;
// per instance
layout (location = 1) in vec4 offset;
layout (location = 2) in int tex_index;
layout (location = 3) in vec4 color;
layout (location = 4) in mat4 model; // this takes locations 4,5,6,7
out vec2 v_TexCoords;
out vec4 textColor;
uniform mat4 projection;
// buffer for all the 96 ascii characters' texcoords
uniform vec2 texcoords[96 * 4];
void main() {
vec2 pos = vec2((vertex.x) * offset.z, (vertex.y) * offset.w);
gl_Position = projection * model * vec4(pos + offset.xy, 0.0, 1.0);
v_TexCoords = texcoords[tex_index * 4 + gl_VertexID];
textColor = color;
}
shaders/ui.frag
+33
View File
@@ -0,0 +1,33 @@
#version 330 core
in vec2 v_TexCoords;
out vec4 FragColor;
uniform vec4 aColor;
uniform float borderRadius;
uniform float uiWidth;
uniform float uiHeight;
const float smoothness = 1.0;
void main() {
float alpha = aColor.a;
if (borderRadius > 0.0) {
vec2 dimensions = v_TexCoords * vec2(uiWidth, uiHeight);
float xMax = uiWidth - borderRadius;
float yMax = uiHeight - borderRadius;
if (dimensions.x < borderRadius && dimensions.y < borderRadius) {
alpha *= 1.0 - smoothstep(borderRadius - smoothness, borderRadius + smoothness, length(dimensions - vec2(borderRadius)));
} else if (dimensions.x < borderRadius && dimensions.y > yMax) {
alpha *= 1.0 - smoothstep(borderRadius - smoothness, borderRadius + smoothness, length(dimensions - vec2(borderRadius, yMax)));
} else if (dimensions.x > xMax && dimensions.y < borderRadius) {
alpha *= 1.0 - smoothstep(borderRadius - smoothness, borderRadius + smoothness, length(dimensions - vec2(xMax, borderRadius)));
} else if (dimensions.x > xMax && dimensions.y > yMax) {
alpha *= 1.0 - smoothstep(borderRadius - smoothness, borderRadius + smoothness, length(dimensions - vec2(xMax, yMax)));
}
}
FragColor = vec4(aColor.rgb, alpha);
}
shaders/ui.vert
+11
View File
@@ -0,0 +1,11 @@
#version 330 core
layout (location = 0) in vec4 vertex;
out vec2 v_TexCoords;
uniform mat4 projection;
uniform mat4 model;
void main() {
gl_Position = projection * model * vec4(vertex.xy, 0.0, 1.0);
v_TexCoords = vertex.zw;
}
text.c
+405
View File
@@ -0,0 +1,405 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ft2build.h>
#include FT_FREETYPE_H
#include <glad/glx.h>
#include "shader.h"
#include "text.h"
#include "zephr.h"
#define FONT_PIXEL_SIZE 128
Shader font_shader;
unsigned int font_vao;
unsigned int font_instance_vbo;
void extend_glyph_instance_list(GlyphInstanceList *dest, GlyphInstanceList *src) {
if (dest->size + src->size >= dest->capacity) {
dest->capacity = dest->size + src->size;
GlyphInstance* temp = realloc(dest->data, dest->capacity * sizeof(GlyphInstance));
if (!temp) {
printf("[FATAL] Failed to reallocate memory for glyph instance list\n");
exit(1);
}
dest->data = temp;
}
memcpy(dest->data + dest->size, src->data, src->size * sizeof(GlyphInstance));
dest->size += src->size;
}
void new_glyph_instance_list(GlyphInstanceList *list, u32 capacity) {
list->size = 0;
list->capacity = capacity;
list->data = malloc(list->capacity * sizeof(GlyphInstance));
}
void clear_glyph_instance_list(GlyphInstanceList *list) {
list->size = 0;
memset(list->data, 0, list->size * sizeof(GlyphInstance));
}
void add_glyph_instance(GlyphInstanceList *list, GlyphInstance instance) {
if (list->size >= list->capacity) {
list->capacity *= 2;
GlyphInstance* temp = realloc(list->data, list->capacity * sizeof(GlyphInstance));
if (!temp) {
printf("[FATAL] Failed to reallocate memory for glyph instance list\n");
exit(1);
}
list->data = temp;
}
list->data[list->size++] = instance;
}
int init_freetype(const char* font_path) {
FT_Library ft;
if (FT_Init_FreeType(&ft)) {
return -1;
}
FT_Face face;
if (FT_New_Face(ft, font_path, 0, &face)) {
return -2;
}
// sets the variable font to be bold
/* if ((face->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS)) { */
/* printf("[INFO] Got a variable font\n"); */
/* FT_MM_Var *mm; */
/* FT_Get_MM_Var(face, &mm); */
/* FT_Set_Var_Design_Coordinates(face, mm->num_namedstyles, mm->namedstyle[mm->num_namedstyles - 4].coords); */
/* FT_Done_MM_Var(ft, mm); */
/* } */
FT_Set_Pixel_Sizes(face, 0, FONT_PIXEL_SIZE);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
int pen_x = 0, pen_y = 0;
/* FT_UInt glyph_idx; */
/* FT_ULong c = FT_Get_First_Char(face, &glyph_idx); */
u32 tex_width = 0, tex_height = 0;
for (u32 i = 32; i < 128; i++) {
if (FT_Load_Char(face, i, FT_LOAD_RENDER)) {
printf("[ERROR]: failed to load glyph for char '0x%x'\n", i);
}
/* FT_Render_Glyph(face->glyph, FT_RENDER_MODE_SDF); */
tex_width += face->glyph->bitmap.width + 1;
tex_height = CORE_MAX(tex_height, face->glyph->bitmap.rows);
}
char *pixels = (char *)calloc(tex_width * tex_height, 1);
for (u32 i = 32; i < 128; i++) {
/* while (glyph_idx) { */
if (FT_Load_Char(face, i, FT_LOAD_RENDER)) {
printf("[ERROR]: failed to load glyph for char '0x%x'\n", i);
}
/* FT_Render_Glyph(face->glyph, FT_RENDER_MODE_SDF); */
FT_Bitmap *bmp = &face->glyph->bitmap;
if (pen_x + bmp->width >= tex_width) {
pen_x = 0;
pen_y += (1 + (face->size->metrics.height >> 6));
}
for (u32 row = 0; row < bmp->rows; row++) {
for (u32 col = 0; col < bmp->width; col++) {
int x = pen_x + col;
int y = pen_y + row;
pixels[y * tex_width + x] = bmp->buffer[row * bmp->pitch + col];
}
}
float atlas_x0 = (float)pen_x / (float)tex_width;
float atlas_y0 = (float)pen_y / (float)tex_height;
float atlas_x1 = (float)(pen_x + bmp->width) / (float)tex_width;
float atlas_y1 = (float)(pen_y + bmp->rows) / (float)tex_height;
Vec2f top_left = (Vec2f){ .x = atlas_x0, .y = atlas_y1 };
Vec2f top_right = (Vec2f){ .x = atlas_x1, .y = atlas_y1 };
Vec2f bottom_right = (Vec2f){ .x = atlas_x1, .y = atlas_y0 };
Vec2f bottom_left = (Vec2f){ .x = atlas_x0, .y = atlas_y0 };
Character character;
character.tex_coords[0] = top_left;
character.tex_coords[1] = top_right;
character.tex_coords[2] = bottom_right;
character.tex_coords[3] = bottom_left;
character.advance = face->glyph->advance.x;
character.size = (Size){ .width = face->glyph->bitmap.width, .height = face->glyph->bitmap.rows };
character.bearing = (Size){ .width = face->glyph->bitmap_left, .height = face->glyph->bitmap_top };
zephr_ctx->font.characters[i] = character;
pen_x += bmp->width + 1;
/* c = FT_Get_Next_Char(face, c, &glyph_idx); */
}
unsigned int texture;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, tex_width,
tex_height, 0, GL_RED, GL_UNSIGNED_BYTE,
pixels);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
zephr_ctx->font.atlas_texture_id = texture;
glBindTexture(GL_TEXTURE_2D, 0);
FT_Done_Face(face);
FT_Done_FreeType(ft);
free(pixels);
return 0;
}
int init_fonts(const char *font_path) {
u32 font_vbo;
u32 font_ebo;
int res = init_freetype(font_path);
if (res != 0) {
return res;
}
font_shader = create_shader("shaders/font.vert", "shaders/font.frag");
glGenVertexArrays(1, &font_vao);
glGenBuffers(1, &font_vbo);
glGenBuffers(1, &font_instance_vbo);
glGenBuffers(1, &font_ebo);
float quad_vertices[4][2] = {
{0.0, 1.0}, // top left
{1.0, 1.0}, // top right
{1.0, 0.0}, // bottom right
{0.0, 0.0}, // bottom left
};
int quad_indices[6] = {
0, 1, 2,
2, 3, 0
};
glBindVertexArray(font_vao);
// font quad vbo
glBindBuffer(GL_ARRAY_BUFFER, font_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(quad_vertices), quad_vertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void *)0);
// font instance vbo
glBindBuffer(GL_ARRAY_BUFFER, font_instance_vbo);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(GlyphInstance), (void *)0);
glVertexAttribDivisor(1, 1);
glEnableVertexAttribArray(2);
glVertexAttribIPointer(2, 1, GL_INT, sizeof(GlyphInstance), (void *)sizeof(Vec4f));
glVertexAttribDivisor(2, 1);
glEnableVertexAttribArray(3);
glVertexAttribPointer(3, 4, GL_FLOAT, GL_FALSE, sizeof(GlyphInstance), (void *)(sizeof(Vec4f) + sizeof(int)));
glVertexAttribDivisor(3, 1);
glEnableVertexAttribArray(4);
glEnableVertexAttribArray(5);
glEnableVertexAttribArray(6);
glEnableVertexAttribArray(7);
glVertexAttribPointer(4, 4, GL_FLOAT, GL_FALSE, sizeof(GlyphInstance), (void *)(sizeof(Vec4f) * 2 + sizeof(int)));
glVertexAttribPointer(5, 4, GL_FLOAT, GL_FALSE, sizeof(GlyphInstance), (void *)(sizeof(Vec4f) * 3 + sizeof(int)));
glVertexAttribPointer(6, 4, GL_FLOAT, GL_FALSE, sizeof(GlyphInstance), (void *)(sizeof(Vec4f) * 4 + sizeof(int)));
glVertexAttribPointer(7, 4, GL_FLOAT, GL_FALSE, sizeof(GlyphInstance), (void *)(sizeof(Vec4f) * 5 + sizeof(int)));
glVertexAttribDivisor(4, 1);
glVertexAttribDivisor(5, 1);
glVertexAttribDivisor(6, 1);
glVertexAttribDivisor(7, 1);
// font ebo
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, font_ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(quad_indices), quad_indices, GL_STATIC_DRAW);
use_shader(font_shader);
for (int i = 32; i < 128; i++) {
for (int j = 0; j < 4; j++) {
char text[32];
snprintf(text, 32, "texcoords[%d]", (i - 32) * 4 + j);
set_vec2f(font_shader, text, zephr_ctx->font.characters[i].tex_coords[j].x, zephr_ctx->font.characters[i].tex_coords[j].y);
}
}
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
return 0;
}
Sizef calculate_text_size(const char *text, int font_size) {
float scale = (float)font_size / FONT_PIXEL_SIZE;
Sizef size = { .width = 0, .height = 0 };
int w = 0;
int h = 0;
int max_bearing_h = 0;
// NOTE: I don't like looping through the characters twice, but it's fine for now
for (int i = 0; text[i] != '\0'; i++) {
Character ch = zephr_ctx->font.characters[(u32)text[i]];
max_bearing_h = CORE_MAX(max_bearing_h, ch.bearing.height);
}
for (u64 i = 0; text[i] != '\0'; i++) {
Character ch = zephr_ctx->font.characters[(u32)text[i]];
w += ch.advance / 64;
// remove bearing of first character
if (i == 0 && strlen(text) > 1) {
w -= ch.bearing.width;
}
// remove the trailing width of the last character
if (i == strlen(text) - 1) {
w -= ((ch.advance / 64) - (ch.bearing.width + ch.size.width));
}
// if we only have one character in the text, then remove the bearing width
if (strlen(text) == 1) {
w -= (ch.bearing.width);
}
h = CORE_MAX(h, max_bearing_h - ch.bearing.height + ch.size.height);
}
size.width = (float)w * scale;
size.height = (float)h * scale;
return size;
}
GlyphInstanceList get_glyph_instance_list_from_text(const char *text, int font_size, UIConstraints constraints, const Color color, Alignment alignment) {
use_shader(font_shader);
Colorf text_color = (Colorf){ color.r / 255.f, color.g / 255.f, color.b / 255.f, color.a / 255.f };
set_mat4f(font_shader, "projection", (float *)zephr_ctx->projection.m);
Vec2f pos = { 0.f, 0.f };
Sizef size = {0};
apply_constraints(&constraints, &pos, &size);
Sizef text_size = calculate_text_size(text, FONT_PIXEL_SIZE);
float font_scale = (float)font_size / FONT_PIXEL_SIZE * size.width;
apply_alignment(alignment, &constraints, &pos, (Sizef){ text_size.width * font_scale, text_size.height * font_scale });
Matrix4x4 model = identity();
apply_scale(&model, (Sizef){font_scale, font_scale});
// rotate around the center point of the text
apply_translation(&model, (Vec2f){-text_size.width * font_scale / 2.f, -text_size.height * font_scale / 2.f});
apply_rotation(&model, to_radians(constraints.rotation));
apply_translation(&model, (Vec2f){text_size.width *font_scale / 2.f, text_size.height * font_scale / 2.f});
apply_translation(&model, pos);
int max_bearing_h = 0;
for (int i = 0; (i < text[i]) != '\0'; i++) {
Character ch = zephr_ctx->font.characters[(int)text[i]];
max_bearing_h = CORE_MAX(max_bearing_h, ch.bearing.height);
}
float first_char_bearing_w = zephr_ctx->font.characters[(int)text[0]].bearing.width;
GlyphInstanceList glyph_instance_list;
new_glyph_instance_list(&glyph_instance_list, 16);
// we use the original text and character sizes in the loop and then we just
// scale up or down the model matrix to get the desired font size.
// this way everything works out fine and we get to transform the text using the
// model matrix
int c = 0;
int x = 0;
while (text[c] != '\0') {
Character ch = zephr_ctx->font.characters[(int)text[c]];
// subtract the bearing width of the first character to remove the extra space
// at the start of the text and move every char to the left by that width
float xpos = (x + (ch.bearing.width - first_char_bearing_w));
float ypos = (text_size.height - ch.bearing.height - (text_size.height - max_bearing_h));
GlyphInstance instance = {
.position = (Vec4f){xpos, ypos, ch.size.width, ch.size.height},
.tex_coords_index = (int)text[c] - 32,
.color = text_color,
.model = {{0}},
};
memcpy(instance.model, model.m, sizeof(float[4][4]));
add_glyph_instance(&glyph_instance_list, instance);
x += (ch.advance >> 6);
c++;
}
return glyph_instance_list;
}
void draw_text(const char* text, int font_size, UIConstraints constraints, const Color color, Alignment alignment) {
GlyphInstanceList glyph_instance_list = get_glyph_instance_list_from_text(text, font_size, constraints, color, alignment);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, zephr_ctx->font.atlas_texture_id);
glBindVertexArray(font_vao);
glBindBuffer(GL_ARRAY_BUFFER, font_instance_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(GlyphInstance) * glyph_instance_list.size, glyph_instance_list.data, GL_DYNAMIC_DRAW);
glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_INT, NULL, glyph_instance_list.size);
glBindVertexArray(0);
glBindTexture(GL_TEXTURE_2D, 0);
free(glyph_instance_list.data);
}
void draw_text_batch(GlyphInstanceList *batch) {
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, zephr_ctx->font.atlas_texture_id);
glBindVertexArray(font_vao);
glBindBuffer(GL_ARRAY_BUFFER, font_instance_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(GlyphInstance) * batch->size, batch->data, GL_DYNAMIC_DRAW);
glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_INT, NULL, batch->size);
glBindVertexArray(0);
glBindTexture(GL_TEXTURE_2D, 0);
free(batch->data);
}
void add_text_instance(GlyphInstanceList *batch, const char* text, int font_size, UIConstraints constraints, const Color color, Alignment alignment) {
GlyphInstanceList glyph_instance_list = get_glyph_instance_list_from_text(text, font_size, constraints, color, alignment);
extend_glyph_instance_list(batch, &glyph_instance_list);
free(glyph_instance_list.data);
}
text.h
+37
View File
@@ -0,0 +1,37 @@
#pragma once
#include "core.h"
#include "ui.h"
#include "zephr_math.h"
typedef struct Character {
Size size;
Size bearing;
unsigned int advance;
Vec2f tex_coords[4]; // the 4 corners of the character quad
} Character;
typedef struct ZephrFont {
Character characters[128];
unsigned int atlas_texture_id;
} ZephrFont;
typedef struct TextInstance {
Vec4f position;
int tex_coords_index;
Colorf color;
float model[4][4];
} GlyphInstance;
typedef struct GlyphInstanceList {
GlyphInstance *data;
int size;
int capacity;
} GlyphInstanceList;
void new_glyph_instance_list(GlyphInstanceList *list, u32 capacity);
int init_fonts(const char *font_path);
Sizef calculate_text_size(const char *text, int font_size);
void draw_text(const char* text, int font_size, UIConstraints constraints, const Color color, Alignment alignment);
void add_text_instance(GlyphInstanceList *batch, const char* text, int font_size, UIConstraints constraints, const Color color, Alignment alignment);
void draw_text_batch(GlyphInstanceList *batch);
timer.c
+58
View File
@@ -0,0 +1,58 @@
#include <sys/time.h>
#include <stdlib.h>
#include "timer.h"
struct timeval start_time;
double get_time(void) {
struct timeval current_time;
gettimeofday(&current_time, NULL);
return (double)(current_time.tv_sec - start_time.tv_sec) + (double)(current_time.tv_usec - start_time.tv_usec) / 1000000.0;
}
void start_internal_timer(void) {
gettimeofday(&start_time, NULL);
}
bool timer_ended(Timer *timer) {
if (timer->state == TIMER_STOPPED) return false;
return get_time() - timer->start >= timer->duration;
}
void timer_start(Timer *timer, float duration) {
timer->start = get_time();
timer->elapsed = 0;
timer->duration = duration;
timer->state = TIMER_RUNNING;
}
void timer_stop(Timer *timer) {
timer->state = TIMER_STOPPED;
}
void timer_reset(Timer *timer) {
timer->start = get_time();
timer->elapsed = 0;
timer->state = TIMER_RUNNING;
}
double timer_remaining(Timer *timer) {
return timer->duration - (get_time() - timer->start);
}
double timer_elapsed(Timer *timer) {
return get_time() - timer->start + timer->elapsed;
}
void timer_pause(Timer *timer) {
timer->state = TIMER_PAUSED;
timer->elapsed = get_time() - timer->start + timer->elapsed;
}
void timer_resume(Timer *timer) {
timer->state = TIMER_RUNNING;
timer->start = get_time();
}
timer.h
+27
View File
@@ -0,0 +1,27 @@
#pragma once
#include <stdbool.h>
typedef enum TimerState {
TIMER_RUNNING,
TIMER_PAUSED,
TIMER_STOPPED,
} TimerState;
typedef struct Timer {
double start;
double elapsed;
float duration;
TimerState state;
} Timer;
double get_time(void);
void start_internal_timer(void);
bool timer_ended(Timer *timer);
void timer_start(Timer *timer, float duration);
void timer_stop(Timer *timer);
void timer_reset(Timer *timer);
double timer_remaining(Timer *timer);
double timer_elapsed(Timer *timer);
void timer_pause(Timer *timer);
void timer_resume(Timer *timer);
ui.c
+299
View File
@@ -0,0 +1,299 @@
#include <stdio.h>
#include <glad/glx.h>
#include "shader.h"
#include "zephr.h"
Shader ui_shader;
unsigned int ui_vao;
unsigned int ui_vbo;
int init_ui(const char* font_path, Size window_size) {
zephr_ctx->window.size = window_size;
zephr_ctx->projection = orthographic_projection_2d(0.f, window_size.width, window_size.height, 0.f);
int res = init_fonts(font_path);
if (res == -1) {
printf("[ERROR]: could not initialize freetype library\n");
return 1;
} else if (res == -2) {
printf("[ERROR]: could not load font file: \"%s\"\n", font_path);
return 1;
}
ui_shader = create_shader("shaders/ui.vert", "shaders/ui.frag");
glGenVertexArrays(1, &ui_vao);
glGenBuffers(1, &ui_vbo);
glBindVertexArray(ui_vao);
glBindBuffer(GL_ARRAY_BUFFER, ui_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 6 * 4, NULL, GL_DYNAMIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void *)0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
return 0;
}
void set_parent_constraint(UIConstraints *constraints, UIConstraints *parent_constraints) {
constraints->parent = parent_constraints;
}
void set_x_constraint(UIConstraints *constraints, float value, UIConstraint type) {
switch (type) {
case UI_CONSTRAINT_RELATIVE_PIXELS:
case UI_CONSTRAINT_ASPECT_RATIO:
// no-op. fallback to FIXED
case UI_CONSTRAINT_FIXED:
constraints->x = value;
break;
case UI_CONSTRAINT_RELATIVE:
constraints->x = (value * zephr_ctx->window.size.width);
break;
}
if (constraints->parent) {
constraints->x += constraints->parent->x;
}
}
void set_y_constraint(UIConstraints *constraints, float value, UIConstraint type) {
switch (type) {
case UI_CONSTRAINT_RELATIVE_PIXELS:
case UI_CONSTRAINT_ASPECT_RATIO:
// no-op. fallback to FIXED
case UI_CONSTRAINT_FIXED:
constraints->y = value;
break;
case UI_CONSTRAINT_RELATIVE:
constraints->y = (value * zephr_ctx->window.size.height);
break;
}
if (constraints->parent) {
constraints->y += constraints->parent->y;
}
}
void set_width_constraint(UIConstraints *constraints, float value, UIConstraint type) {
switch (type) {
case UI_CONSTRAINT_FIXED:
constraints->width = value;
break;
case UI_CONSTRAINT_RELATIVE:
constraints->width = (value * zephr_ctx->window.size.width);
break;
case UI_CONSTRAINT_RELATIVE_PIXELS:
constraints->width = zephr_ctx->window.size.width / (float)zephr_ctx->screen_size.width * value;
break;
case UI_CONSTRAINT_ASPECT_RATIO:
constraints->width = constraints->height * value;
break;
}
}
void set_height_constraint(UIConstraints *constraints, float value, UIConstraint type) {
switch (type) {
case UI_CONSTRAINT_FIXED:
constraints->height = value;
break;
case UI_CONSTRAINT_RELATIVE:
constraints->height = (value * zephr_ctx->window.size.height);
break;
case UI_CONSTRAINT_RELATIVE_PIXELS:
constraints->height = zephr_ctx->window.size.height / (float)zephr_ctx->screen_size.height * value;
break;
case UI_CONSTRAINT_ASPECT_RATIO:
constraints->height = constraints->width * value;
break;
}
}
void set_rotation_constraint(UIConstraints *constraints, float angle_d) {
constraints->rotation = angle_d;
}
void apply_constraints(UIConstraints *constraints, Vec2f *pos, Sizef *size) {
*pos = (Vec2f){constraints->x, constraints->y};
*size = (Sizef){constraints->width, constraints->height};
}
void apply_alignment(Alignment align, UIConstraints *constraints, Vec2f *pos, Sizef size) {
// if we don't have a parent then we're a top level element and we should align against the window
Sizef parent_size = (Sizef){zephr_ctx->window.size.width, zephr_ctx->window.size.height};
if (constraints->parent) {
parent_size = (Sizef){constraints->parent->width, constraints->parent->height};
}
switch (align) {
case ALIGN_TOP_LEFT:
pos->x = pos->x;
pos->y = pos->y;
break;
case ALIGN_TOP_CENTER:
pos->x += parent_size.width / 2.f - size.width / 2.f;
pos->y = pos->y;
break;
case ALIGN_TOP_RIGHT:
pos->x += parent_size.width - size.width;
pos->y = pos->y;
break;
case ALIGN_BOTTOM_LEFT:
pos->x = pos->x;
pos->y += parent_size.height - size.height;
break;
case ALIGN_BOTTOM_CENTER:
pos->x += parent_size.width / 2.f - size.width / 2.f;
pos->y += parent_size.height - size.height;
break;
case ALIGN_BOTTOM_RIGHT:
pos->x += parent_size.width - size.width;
pos->y += parent_size.height - size.height;
break;
case ALIGN_LEFT_CENTER:
pos->x = pos->x;
pos->y += parent_size.height / 2.f - size.height / 2.f;
break;
case ALIGN_RIGHT_CENTER:
pos->x += parent_size.width - size.width;
pos->y += parent_size.height / 2.f - size.height / 2.f;
break;
case ALIGN_CENTER:
pos->x += parent_size.width / 2.f - size.width / 2.f;
pos->y += parent_size.height / 2.f - size.height / 2.f;
break;
}
}
void draw_quad(UIConstraints *constraints, const Color color, float border_radius, Alignment align) {
use_shader(ui_shader);
set_vec4f(ui_shader, "aColor", color.r / 255.f, color.g / 255.f, color.b / 255.f, color.a / 255.f);
set_float(ui_shader, "uiWidth", constraints->width);
set_float(ui_shader, "uiHeight", constraints->height);
set_float(ui_shader, "borderRadius", border_radius);
set_mat4f(ui_shader, "projection", (float *)zephr_ctx->projection.m);
Vec2f pos = { 0.f, 0.f };
Sizef size = { 0.f, 0.f };
apply_constraints(constraints, &pos, &size);
apply_alignment(align, constraints, &pos, size);
// set the positions after applying alignment so children can use them
constraints->x = pos.x;
constraints->y = pos.y;
Matrix4x4 model = identity();
apply_translation(&model, (Vec2f){-size.width / 2.f, -size.height / 2.f});
apply_rotation(&model, to_radians(constraints->rotation));
apply_translation(&model, (Vec2f){size.width / 2.f, size.height / 2.f});
apply_translation(&model, pos);
set_mat4f(ui_shader, "model", (float *)model.m);
glBindVertexArray(ui_vao);
float vertices[6][4] = {
// bottom left tri
{0, 0 + size.height, 0.0, 1.0},
{0, 0, 0.0, 0.0},
{0 + size.width, 0, 1.0, 0.0},
// top right tri
{0, 0 + size.height, 0.0, 1.0},
{0 + size.width, 0, 1.0, 0.0},
{0 + size.width, 0 + size.height, 1.0, 1.0},
};
glBindBuffer(GL_ARRAY_BUFFER, ui_vbo);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindVertexArray(0);
}
void draw_circle(UIConstraints *constraints, const Color color, Alignment align) {
float radius = 0.f;
if (constraints->width > constraints->height) {
radius = constraints->height / 2.f;
} else {
radius = constraints->width / 2.f;
}
draw_quad(constraints, color, radius, align);
}
void draw_triangle(UIConstraints *constraints, const Color color, Alignment align) {
use_shader(ui_shader);
set_vec4f(ui_shader, "aColor", color.r / 255.f, color.g / 255.f, color.b / 255.f, color.a / 255.f);
set_mat4f(ui_shader, "projection", (float *)zephr_ctx->projection.m);
Vec2f pos = { 0.f, 0.f };
Sizef size = { 0.f, 0.f };
apply_constraints(constraints, &pos, &size);
apply_alignment(align, constraints, &pos, size);
Matrix4x4 model = identity();
apply_translation(&model, (Vec2f){-size.width / 2.f, -size.height / 2.f});
apply_rotation(&model, to_radians(constraints->rotation));
apply_translation(&model, (Vec2f){size.width / 2.f, size.height / 2.f});
apply_translation(&model, pos);
set_mat4f(ui_shader, "model", (float *)model.m);
glBindVertexArray(ui_vao);
float vertices[3][4] = {
{0 + size.width, 0, 0.0, 0.0},
{0, 0, 0.0, 0.0},
{0 + size.width / 2, 0 + size.height, 0.0, 0.0},
};
glBindBuffer(GL_ARRAY_BUFFER, ui_vbo);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDrawArrays(GL_TRIANGLES, 0, 3);
glBindVertexArray(0);
}
/* enum Element { */
/* Rect, */
/* Circle, */
/* }; */
/* struct UIElement { */
/* Vec2 pos; */
/* Size size; */
/* Color *color; */
/* enum Element type; */
/* }; */
/* struct UIText { */
/* Vec2 pos; */
/* float scale; */
/* Color *color; */
/* const char* text; */
/* }; */
/* struct UIElement *create_element(Vec2 pos, Size size, Color *color, enum Element type) { */
/* struct UIElement *element = malloc(sizeof(struct UIElement)); */
/* element->pos = pos; */
/* element->size = size; */
/* element->color = color; */
/* element->type = type; */
/* return element; */
/* } */
ui.h
+44
View File
@@ -0,0 +1,44 @@
#pragma once
#include "zephr_math.h"
typedef enum Alignment {
ALIGN_TOP_LEFT,
ALIGN_TOP_CENTER,
ALIGN_TOP_RIGHT,
ALIGN_LEFT_CENTER,
ALIGN_CENTER,
ALIGN_RIGHT_CENTER,
ALIGN_BOTTOM_LEFT,
ALIGN_BOTTOM_CENTER,
ALIGN_BOTTOM_RIGHT,
} Alignment;
typedef enum UIConstraint {
UI_CONSTRAINT_FIXED,
UI_CONSTRAINT_RELATIVE,
UI_CONSTRAINT_RELATIVE_PIXELS,
UI_CONSTRAINT_ASPECT_RATIO,
} UIConstraint;
typedef struct UIConstraints {
float x;
float y;
float width;
float height;
float rotation;
struct UIConstraints *parent;
} UIConstraints;
int init_ui(const char* font_path, Size window_size);
void set_parent_constraint(UIConstraints *constraints, UIConstraints *parent_constraints);
void set_x_constraint(UIConstraints *constraints, float value, UIConstraint type);
void set_y_constraint(UIConstraints *constraints, float value, UIConstraint type);
void set_width_constraint(UIConstraints *constraints, float value, UIConstraint type);
void set_height_constraint(UIConstraints *constraints, float value, UIConstraint type);
void set_rotation_constraint(UIConstraints *constraints, float angle_d);
void apply_constraints(UIConstraints *constraints, Vec2f *pos, Sizef *size);
void apply_alignment(Alignment align, UIConstraints *constraints, Vec2f *pos, Sizef size);
void draw_quad(UIConstraints *constraints, const Color color, float border_radius, Alignment align);
void draw_circle(UIConstraints *constraints, const Color color, Alignment align);
void draw_triangle(UIConstraints *constraints, const Color color, Alignment align);
zephr.c
+998
View File
@@ -0,0 +1,998 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <X11/Xatom.h>
#include <glad/glx.h>
#include "audio.h"
#include "core.h"
#include "timer.h"
#include "ui.h"
#include "zephr.h"
Display *x11_display;
Window x11_window;
Colormap x11_colormap;
GLXContext glx_context;
/* XIC x11_xic; */
ZephrContext *zephr_ctx = NULL;
///////////////////////////
//
// Common
//
///////////////////////////
ZephrKeycode zephr_evdev_scancode_to_zephr_scancode_map[] = {
ZEPHR_KEYCODE_NULL,
ZEPHR_KEYCODE_ESCAPE,
ZEPHR_KEYCODE_1,
ZEPHR_KEYCODE_2,
ZEPHR_KEYCODE_3,
ZEPHR_KEYCODE_4,
ZEPHR_KEYCODE_5,
ZEPHR_KEYCODE_6,
ZEPHR_KEYCODE_7,
ZEPHR_KEYCODE_8,
ZEPHR_KEYCODE_9,
ZEPHR_KEYCODE_0,
ZEPHR_KEYCODE_MINUS,
ZEPHR_KEYCODE_EQUALS,
ZEPHR_KEYCODE_BACKSPACE,
ZEPHR_KEYCODE_TAB,
ZEPHR_KEYCODE_Q,
ZEPHR_KEYCODE_W,
ZEPHR_KEYCODE_E,
ZEPHR_KEYCODE_R,
ZEPHR_KEYCODE_T,
ZEPHR_KEYCODE_Y,
ZEPHR_KEYCODE_U,
ZEPHR_KEYCODE_I,
ZEPHR_KEYCODE_O,
ZEPHR_KEYCODE_P,
ZEPHR_KEYCODE_LEFT_BRACKET,
ZEPHR_KEYCODE_RIGHT_BRACKET,
ZEPHR_KEYCODE_ENTER,
ZEPHR_KEYCODE_LEFT_CTRL,
ZEPHR_KEYCODE_A,
ZEPHR_KEYCODE_S,
ZEPHR_KEYCODE_D,
ZEPHR_KEYCODE_F,
ZEPHR_KEYCODE_G,
ZEPHR_KEYCODE_H,
ZEPHR_KEYCODE_J,
ZEPHR_KEYCODE_K,
ZEPHR_KEYCODE_L,
ZEPHR_KEYCODE_SEMICOLON,
ZEPHR_KEYCODE_APOSTROPHE,
ZEPHR_KEYCODE_GRAVE,
ZEPHR_KEYCODE_LEFT_SHIFT,
ZEPHR_KEYCODE_BACKSLASH,
ZEPHR_KEYCODE_Z,
ZEPHR_KEYCODE_X,
ZEPHR_KEYCODE_C,
ZEPHR_KEYCODE_V,
ZEPHR_KEYCODE_B,
ZEPHR_KEYCODE_N,
ZEPHR_KEYCODE_M,
ZEPHR_KEYCODE_COMMA,
ZEPHR_KEYCODE_PERIOD,
ZEPHR_KEYCODE_SLASH,
ZEPHR_KEYCODE_RIGHT_SHIFT,
ZEPHR_KEYCODE_KP_MULTIPLY,
ZEPHR_KEYCODE_LEFT_ALT,
ZEPHR_KEYCODE_SPACE,
ZEPHR_KEYCODE_CAPS_LOCK,
ZEPHR_KEYCODE_F1,
ZEPHR_KEYCODE_F2,
ZEPHR_KEYCODE_F3,
ZEPHR_KEYCODE_F4,
ZEPHR_KEYCODE_F5,
ZEPHR_KEYCODE_F6,
ZEPHR_KEYCODE_F7,
ZEPHR_KEYCODE_F8,
ZEPHR_KEYCODE_F9,
ZEPHR_KEYCODE_F10,
ZEPHR_KEYCODE_NUM_LOCK_OR_CLEAR,
ZEPHR_KEYCODE_SCROLL_LOCK,
ZEPHR_KEYCODE_KP_7,
ZEPHR_KEYCODE_KP_8,
ZEPHR_KEYCODE_KP_9,
ZEPHR_KEYCODE_KP_MINUS,
ZEPHR_KEYCODE_KP_4,
ZEPHR_KEYCODE_KP_5,
ZEPHR_KEYCODE_KP_6,
ZEPHR_KEYCODE_KP_PLUS,
ZEPHR_KEYCODE_KP_1,
ZEPHR_KEYCODE_KP_2,
ZEPHR_KEYCODE_KP_3,
ZEPHR_KEYCODE_KP_0,
ZEPHR_KEYCODE_KP_PERIOD,
[85] = ZEPHR_KEYCODE_LANG5, // KEY_ZENKAKUHANKAKU
ZEPHR_KEYCODE_NON_US_BACKSLASH, // KEY_102ND
ZEPHR_KEYCODE_F11,
ZEPHR_KEYCODE_F12,
ZEPHR_KEYCODE_INTERNATIONAL1, // KEY_RO,
ZEPHR_KEYCODE_LANG3, // KEY_KATAKANA
ZEPHR_KEYCODE_LANG4, // KEY_HIRAGANA
ZEPHR_KEYCODE_INTERNATIONAL4, // KEY_HENKAN
ZEPHR_KEYCODE_INTERNATIONAL2, // KEY_KATAKANAHIRAGANA
ZEPHR_KEYCODE_INTERNATIONAL5, // KEY_MUHENKAN
ZEPHR_KEYCODE_INTERNATIONAL5, // KEY_KPJOCOMMA
ZEPHR_KEYCODE_KP_ENTER,
ZEPHR_KEYCODE_RIGHT_CTRL,
ZEPHR_KEYCODE_KP_DIVIDE,
ZEPHR_KEYCODE_SYSREQ,
ZEPHR_KEYCODE_RIGHT_ALT,
ZEPHR_KEYCODE_NULL, // KEY_LINEFEED
ZEPHR_KEYCODE_HOME,
ZEPHR_KEYCODE_UP,
ZEPHR_KEYCODE_PAGE_UP,
ZEPHR_KEYCODE_LEFT,
ZEPHR_KEYCODE_RIGHT,
ZEPHR_KEYCODE_END,
ZEPHR_KEYCODE_DOWN,
ZEPHR_KEYCODE_PAGE_DOWN,
ZEPHR_KEYCODE_INSERT,
ZEPHR_KEYCODE_DELETE,
ZEPHR_KEYCODE_NULL, // KEY_MACRO
ZEPHR_KEYCODE_MUTE,
ZEPHR_KEYCODE_VOLUME_DOWN,
ZEPHR_KEYCODE_VOLUME_UP,
ZEPHR_KEYCODE_POWER,
ZEPHR_KEYCODE_KP_EQUALS,
ZEPHR_KEYCODE_KP_PLUS_MINUS,
ZEPHR_KEYCODE_PAUSE,
[121] = ZEPHR_KEYCODE_KP_COMMA,
ZEPHR_KEYCODE_LANG1, // KEY_HANGUEL
ZEPHR_KEYCODE_LANG2, // KEY_HANJA
ZEPHR_KEYCODE_INTERNATIONAL3, // KEY_YEN
ZEPHR_KEYCODE_LEFT_META,
ZEPHR_KEYCODE_RIGHT_META,
ZEPHR_KEYCODE_APPLICATION, // KEY_COMPOSE
ZEPHR_KEYCODE_STOP,
ZEPHR_KEYCODE_AGAIN,
ZEPHR_KEYCODE_NULL, // KEY_PROPS
ZEPHR_KEYCODE_UNDO,
ZEPHR_KEYCODE_NULL, // KEY_FRONT
ZEPHR_KEYCODE_COPY,
ZEPHR_KEYCODE_NULL, // KEY_OPEN
ZEPHR_KEYCODE_PASTE,
ZEPHR_KEYCODE_FIND,
ZEPHR_KEYCODE_CUT,
ZEPHR_KEYCODE_HELP,
ZEPHR_KEYCODE_MENU,
ZEPHR_KEYCODE_NULL, // CALCULATOR
ZEPHR_KEYCODE_NULL, // KEY_SETUP
ZEPHR_KEYCODE_NULL, // SLEEP
ZEPHR_KEYCODE_NULL, // KEY_WAKEUP
ZEPHR_KEYCODE_NULL, // KEY_FILE
ZEPHR_KEYCODE_NULL, // KEY_SENDFILE
ZEPHR_KEYCODE_NULL, // KEY_DELETEFILE
ZEPHR_KEYCODE_NULL, // KEY_XFER
ZEPHR_KEYCODE_NULL, // KEY_PROG1
ZEPHR_KEYCODE_NULL, // KEY_PROG2
ZEPHR_KEYCODE_NULL, // WWW
ZEPHR_KEYCODE_NULL, // KEY_MSDOS
ZEPHR_KEYCODE_NULL, // KEY_COFFEE
ZEPHR_KEYCODE_NULL, // KEY_DIRECTION
ZEPHR_KEYCODE_NULL, // KEY_CYCLEWINDOWS
ZEPHR_KEYCODE_NULL, // MAIL
ZEPHR_KEYCODE_NULL, // AC_BOOKMARKS
ZEPHR_KEYCODE_NULL, // COMPUTER
ZEPHR_KEYCODE_NULL, // AC_BACK
ZEPHR_KEYCODE_NULL, // AC_FORWARD
ZEPHR_KEYCODE_NULL, // KEY_CLOSECD
ZEPHR_KEYCODE_NULL, // EJECT
ZEPHR_KEYCODE_NULL, // KEY_EJECTCLOSECD
ZEPHR_KEYCODE_NULL, // AUDIO_NEXT
ZEPHR_KEYCODE_NULL, // AUDIO_PLAY
ZEPHR_KEYCODE_NULL, // AUDIO_PREV
ZEPHR_KEYCODE_NULL, // AUDIO_STOP
ZEPHR_KEYCODE_NULL, // KEY_RECORD
ZEPHR_KEYCODE_NULL, // AUDIO_REWIND
ZEPHR_KEYCODE_NULL, // KEY_PHONE
ZEPHR_KEYCODE_NULL, // KEY_ISO
ZEPHR_KEYCODE_NULL, // KEY_CONFIG
ZEPHR_KEYCODE_NULL, // AC_HOME
ZEPHR_KEYCODE_NULL, // AC_REFRESH
ZEPHR_KEYCODE_NULL, // KEY_EXIT
ZEPHR_KEYCODE_NULL, // KEY_MOVE
ZEPHR_KEYCODE_NULL, // KEY_EDIT
ZEPHR_KEYCODE_NULL, // KEY_SCROLLUP
ZEPHR_KEYCODE_NULL, // KEY_SCROLLDOWN
ZEPHR_KEYCODE_KP_LEFT_PAREN,
ZEPHR_KEYCODE_KP_RIGHT_PAREN,
ZEPHR_KEYCODE_NULL, // KEY_NEW
ZEPHR_KEYCODE_NULL, // KEY_REDO
ZEPHR_KEYCODE_F13,
ZEPHR_KEYCODE_F14,
ZEPHR_KEYCODE_F15,
ZEPHR_KEYCODE_F16,
ZEPHR_KEYCODE_F17,
ZEPHR_KEYCODE_F18,
ZEPHR_KEYCODE_F19,
ZEPHR_KEYCODE_F20,
ZEPHR_KEYCODE_F21,
ZEPHR_KEYCODE_F22,
ZEPHR_KEYCODE_F23,
ZEPHR_KEYCODE_F24,
[200] = ZEPHR_KEYCODE_NULL, // KEY_PLAYCD
ZEPHR_KEYCODE_NULL, // KEY_PAUSECD
ZEPHR_KEYCODE_NULL, // KEY_PROG3
ZEPHR_KEYCODE_NULL, // KEY_PROG4
[205] = ZEPHR_KEYCODE_NULL, // KEY_SUSPEND
ZEPHR_KEYCODE_NULL, // KEY_CLOSE
ZEPHR_KEYCODE_NULL, // KEY_PLAY
ZEPHR_KEYCODE_NULL, // AUDIO_FASTFORWARD
ZEPHR_KEYCODE_NULL, // KEY_BASSBOOST
ZEPHR_KEYCODE_NULL, // KEY_PRINT
ZEPHR_KEYCODE_NULL, // KEY_HP
ZEPHR_KEYCODE_NULL, // KEY_CAMERA
ZEPHR_KEYCODE_NULL, // KEY_SOUND
ZEPHR_KEYCODE_NULL, // KEY_QUESTION
ZEPHR_KEYCODE_NULL, // KEY_EMAIL
ZEPHR_KEYCODE_NULL, // KEY_CHAT
ZEPHR_KEYCODE_NULL, // AC_SEARCH
ZEPHR_KEYCODE_NULL, // KEY_CONNECT
ZEPHR_KEYCODE_NULL, // KEY_FINANCE
ZEPHR_KEYCODE_NULL, // KEY_SPORT
ZEPHR_KEYCODE_NULL, // KEY_SHOP
ZEPHR_KEYCODE_ALT_ERASE,
ZEPHR_KEYCODE_CANCEL,
ZEPHR_KEYCODE_NULL, // BRIGHTNESS_DOWN
ZEPHR_KEYCODE_NULL, // BRIGHNESS_UP
ZEPHR_KEYCODE_NULL, // KEY_MEDIA
ZEPHR_KEYCODE_NULL, // DISPLAY_SWITCH
ZEPHR_KEYCODE_NULL, // KBD_ILLUM_TOGGLE
ZEPHR_KEYCODE_NULL, // KBD_ILLUM_DOWN
ZEPHR_KEYCODE_NULL, // KBD_ILLUM_UP
ZEPHR_KEYCODE_NULL, // KEY_SEND
ZEPHR_KEYCODE_NULL, // KEY_REPLY
ZEPHR_KEYCODE_NULL, // KEY_FORWARDEMAIL
ZEPHR_KEYCODE_NULL, // KEY_SAVE
ZEPHR_KEYCODE_NULL, // KEY_DOCUMENTS
ZEPHR_KEYCODE_NULL, // KEY_BATTERY
};
ZephrKeycode zephr_x11_fn_keysym_to_zephr_keycode_map[] = {
[0x08] = ZEPHR_KEYCODE_BACKSPACE,
ZEPHR_KEYCODE_TAB,
[0x0b] = ZEPHR_KEYCODE_CLEAR,
[0x0d] = ZEPHR_KEYCODE_ENTER,
[0x13] = ZEPHR_KEYCODE_PAUSE,
ZEPHR_KEYCODE_SCROLL_LOCK,
ZEPHR_KEYCODE_SYSREQ,
[0x1b] = ZEPHR_KEYCODE_ESCAPE,
[0x50] = ZEPHR_KEYCODE_HOME,
ZEPHR_KEYCODE_LEFT,
ZEPHR_KEYCODE_UP,
ZEPHR_KEYCODE_RIGHT,
ZEPHR_KEYCODE_DOWN,
ZEPHR_KEYCODE_PAGE_UP,
ZEPHR_KEYCODE_PAGE_DOWN,
ZEPHR_KEYCODE_END,
[0x60] = ZEPHR_KEYCODE_SELECT,
ZEPHR_KEYCODE_PRINT_SCREEN,
ZEPHR_KEYCODE_EXECUTE,
ZEPHR_KEYCODE_INSERT,
[0x65] = ZEPHR_KEYCODE_UNDO,
[0x67] = ZEPHR_KEYCODE_MENU,
ZEPHR_KEYCODE_FIND,
ZEPHR_KEYCODE_CANCEL,
ZEPHR_KEYCODE_HELP,
[0x7f] = ZEPHR_KEYCODE_NUM_LOCK_OR_CLEAR,
[0x80] = ZEPHR_KEYCODE_KP_SPACE,
[0x89] = ZEPHR_KEYCODE_KP_TAB,
[0x8d] = ZEPHR_KEYCODE_KP_ENTER,
[0xbd] = ZEPHR_KEYCODE_KP_EQUALS,
[0xaa] = ZEPHR_KEYCODE_KP_MULTIPLY,
ZEPHR_KEYCODE_KP_PLUS,
[0xad] = ZEPHR_KEYCODE_KP_MINUS,
ZEPHR_KEYCODE_KP_DECIMAL,
ZEPHR_KEYCODE_KP_DIVIDE,
[0xb0] = ZEPHR_KEYCODE_KP_0,
ZEPHR_KEYCODE_KP_1,
ZEPHR_KEYCODE_KP_2,
ZEPHR_KEYCODE_KP_3,
ZEPHR_KEYCODE_KP_4,
ZEPHR_KEYCODE_KP_5,
ZEPHR_KEYCODE_KP_6,
ZEPHR_KEYCODE_KP_7,
ZEPHR_KEYCODE_KP_8,
ZEPHR_KEYCODE_KP_9,
[0xbe] = ZEPHR_KEYCODE_F1,
ZEPHR_KEYCODE_F2,
ZEPHR_KEYCODE_F3,
ZEPHR_KEYCODE_F4,
ZEPHR_KEYCODE_F5,
ZEPHR_KEYCODE_F6,
ZEPHR_KEYCODE_F7,
ZEPHR_KEYCODE_F8,
ZEPHR_KEYCODE_F9,
ZEPHR_KEYCODE_F10,
ZEPHR_KEYCODE_F11,
ZEPHR_KEYCODE_F12,
ZEPHR_KEYCODE_F13,
ZEPHR_KEYCODE_F14,
ZEPHR_KEYCODE_F15,
ZEPHR_KEYCODE_F16,
ZEPHR_KEYCODE_F17,
ZEPHR_KEYCODE_F18,
ZEPHR_KEYCODE_F19,
ZEPHR_KEYCODE_F20,
ZEPHR_KEYCODE_F21,
ZEPHR_KEYCODE_F22,
ZEPHR_KEYCODE_F23,
ZEPHR_KEYCODE_F24,
[0xe1] = ZEPHR_KEYCODE_LEFT_SHIFT,
ZEPHR_KEYCODE_RIGHT_SHIFT,
ZEPHR_KEYCODE_LEFT_CTRL,
ZEPHR_KEYCODE_RIGHT_CTRL,
ZEPHR_KEYCODE_CAPS_LOCK,
ZEPHR_KEYCODE_CAPS_LOCK, // TODO: ???
ZEPHR_KEYCODE_LEFT_META,
ZEPHR_KEYCODE_RIGHT_META,
ZEPHR_KEYCODE_LEFT_ALT,
ZEPHR_KEYCODE_RIGHT_ALT,
ZEPHR_KEYCODE_LEFT_META, // TODO: ???
ZEPHR_KEYCODE_RIGHT_META, // TODO: ???
[0xff] = ZEPHR_KEYCODE_DELETE,
};
ZephrKeycode zephr_x11_fn_ex_keysym_to_zephr_keycode_map[] = {
[0x03] = ZEPHR_KEYCODE_RIGHT_ALT,
[0xff] = ZEPHR_KEYCODE_NULL,
};
ZephrKeycode zephr_x11_latin1_keysym_to_zephr_keycode_map[] = {
[0x20] = ZEPHR_KEYCODE_SPACE,
[0x27] = ZEPHR_KEYCODE_APOSTROPHE,
[0x2c] = ZEPHR_KEYCODE_COMMA,
ZEPHR_KEYCODE_MINUS,
ZEPHR_KEYCODE_PERIOD,
ZEPHR_KEYCODE_SLASH,
ZEPHR_KEYCODE_0,
ZEPHR_KEYCODE_1,
ZEPHR_KEYCODE_2,
ZEPHR_KEYCODE_3,
ZEPHR_KEYCODE_4,
ZEPHR_KEYCODE_5,
ZEPHR_KEYCODE_6,
ZEPHR_KEYCODE_7,
ZEPHR_KEYCODE_8,
ZEPHR_KEYCODE_9,
[0x3b] = ZEPHR_KEYCODE_SEMICOLON,
[0x3d] = ZEPHR_KEYCODE_EQUALS,
[0x5b] = ZEPHR_KEYCODE_LEFT_BRACKET,
ZEPHR_KEYCODE_BACKSLASH,
ZEPHR_KEYCODE_RIGHT_BRACKET,
[0x60] = ZEPHR_KEYCODE_GRAVE,
ZEPHR_KEYCODE_A,
ZEPHR_KEYCODE_B,
ZEPHR_KEYCODE_C,
ZEPHR_KEYCODE_D,
ZEPHR_KEYCODE_E,
ZEPHR_KEYCODE_F,
ZEPHR_KEYCODE_G,
ZEPHR_KEYCODE_H,
ZEPHR_KEYCODE_I,
ZEPHR_KEYCODE_J,
ZEPHR_KEYCODE_K,
ZEPHR_KEYCODE_L,
ZEPHR_KEYCODE_M,
ZEPHR_KEYCODE_N,
ZEPHR_KEYCODE_O,
ZEPHR_KEYCODE_P,
ZEPHR_KEYCODE_Q,
ZEPHR_KEYCODE_R,
ZEPHR_KEYCODE_S,
ZEPHR_KEYCODE_T,
ZEPHR_KEYCODE_U,
ZEPHR_KEYCODE_V,
ZEPHR_KEYCODE_W,
ZEPHR_KEYCODE_X,
ZEPHR_KEYCODE_Y,
ZEPHR_KEYCODE_Z,
[0xff] = ZEPHR_KEYCODE_NULL,
};
///////////////////////////
//
// X11
//
///////////////////////////
ZephrKeycode x11_keysym_to_zephr_keycode_map(KeySym sym) {
if (sym >= 0xff00 && sym <= 0xffff) {
return zephr_x11_fn_keysym_to_zephr_keycode_map[sym - 0xff00];
} else if (sym >= 0xfe00 && sym <= 0xfeff) {
return zephr_x11_fn_ex_keysym_to_zephr_keycode_map[sym - 0xfe00];
} else if (sym >= 0x100 && sym <= 0x1ff) {
return ZEPHR_KEYCODE_NULL;
/* return zephr_x11_latin2_keysym_to_zephr_keycode_map[sym - 0x100]; */
} else if (sym <= 0xff) {
return zephr_x11_latin1_keysym_to_zephr_keycode_map[sym];
} else {
return ZEPHR_KEYCODE_NULL;
}
}
// update internal keyboard map when the keyboard layout changes during runtime
/* void x11_keyboard_map_update() { */
/* // reset the keycodes to map directly to the scancodes */
/* for (int kc = 0; kc < ZEPHR_KEYCODE_COUNT; kc++) { */
/* zephr_ctx.keyboard.scancode_to_keycode[kc] = kc; */
/* zephr_ctx.keyboard.keycode_to_scancode[kc] = kc; */
/* } */
/* XkbStateRec state; */
/* XkbGetUpdatedMap(x11_display, XkbAllClientInfoMask, zephr_ctx.xkb); */
/* unsigned int group = 0; */
/* if (XkbGetState(x11_display, XkbUseCoreKbd, &state) == Success) { */
/* group = state.group; */
/* } */
/* int first_keycode = zephr_ctx.xkb->min_key_code; */
/* int last_keycode = zephr_ctx.xkb->max_key_code; */
/* // we don't map any more keys in evdev after 236 */
/* if (last_keycode > 236) { */
/* last_keycode = 236; */
/* } */
/* // some x11 magic: https://youtu.be/Y7yIwWIaD-Q?t=12993 */
/* // last_keycode - first_keycode exclusive because the first keycode is a NULL keycode */
/* // evdev scancodes are 8 less than x11 keycodes */
/* XkbGetKeySyms(x11_display, first_keycode, last_keycode - first_keycode, zephr_ctx.xkb); */
/* XkbClientMapRec *client_map = zephr_ctx.xkb->map; */
/* for (int x11keycode = 8; x11keycode < last_keycode; x11keycode++) { */
/* XkbSymMapRec *sym_map = &client_map->key_sym_map[x11keycode]; */
/* int sym_start_idx = sym_map->offset; */
/* // since we do not want any key modifiers, our shift is 0 */
/* int shift = 0; */
/* int sym_idx = sym_start_idx + (sym_map->width * group) + shift; */
/* KeySym sym = client_map->syms[sym_idx]; */
/* ZephrScancode scancode = zephr_evdev_scancode_to_zephr_scancode_map[x11keycode]; */
/* ZephrKeycode keycode = x11_keysym_to_zephr_keycode_map(sym); */
/* zephr_ctx.keyboard.scancode_to_keycode[scancode] = keycode; */
/* zephr_ctx.keyboard.keycode_to_scancode[keycode] = scancode; */
/* } */
/* } */
void x11_resize_window(void) {
XWindowAttributes win_attrs;
XGetWindowAttributes(x11_display, x11_window, &win_attrs);
glViewport(0, 0, win_attrs.width, win_attrs.height);
}
void x11_go_fullscreen(void) {
XEvent xev;
Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
Atom fullscreen = XInternAtom(x11_display, "_NET_WM_STATE_FULLSCREEN", False);
memset(&xev, 0, sizeof(xev));
xev.type = ClientMessage;
xev.xclient.window = x11_window;
xev.xclient.message_type = wm_state;
xev.xclient.format = 32;
xev.xclient.data.l[0] = 1; // _NET_WM_STATE_ADD
xev.xclient.data.l[1] = fullscreen;
xev.xclient.data.l[2] = 0;
XSendEvent(x11_display, DefaultRootWindow(x11_display), False,
SubstructureNotifyMask | SubstructureRedirectMask, &xev);
}
void x11_return_fullscreen(void) {
XEvent xev;
Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
Atom fullscreen = XInternAtom(x11_display, "_NET_WM_STATE_FULLSCREEN", False);
memset(&xev, 0, sizeof(xev));
xev.type = ClientMessage;
xev.xclient.window = x11_window;
xev.xclient.message_type = wm_state;
xev.xclient.format = 32;
xev.xclient.data.l[0] = 0; // _NET_WM_STATE_REMOVE
xev.xclient.data.l[1] = fullscreen;
xev.xclient.data.l[2] = 0;
XSendEvent(x11_display, DefaultRootWindow(x11_display), False,
SubstructureNotifyMask | SubstructureRedirectMask, &xev);
}
void x11_toggle_fullscreen(bool fullscreen) {
if (fullscreen) {
x11_return_fullscreen();
} else {
x11_go_fullscreen();
}
}
int x11_create_window(const char* title, int window_width, int window_height) {
x11_display = XOpenDisplay(NULL);
CORE_ASSERT(x11_display, "Cannot open x11 display connection\n");
int screen = DefaultScreen(x11_display);
Window root = RootWindow(x11_display, screen);
Visual *visual = DefaultVisual(x11_display, screen);
x11_colormap = XCreateColormap(x11_display, root, visual, AllocNone);
XSetWindowAttributes attributes;
attributes.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask |
StructureNotifyMask | ButtonPressMask | ButtonReleaseMask;
attributes.colormap = x11_colormap;
x11_window = XCreateWindow(x11_display, root, 0, 0, window_width, window_height, 0,
DefaultDepth(x11_display, screen), InputOutput, visual,
CWColormap | CWEventMask, &attributes);
// Hints to the WM that the window is a dialog window which makes it a floating
// window in tiling WMs (only tested on DWM though)
// Of course this is only a hint and the WM can ignore it
Atom net_wm_window_type = XInternAtom(x11_display, "_NET_WM_WINDOW_TYPE", False);
Atom net_wm_window_type_dialog = XInternAtom(x11_display, "_NET_WM_WINDOW_TYPE_DIALOG", False);
XChangeProperty(x11_display, x11_window, net_wm_window_type, XA_ATOM, 32, PropModeReplace, (unsigned char*)&net_wm_window_type_dialog, 1);
Atom wm_delete_window = XInternAtom(x11_display, "WM_DELETE_WINDOW", False);
XSetWMProtocols(x11_display, x11_window, &wm_delete_window, 1);
zephr_ctx->window_delete_atom = wm_delete_window;
XMapWindow(x11_display, x11_window);
XStoreName(x11_display, x11_window, title);
CORE_ASSERT(x11_window, "Failed to create window\n");
int glx_version = gladLoaderLoadGLX(x11_display, screen);
if (!glx_version) {
printf("[FATAL] Failed to load GLX\n");
return 1;
}
printf("[INFO] Loaded GLX %d.%d\n",
GLAD_VERSION_MAJOR(glx_version), GLAD_VERSION_MINOR(glx_version));
GLint visual_attributes[] = {
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_DEPTH_SIZE, 24,
GLX_DOUBLEBUFFER, 1,
GLX_SAMPLES, 4, // MSAA
None
};
int num_fbc = 0;
GLXFBConfig *fbc =
glXChooseFBConfig(x11_display, screen, visual_attributes, &num_fbc);
GLint context_attributes[] = {
GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
GLX_CONTEXT_MINOR_VERSION_ARB, 3,
GLX_CONTEXT_PROFILE_MASK_ARB, GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
None
};
glx_context = glXCreateContextAttribsARB(x11_display, fbc[0], NULL, 1,
context_attributes);
if (!glx_context) {
printf("[FATAL] Failed to create GLX context\n");
return 1;
}
glXMakeCurrent(x11_display, x11_window, glx_context);
int gl_version = gladLoaderLoadGL();
if (!gl_version) {
printf("[FATAL] Failed to load GL\n");
return 1;
}
printf("[INFO] Loaded GL %d.%d\n",
GLAD_VERSION_MAJOR(gl_version), GLAD_VERSION_MINOR(gl_version));
XWindowAttributes win_attrs;
XGetWindowAttributes(x11_display, x11_window, &win_attrs);
glad_glXSwapIntervalEXT(x11_display, x11_window, 1);
// we enable blending for text
glEnable(GL_BLEND);
glEnable(GL_MULTISAMPLE);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glViewport(0, 0, win_attrs.width, win_attrs.height);
x11_resize_window();
XFree(fbc);
return 0;
}
int x11_init(const char* title, int window_width, int window_height) {
int res = x11_create_window(title, window_width, window_height);
/* // loads the XMODIFIERS environment variable to see what IME to use */
/* XSetLocaleModifiers(""); */
/* XIM xim = XOpenIM(x11_display, 0, 0, 0); */
/* if(!xim){ */
/* // fallback to internal input method */
/* XSetLocaleModifiers("@im=none"); */
/* xim = XOpenIM(x11_display, 0, 0, 0); */
/* } */
/* zephr_ctx.xim = xim; */
/* // XIC */
/* // create an input context that is used by the whole window */
/* // you are supposed to have one of these per text field, but this should do */
/* x11_xic = XCreateIC(zephr_ctx.xim, */
/* XNInputStyle, XIMPreeditNothing | XIMStatusNothing, */
/* XNClientWindow, x11_window, XNFocusWindow, x11_window, */
/* NULL); */
/* XSetICFocus(x11_xic); */
/* // TODO: do we need to flush?? */
/* XFlush(x11_display); */
// XKB
/* { */
/* XAutoRepeatOn(x11_display); */
/* int major = 1, minor = 0; */
/* CORE_ASSERT(XkbQueryExtension(x11_display, NULL, NULL, NULL, &major, &minor), "XKB not supported"); */
/* zephr_ctx.xkb = XkbGetMap(x11_display, XkbAllClientInfoMask, XkbUseCoreKbd); */
/* int repeat = 0; */
/* XkbSetDetectableAutoRepeat(x11_display, True, &repeat); */
/* XkbSelectEvents(x11_display, XkbUseCoreKbd, XkbMapNotifyMask, XkbMapNotifyMask); */
/* x11_keyboard_map_update(); */
/* } */
return res;
}
void x11_close(void) {
glXMakeCurrent(x11_display, 0, 0);
glXDestroyContext(x11_display, glx_context);
XDestroyWindow(x11_display, x11_window);
XFreeColormap(x11_display, x11_colormap);
XCloseDisplay(x11_display);
gladLoaderUnloadGLX();
}
void x11_get_screen_size(int *width, int *height) {
Screen *screen = DefaultScreenOfDisplay(x11_display);
*width = screen->width;
*height = screen->height;
}
void x11_make_window_non_resizable(int width, int height) {
XSizeHints *size_hints = XAllocSizeHints();
size_hints->flags = PMinSize | PMaxSize;
size_hints->min_width = width;
size_hints->min_height = height;
size_hints->max_width = width;
size_hints->max_height = height;
XSetWMNormalHints(x11_display, x11_window, size_hints);
XFree(size_hints);
}
////////////////////////////
//
// Zephr
//
///////////////////////////
void zephr_init(const char* font_path, const char* window_title, Size window_size) {
zephr_ctx = malloc(sizeof(ZephrContext));
// TODO: should I initalize the audio here or let the game handle that??
int res = audio_init();
CORE_ASSERT(res == 0, "Failed to initialize audio");
res = x11_init(window_title, window_size.width, window_size.height);
CORE_ASSERT(res == 0, "Failed to initialize X11");
res = init_ui(font_path, (Size){ .width = window_size.width, .height = window_size.height });
CORE_ASSERT(res == 0, "Failed to initialize UI");
x11_get_screen_size(&zephr_ctx->screen_size.width, &zephr_ctx->screen_size.height);
start_internal_timer();
}
void zephr_deinit(void) {
x11_close();
audio_close();
}
bool zephr_should_quit(void) {
CORE_DEBUG_ASSERT(zephr_ctx, "Zephr context not initialized");
glClearColor(0, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
audio_update();
return zephr_ctx->should_quit;
}
// This MUST be called at the end of the frame
void zephr_swap_buffers(void) {
CORE_DEBUG_ASSERT(zephr_ctx, "Zephr context not initialized");
glXSwapBuffers(x11_display, x11_window);
}
Size zephr_get_window_size(void) {
return zephr_ctx->window.size;
}
// This MUST be called after calling init_zephr()
void zephr_make_window_non_resizable(void) {
CORE_DEBUG_ASSERT(zephr_ctx, "Zephr context not initialized");
x11_make_window_non_resizable(zephr_ctx->window.size.width, zephr_ctx->window.size.height);
}
void zephr_toggle_fullscreen(void) {
x11_toggle_fullscreen(zephr_ctx->window.is_fullscreen);
zephr_ctx->window.is_fullscreen = !zephr_ctx->window.is_fullscreen;
}
void zephr_quit(void) {
zephr_ctx->should_quit = true;
}
Color ColorRGBA(u8 r, u8 g, u8 b, u8 a) {
return (Color){ r, g, b, a };
}
ZephrKeyMod zephr_x11_mods_to_zephr_mods(XKeyEvent xkey) {
ZephrKeyMod zephr_mods = 0;
if (xkey.state & ShiftMask) {
if (XLookupKeysym(&xkey, 0) == XK_Shift_L) {
zephr_mods |= ZEPHR_KEY_MOD_LEFT_SHIFT;
} else if (XLookupKeysym(&xkey, 0) == XK_Shift_R) {
zephr_mods |= ZEPHR_KEY_MOD_RIGHT_SHIFT;
} else {
zephr_mods |= ZEPHR_KEY_MOD_SHIFT;
}
}
if (xkey.state & ControlMask){
if (XLookupKeysym(&xkey, 0) == XK_Control_L) {
zephr_mods |= ZEPHR_KEY_MOD_LEFT_CTRL;
} else if (XLookupKeysym(&xkey, 0) == XK_Control_R) {
zephr_mods |= ZEPHR_KEY_MOD_RIGHT_CTRL;
} else {
zephr_mods |= ZEPHR_KEY_MOD_CTRL;
}
}
if (xkey.state & Mod1Mask) {
if (XLookupKeysym(&xkey, 0) == XK_Alt_L) {
zephr_mods |= ZEPHR_KEY_MOD_LEFT_ALT;
} else if (XLookupKeysym(&xkey, 0) == XK_Alt_R) {
zephr_mods |= ZEPHR_KEY_MOD_RIGHT_ALT;
} else {
zephr_mods |= ZEPHR_KEY_MOD_ALT;
}
}
if (xkey.state & Mod4Mask) {
if (XLookupKeysym(&xkey, 0) == XK_Super_L) {
zephr_mods |= ZEPHR_KEY_MOD_LEFT_META;
} else if (XLookupKeysym(&xkey, 0) == XK_Super_R) {
zephr_mods |= ZEPHR_KEY_MOD_RIGHT_META;
} else {
zephr_mods |= ZEPHR_KEY_MOD_META;
}
}
if (xkey.state & LockMask) {
zephr_mods |= ZEPHR_KEY_MOD_CAPS_LOCK;
}
if (xkey.state & Mod2Mask) {
zephr_mods |= ZEPHR_KEY_MOD_NUM_LOCK;
}
return zephr_mods;
}
bool zephr_iter_events(ZephrEvent *event_out) {
XEvent xev;
while (XPending(x11_display)) {
XNextEvent(x11_display, &xev);
if (xev.type == ConfigureNotify) {
XConfigureEvent xce = xev.xconfigure;
if (xce.width != zephr_ctx->window.size.width || xce.height != zephr_ctx->window.size.height) {
zephr_ctx->window.size = (Size){ .width = xce.width, .height = xce.height };
zephr_ctx->projection = orthographic_projection_2d(0.f, xce.width, xce.height, 0.f);
x11_resize_window();
event_out->type = ZEPHR_EVENT_WINDOW_RESIZED;
event_out->window.width = xce.width;
event_out->window.height = xce.height;
return true;
}
} else if (xev.type == DestroyNotify) {
// window destroy event
event_out->type = ZEPHR_EVENT_WINDOW_CLOSED;
return true;
} else if (xev.type == ClientMessage) {
// window close event
if ((Atom)xev.xclient.data.l[0] == zephr_ctx->window_delete_atom) {
event_out->type = ZEPHR_EVENT_WINDOW_CLOSED;
return true;
}
} else if (xev.type == KeyPress) {
XKeyEvent xke = xev.xkey;
u32 evdev_keycode = xke.keycode - 8;
ZephrScancode scancode = zephr_evdev_scancode_to_zephr_scancode_map[evdev_keycode];
event_out->type = ZEPHR_EVENT_KEY_PRESSED;
event_out->key.code = scancode;
event_out->key.mods = zephr_x11_mods_to_zephr_mods(xke);
/* { */
/* // remove the control modifier as it causes control codes to be returned */
/* xev.xkey.state &= ~ControlMask; */
/* char string[4] = {0}; */
/* KeySym keysym = 0; */
/* u8 string_length = Xutf8LookupString(x11_xic, &xev.xkey, string, sizeof(string), &keysym, NULL); */
/* // do not send any keys like ctrl, shift, function, arrow, escape, return, backspace. */
/* // instead, send regular key events. */
/* if (string_length && !(keysym >= 0xfd00 && keysym <= 0xffff)) { */
/* os_event_queue_virt_key_input_utf8(string, string_length); */
/* } */
/* } */
/* // an X11 keycode is conceptually the same as our keycode. */
/* // they are both used to represent a physical key. */
/* // map evdev enumeration to our keycode */
/* u32 evdev_keycode = xev.xkey.keycode - 8; */
/* ZephrKeycode keycode; */
/* if (evdev_keycode < CORE_ARRAY_COUNT(os_linux_keyboard_evdev_keycode_to_keycode_map)) { */
/* keycode = os_linux_keyboard_evdev_keycode_to_keycode_map[evdev_keycode]; */
/* } else { */
/* keycode = ZEPHR_KEYCODE_NULL; */
/* } */
/* os_event_queue_virt_key_changed(xev.type == KeyPress, keycode); */
return true;
} else if (xev.type == KeyRelease) {
XKeyEvent xke = xev.xkey;
unsigned int evdev_keycode = xke.keycode - 8;
ZephrScancode scancode = zephr_evdev_scancode_to_zephr_scancode_map[evdev_keycode];
event_out->type = ZEPHR_EVENT_KEY_RELEASED;
event_out->key.code = scancode;
event_out->key.mods = zephr_x11_mods_to_zephr_mods(xke);
return true;
} else if (xev.type == ButtonPress) {
event_out->type = ZEPHR_EVENT_MOUSE_BUTTON_PRESSED;
event_out->mouse.position = (Vec2){ .x = xev.xbutton.x, .y = xev.xbutton.y };
switch (xev.xbutton.button) {
case Button1:
event_out->mouse.button = ZEPHR_MOUSE_BUTTON_LEFT;
break;
case Button2:
event_out->mouse.button = ZEPHR_MOUSE_BUTTON_MIDDLE;
break;
case Button3:
event_out->mouse.button = ZEPHR_MOUSE_BUTTON_RIGHT;
break;
case Button4:
event_out->type = ZEPHR_EVENT_MOUSE_SCROLL;
event_out->mouse.scroll_direction = ZEPHR_MOUSE_SCROLL_UP;
break;
case Button5:
event_out->type = ZEPHR_EVENT_MOUSE_SCROLL;
event_out->mouse.scroll_direction = ZEPHR_MOUSE_SCROLL_DOWN;
break;
case 8: // Back
event_out->mouse.button = ZEPHR_MOUSE_BUTTON_BACK;
break;
case 9: // Forward
event_out->mouse.button = ZEPHR_MOUSE_BUTTON_FORWARD;
break;
default:
printf("[WARN] Unknown mouse button pressed: %d\n", xev.xbutton.button);
break;
}
return true;
} else if (xev.type == ButtonRelease) {
event_out->type = ZEPHR_EVENT_MOUSE_BUTTON_RELEASED;
event_out->mouse.position = (Vec2){ .x = xev.xbutton.x, .y = xev.xbutton.y };
switch (xev.xbutton.button) {
case Button1:
event_out->mouse.button = ZEPHR_MOUSE_BUTTON_LEFT;
break;
case Button2:
event_out->mouse.button = ZEPHR_MOUSE_BUTTON_MIDDLE;
break;
case Button3:
event_out->mouse.button = ZEPHR_MOUSE_BUTTON_RIGHT;
break;
}
return true;
} else if (xev.type == MappingNotify) {
// input device mapping changed
if (xev.xmapping.request != MappingKeyboard) {
break;
}
XRefreshKeyboardMapping(&xev.xmapping);
/* x11_keyboard_map_update(); */
break;
}
}
return false;
}
/* bool zephr_keyboard_scancode_is_pressed(ZephrScancode scancode) { */
/* return core_bitset_is_set(zephr_ctx.keyboard.scancode_is_pressed_bitset, scancode); */
/* } */
/* bool zephr_keyboard_scancode_has_been_pressed(ZephrScancode scancode) { */
/* return core_bitset_is_set(zephr_ctx.keyboard.scancode_has_been_pressed_bitset, scancode); */
/* } */
/* bool zephr_keyboard_scancode_has_been_released(ZephrScancode scancode) { */
/* return core_bitset_is_set(zephr_ctx.keyboard.scancode_has_been_released_bitset, scancode); */
/* } */
/* bool zephr_keyboard_keycode_is_pressed(ZephrKeycode keycode) { */
/* return core_bitset_is_set(zephr_ctx.keyboard.keycode_is_pressed_bitset, keycode); */
/* } */
/* bool zephr_keyboard_keycode_has_been_pressed(ZephrKeycode keycode) { */
/* return core_bitset_is_set(zephr_ctx.keyboard.keycode_has_been_pressed_bitset, keycode); */
/* } */
/* bool zephr_keyboard_keycode_has_been_released(ZephrKeycode keycode) { */
/* return core_bitset_is_set(zephr_ctx.keyboard.keycode_has_been_released_bitset, keycode); */
/* } */
/* ZephrScancode zephr_keyboard_keycode_to_scancode(ZephrKeycode keycode) { */
/* return zephr_ctx.keyboard.keycode_to_scancode[keycode]; */
/* } */
/* ZephrKeycode zephr_keyboard_scancode_to_keycode(ZephrScancode scancode) { */
/* return zephr_ctx.keyboard.scancode_to_keycode[scancode]; */
/* } */
zephr.h
+387
View File
@@ -0,0 +1,387 @@
#pragma once
#include <stdbool.h>
#include <stdint.h>
#include <X11/XKBlib.h>
#include "text.h"
#include "zephr_math.h"
#define COLOR_BLACK (Color){0, 0, 0, 255}
#define COLOR_WHITE (Color){255, 255, 255, 255}
#define COLOR_RED (Color){255, 0, 0, 255}
#define COLOR_GREEN (Color){0, 255, 0, 255}
#define COLOR_BLUE (Color){0, 0, 255, 255}
#define COLOR_YELLOW (Color){255, 255, 0, 255}
#define COLOR_MAGENTA (Color){255, 0, 255, 255}
#define COLOR_CYAN (Color){0, 255, 255, 255}
#define COLOR_ORANGE (Color){255, 128, 0, 255}
#define COLOR_PURPLE (Color){128, 0, 255, 255}
typedef struct ZephrWindow {
Size size;
bool is_fullscreen;
} ZephrWindow;
typedef enum ZephrEventType {
ZEPHR_EVENT_UNKNOWN,
ZEPHR_EVENT_KEY_PRESSED,
ZEPHR_EVENT_KEY_RELEASED,
ZEPHR_EVENT_MOUSE_BUTTON_PRESSED,
ZEPHR_EVENT_MOUSE_BUTTON_RELEASED,
ZEPHR_EVENT_MOUSE_SCROLL,
ZEPHR_EVENT_WINDOW_RESIZED,
ZEPHR_EVENT_WINDOW_CLOSED
} ZephrEventType;
typedef enum ZephrMouseScrollDirection {
ZEPHR_MOUSE_SCROLL_UP,
ZEPHR_MOUSE_SCROLL_DOWN,
} ZephrMouseScrollDirection;
typedef enum ZephrMouseButton {
ZEPHR_MOUSE_BUTTON_LEFT,
ZEPHR_MOUSE_BUTTON_RIGHT,
ZEPHR_MOUSE_BUTTON_MIDDLE,
ZEPHR_MOUSE_BUTTON_BACK,
ZEPHR_MOUSE_BUTTON_FORWARD,
ZEPHR_MOUSE_BUTTON_3,
ZEPHR_MOUSE_BUTTON_4,
ZEPHR_MOUSE_BUTTON_5,
ZEPHR_MOUSE_BUTTON_6,
ZEPHR_MOUSE_BUTTON_7,
} ZephrMouseButton;
typedef u16 ZephrScancode;
typedef u16 ZephrKeycode;
// these are actually scancodes as documented by the USB HID Usage Tables
// https://usb.org/sites/default/files/documents/hut1_12v2.pdf
enum {
ZEPHR_KEYCODE_NULL = 0,
ZEPHR_KEYCODE_A = 4,
ZEPHR_KEYCODE_B = 5,
ZEPHR_KEYCODE_C = 6,
ZEPHR_KEYCODE_D = 7,
ZEPHR_KEYCODE_E = 8,
ZEPHR_KEYCODE_F = 9,
ZEPHR_KEYCODE_G = 10,
ZEPHR_KEYCODE_H = 11,
ZEPHR_KEYCODE_I = 12,
ZEPHR_KEYCODE_J = 13,
ZEPHR_KEYCODE_K = 14,
ZEPHR_KEYCODE_L = 15,
ZEPHR_KEYCODE_M = 16,
ZEPHR_KEYCODE_N = 17,
ZEPHR_KEYCODE_O = 18,
ZEPHR_KEYCODE_P = 19,
ZEPHR_KEYCODE_Q = 20,
ZEPHR_KEYCODE_R = 21,
ZEPHR_KEYCODE_S = 22,
ZEPHR_KEYCODE_T = 23,
ZEPHR_KEYCODE_U = 24,
ZEPHR_KEYCODE_V = 25,
ZEPHR_KEYCODE_W = 26,
ZEPHR_KEYCODE_X = 27,
ZEPHR_KEYCODE_Y = 28,
ZEPHR_KEYCODE_Z = 29,
ZEPHR_KEYCODE_1 = 30,
ZEPHR_KEYCODE_2 = 31,
ZEPHR_KEYCODE_3 = 32,
ZEPHR_KEYCODE_4 = 33,
ZEPHR_KEYCODE_5 = 34,
ZEPHR_KEYCODE_6 = 35,
ZEPHR_KEYCODE_7 = 36,
ZEPHR_KEYCODE_8 = 37,
ZEPHR_KEYCODE_9 = 38,
ZEPHR_KEYCODE_0 = 39,
ZEPHR_KEYCODE_ENTER = 40,
ZEPHR_KEYCODE_ESCAPE = 41,
ZEPHR_KEYCODE_BACKSPACE = 42,
ZEPHR_KEYCODE_TAB = 43,
ZEPHR_KEYCODE_SPACE = 44,
ZEPHR_KEYCODE_MINUS = 45,
ZEPHR_KEYCODE_EQUALS = 46,
ZEPHR_KEYCODE_LEFT_BRACKET = 47,
ZEPHR_KEYCODE_RIGHT_BRACKET = 48,
ZEPHR_KEYCODE_BACKSLASH = 49,
ZEPHR_KEYCODE_NON_US_HASH = 50,
ZEPHR_KEYCODE_SEMICOLON = 51,
ZEPHR_KEYCODE_APOSTROPHE = 52,
ZEPHR_KEYCODE_GRAVE = 53,
ZEPHR_KEYCODE_COMMA = 54,
ZEPHR_KEYCODE_PERIOD = 55,
ZEPHR_KEYCODE_SLASH = 56,
ZEPHR_KEYCODE_CAPS_LOCK = 57,
ZEPHR_KEYCODE_F1 = 58,
ZEPHR_KEYCODE_F2 = 59,
ZEPHR_KEYCODE_F3 = 60,
ZEPHR_KEYCODE_F4 = 61,
ZEPHR_KEYCODE_F5 = 62,
ZEPHR_KEYCODE_F6 = 63,
ZEPHR_KEYCODE_F7 = 64,
ZEPHR_KEYCODE_F8 = 65,
ZEPHR_KEYCODE_F9 = 66,
ZEPHR_KEYCODE_F10 = 67,
ZEPHR_KEYCODE_F11 = 68,
ZEPHR_KEYCODE_F12 = 69,
ZEPHR_KEYCODE_PRINT_SCREEN = 70,
ZEPHR_KEYCODE_SCROLL_LOCK = 71,
ZEPHR_KEYCODE_PAUSE = 72,
ZEPHR_KEYCODE_INSERT = 73,
ZEPHR_KEYCODE_HOME = 74,
ZEPHR_KEYCODE_PAGE_UP = 75,
ZEPHR_KEYCODE_DELETE = 76,
ZEPHR_KEYCODE_END = 77,
ZEPHR_KEYCODE_PAGE_DOWN = 78,
ZEPHR_KEYCODE_RIGHT = 79,
ZEPHR_KEYCODE_LEFT = 80,
ZEPHR_KEYCODE_DOWN = 81,
ZEPHR_KEYCODE_UP = 82,
ZEPHR_KEYCODE_NUM_LOCK_OR_CLEAR = 83,
ZEPHR_KEYCODE_KP_DIVIDE = 84,
ZEPHR_KEYCODE_KP_MULTIPLY = 85,
ZEPHR_KEYCODE_KP_MINUS = 86,
ZEPHR_KEYCODE_KP_PLUS = 87,
ZEPHR_KEYCODE_KP_ENTER = 88,
ZEPHR_KEYCODE_KP_1 = 89,
ZEPHR_KEYCODE_KP_2 = 90,
ZEPHR_KEYCODE_KP_3 = 91,
ZEPHR_KEYCODE_KP_4 = 92,
ZEPHR_KEYCODE_KP_5 = 93,
ZEPHR_KEYCODE_KP_6 = 94,
ZEPHR_KEYCODE_KP_7 = 95,
ZEPHR_KEYCODE_KP_8 = 96,
ZEPHR_KEYCODE_KP_9 = 97,
ZEPHR_KEYCODE_KP_0 = 98,
ZEPHR_KEYCODE_KP_PERIOD = 99,
ZEPHR_KEYCODE_NON_US_BACKSLASH = 100,
ZEPHR_KEYCODE_APPLICATION = 101,
ZEPHR_KEYCODE_POWER = 102,
ZEPHR_KEYCODE_KP_EQUALS = 103,
ZEPHR_KEYCODE_F13 = 104,
ZEPHR_KEYCODE_F14 = 105,
ZEPHR_KEYCODE_F15 = 106,
ZEPHR_KEYCODE_F16 = 107,
ZEPHR_KEYCODE_F17 = 108,
ZEPHR_KEYCODE_F18 = 109,
ZEPHR_KEYCODE_F19 = 110,
ZEPHR_KEYCODE_F20 = 111,
ZEPHR_KEYCODE_F21 = 112,
ZEPHR_KEYCODE_F22 = 113,
ZEPHR_KEYCODE_F23 = 114,
ZEPHR_KEYCODE_F24 = 115,
ZEPHR_KEYCODE_EXECUTE = 116,
ZEPHR_KEYCODE_HELP = 117,
ZEPHR_KEYCODE_MENU = 118,
ZEPHR_KEYCODE_SELECT = 119,
ZEPHR_KEYCODE_STOP = 120,
ZEPHR_KEYCODE_AGAIN = 121,
ZEPHR_KEYCODE_UNDO = 122,
ZEPHR_KEYCODE_CUT = 123,
ZEPHR_KEYCODE_COPY = 124,
ZEPHR_KEYCODE_PASTE = 125,
ZEPHR_KEYCODE_FIND = 126,
ZEPHR_KEYCODE_MUTE = 127,
ZEPHR_KEYCODE_VOLUME_UP = 128,
ZEPHR_KEYCODE_VOLUME_DOWN = 129,
ZEPHR_KEYCODE_KP_COMMA = 133,
ZEPHR_KEYCODE_KP_EQUALSAS400 = 134,
ZEPHR_KEYCODE_INTERNATIONAL1 = 135,
ZEPHR_KEYCODE_INTERNATIONAL2 = 136,
ZEPHR_KEYCODE_INTERNATIONAL3 = 137,
ZEPHR_KEYCODE_INTERNATIONAL4 = 138,
ZEPHR_KEYCODE_INTERNATIONAL5 = 139,
ZEPHR_KEYCODE_INTERNATIONAL6 = 140,
ZEPHR_KEYCODE_INTERNATIONAL7 = 141,
ZEPHR_KEYCODE_INTERNATIONAL8 = 142,
ZEPHR_KEYCODE_INTERNATIONAL9 = 143,
ZEPHR_KEYCODE_LANG1 = 144,
ZEPHR_KEYCODE_LANG2 = 145,
ZEPHR_KEYCODE_LANG3 = 146,
ZEPHR_KEYCODE_LANG4 = 147,
ZEPHR_KEYCODE_LANG5 = 148,
ZEPHR_KEYCODE_LANG6 = 149,
ZEPHR_KEYCODE_LANG7 = 150,
ZEPHR_KEYCODE_LANG8 = 151,
ZEPHR_KEYCODE_LANG9 = 152,
ZEPHR_KEYCODE_ALT_ERASE = 153,
ZEPHR_KEYCODE_SYSREQ = 154,
ZEPHR_KEYCODE_CANCEL = 155,
ZEPHR_KEYCODE_CLEAR = 156,
ZEPHR_KEYCODE_PRIOR = 157,
ZEPHR_KEYCODE_ENTER_2 = 158,
ZEPHR_KEYCODE_SEPARATOR = 159,
ZEPHR_KEYCODE_OUT = 160,
ZEPHR_KEYCODE_OPER = 161,
ZEPHR_KEYCODE_CLEARAGAIN = 162,
ZEPHR_KEYCODE_CRSEL = 163,
ZEPHR_KEYCODE_EXSEL = 164,
ZEPHR_KEYCODE_KP_00 = 176,
ZEPHR_KEYCODE_KP_000 = 177,
ZEPHR_KEYCODE_THOUSANDSSEPARATOR = 178,
ZEPHR_KEYCODE_DECIMALSEPARATOR = 179,
ZEPHR_KEYCODE_CURRENCYUNIT = 180,
ZEPHR_KEYCODE_CURRENCYSUBUNIT = 181,
ZEPHR_KEYCODE_KP_LEFT_PAREN = 182,
ZEPHR_KEYCODE_KP_RIGHT_PAREN = 183,
ZEPHR_KEYCODE_KP_LEFT_BRACE = 184,
ZEPHR_KEYCODE_KP_RIGHT_BRACE = 185,
ZEPHR_KEYCODE_KP_TAB = 186,
ZEPHR_KEYCODE_KP_BACKSPACE = 187,
ZEPHR_KEYCODE_KP_A = 188,
ZEPHR_KEYCODE_KP_B = 189,
ZEPHR_KEYCODE_KP_C = 190,
ZEPHR_KEYCODE_KP_D = 191,
ZEPHR_KEYCODE_KP_E = 192,
ZEPHR_KEYCODE_KP_F = 193,
ZEPHR_KEYCODE_KP_XOR = 194,
ZEPHR_KEYCODE_KP_POWER = 195,
ZEPHR_KEYCODE_KP_PERCENT = 196,
ZEPHR_KEYCODE_KP_LESS = 197,
ZEPHR_KEYCODE_KP_GREATER = 198,
ZEPHR_KEYCODE_KP_AMPERSAND = 199,
ZEPHR_KEYCODE_KP_DBLAMPERSAND = 200,
ZEPHR_KEYCODE_KP_VERTICALBAR = 201,
ZEPHR_KEYCODE_KP_DBLVERTICALBAR = 202,
ZEPHR_KEYCODE_KP_COLON = 203,
ZEPHR_KEYCODE_KP_HASH = 204,
ZEPHR_KEYCODE_KP_SPACE = 205,
ZEPHR_KEYCODE_KP_AT = 206,
ZEPHR_KEYCODE_KP_EXCLAM = 207,
ZEPHR_KEYCODE_KP_MEMSTORE = 208,
ZEPHR_KEYCODE_KP_MEMRECALL = 209,
ZEPHR_KEYCODE_KP_MEMCLEAR = 210,
ZEPHR_KEYCODE_KP_MEMADD = 211,
ZEPHR_KEYCODE_KP_MEMSUBTRACT = 212,
ZEPHR_KEYCODE_KP_MEMMULTIPLY = 213,
ZEPHR_KEYCODE_KP_MEMDIVIDE = 214,
ZEPHR_KEYCODE_KP_PLUS_MINUS = 215,
ZEPHR_KEYCODE_KP_CLEAR = 216,
ZEPHR_KEYCODE_KP_CLEARENTRY = 217,
ZEPHR_KEYCODE_KP_BINARY = 218,
ZEPHR_KEYCODE_KP_OCTAL = 219,
ZEPHR_KEYCODE_KP_DECIMAL = 220,
ZEPHR_KEYCODE_KP_HEXADECIMAL = 221,
ZEPHR_KEYCODE_LEFT_CTRL = 224,
ZEPHR_KEYCODE_LEFT_SHIFT = 225,
ZEPHR_KEYCODE_LEFT_ALT = 226,
ZEPHR_KEYCODE_LEFT_META = 227,
ZEPHR_KEYCODE_RIGHT_CTRL = 228,
ZEPHR_KEYCODE_RIGHT_SHIFT = 229,
ZEPHR_KEYCODE_RIGHT_ALT = 230,
ZEPHR_KEYCODE_RIGHT_META = 231,
/** Not a key. Marks the number of scancodes. */
ZEPHR_KEYCODE_COUNT = 512,
};
typedef enum ZephrKeyMod {
ZEPHR_KEY_MOD_NONE = 0x0000,
ZEPHR_KEY_MOD_LEFT_SHIFT = 0x0001,
ZEPHR_KEY_MOD_RIGHT_SHIFT = 0x0002,
ZEPHR_KEY_MOD_SHIFT = 0x0003,
ZEPHR_KEY_MOD_LEFT_CTRL = 0x0040,
ZEPHR_KEY_MOD_RIGHT_CTRL = 0x0080,
ZEPHR_KEY_MOD_CTRL = 0x00C0,
ZEPHR_KEY_MOD_LEFT_ALT = 0x0100,
ZEPHR_KEY_MOD_RIGHT_ALT = 0x0200,
ZEPHR_KEY_MOD_ALT = 0x0300,
ZEPHR_KEY_MOD_LEFT_META = 0x0400,
ZEPHR_KEY_MOD_RIGHT_META = 0x0800,
ZEPHR_KEY_MOD_META = 0x0C00,
ZEPHR_KEY_MOD_CAPS_LOCK = 0x1000,
ZEPHR_KEY_MOD_NUM_LOCK = 0x2000,
} ZephrKeyMod;
typedef struct ZephrKeyboard {
ZephrKeycode scancode_to_keycode[ZEPHR_KEYCODE_COUNT];
ZephrScancode keycode_to_scancode[ZEPHR_KEYCODE_COUNT];
/* u64 scancode_is_pressed_bitset[CORE_DIV_ROUND_UP(ZEPHR_KEYCODE_COUNT, 64)]; */
/* u64 scancode_has_been_pressed_bitset[CORE_DIV_ROUND_UP(ZEPHR_KEYCODE_COUNT, 64)]; */
/* u64 scancode_has_been_released_bitset[CORE_DIV_ROUND_UP(ZEPHR_KEYCODE_COUNT, 64)]; */
/* u64 keycode_is_pressed_bitset[CORE_DIV_ROUND_UP(ZEPHR_KEYCODE_COUNT, 64)]; */
/* u64 keycode_has_been_pressed_bitset[CORE_DIV_ROUND_UP(ZEPHR_KEYCODE_COUNT, 64)]; */
/* u64 keycode_has_been_released_bitset[CORE_DIV_ROUND_UP(ZEPHR_KEYCODE_COUNT, 64)]; */
} ZephrKeyboard;
typedef struct ZephrEvent {
ZephrEventType type;
union {
struct {
bool is_pressed;
bool is_repeat;
ZephrScancode scancode;
ZephrKeycode code;
ZephrKeyMod mods;
} key;
struct {
ZephrMouseButton button;
Vec2 position;
ZephrMouseScrollDirection scroll_direction;
} mouse;
struct {
u32 width;
u32 height;
} window;
};
} ZephrEvent;
/* CORE_DEFINE_STACK(ZephrEvent); */
typedef struct ZephrContext {
Atom window_delete_atom;
bool should_quit;
Size screen_size;
ZephrWindow window;
ZephrFont font;
/* ZephrKeyboard keyboard; */
/* XkbDescPtr xkb; */
/* XIM xim; */
/* CoreStack(ZephrEvent) event_queue; */
/* u32 event_queue_cursor; */
Matrix4x4 projection;
} ZephrContext;
void zephr_init(const char* font_path, const char* window_title, Size window_size);
void zephr_deinit(void);
bool zephr_should_quit(void);
void zephr_swap_buffers(void);
Size zephr_get_window_size(void);
void zephr_make_window_non_resizable(void);
void zephr_toggle_fullscreen(void);
void zephr_quit(void);
Color ColorRGBA(u8 r, u8 g, u8 b, u8 a);
bool zephr_iter_events(ZephrEvent *event_out);
/* bool zephr_keyboard_keycode_is_pressed(ZephrKeycode keycode); */
/* bool zephr_keyboard_keycode_has_been_pressed(ZephrKeycode keycode); */
/* bool zephr_keyboard_keycode_has_been_released(ZephrKeycode keycode); */
/* ZephrScancode zephr_keyboard_keycode_to_scancode(ZephrKeycode keycode); */
/* ZephrKeycode zephr_keyboard_scancode_to_keycode(ZephrScancode scancode); */
extern ZephrContext *zephr_ctx;
zephr_math.c
+86
View File
@@ -0,0 +1,86 @@
#include <math.h>
#include "zephr_math.h"
float to_radians(float degrees) {
return degrees * ((float)M_PI / 180.f);
}
Matrix4x4 orthographic_projection_2d(float left, float right, float bottom, float top) {
Matrix4x4 result = identity();
result.m[0][0] = 2.0f / (right - left);
result.m[3][0] = -(right + left) / (right - left);
result.m[1][1] = 2.0f / (top - bottom);
result.m[3][1] = -(top + bottom) / (top - bottom);
result.m[2][2] = -1.0f;
result.m[3][3] = 1.0f;
return result;
}
Matrix4x4 identity(void) {
Matrix4x4 result = {0};
result.m[0][0] = 1.0f;
result.m[1][1] = 1.0f;
result.m[2][2] = 1.0f;
result.m[3][3] = 1.0f;
return result;
}
void mult_4x4(Matrix4x4 *multiplicant, Matrix4x4 *multiplier) {
Matrix4x4 result = identity();
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
result.m[i][j] = 0;
for (int k = 0; k < 4; k++) {
result.m[i][j] += multiplicant->m[i][k] * multiplier->m[k][j];
}
}
}
*multiplicant = result;
}
void apply_scale(Matrix4x4 *matrix, Sizef scale) {
Matrix4x4 temp = identity();
temp.m[0][0] = scale.width;
temp.m[1][1] = scale.height;
mult_4x4(matrix, &temp);
}
void apply_rotation(Matrix4x4 *model, float angle) {
Matrix4x4 temp = identity();
temp.m[0][0] = (float)cos(angle);
temp.m[0][1] = (float)sin(angle);
temp.m[1][0] = -(float)sin(angle);
temp.m[1][1] = (float)cos(angle);
mult_4x4(model, &temp);
}
void apply_translation(Matrix4x4 *matrix, Vec2f pos) {
Matrix4x4 temp = identity();
temp.m[3][0] = pos.x;
temp.m[3][1] = pos.y;
mult_4x4(matrix, &temp);
}
Color mul_color(Color color, float amount) {
Color result = color;
result.r = CORE_CLAMP((u8)((float)result.r * amount), 0, 255);
result.g = CORE_CLAMP((u8)((float)result.g * amount), 0, 255);
result.b = CORE_CLAMP((u8)((float)result.b * amount), 0, 255);
return result;
}
zephr_math.h
+57
View File
@@ -0,0 +1,57 @@
#pragma once
#include "core.h"
typedef struct {
float m[4][4];
} Matrix4x4;
typedef struct Size {
int width;
int height;
} Size;
typedef struct Sizef {
float width;
float height;
} Sizef;
typedef struct Vec2 {
int x;
int y;
} Vec2;
typedef struct Vec2f {
float x;
float y;
} Vec2f;
typedef struct Vec4f {
float x;
float y;
float z;
float w;
} Vec4f;
typedef struct Color {
u8 r;
u8 g;
u8 b;
u8 a;
} Color;
typedef struct Colorf {
f32 r;
f32 g;
f32 b;
f32 a;
} Colorf;
float to_radians(float degrees);
Matrix4x4 identity(void);
void mult_4x4(Matrix4x4 *multiplicant, Matrix4x4 *multiplier);
void apply_scale(Matrix4x4 *matrix, Sizef scale);
void apply_rotation(Matrix4x4 *model, float angle);
void apply_translation(Matrix4x4 *matrix, Vec2f pos);
Matrix4x4 orthographic_projection_2d(float left, float right, float bottom, float top);
Color mul_color(Color color, float amount);