Merge branch 'master' into particles

Conflicts:
	src/GameWorld.cpp
	vs11/Returngeance/Returngeance.vcxproj
	vs11/Returngeance/Returngeance.vcxproj.filters

.gitattributes

@@ -0,0 +1,63 @@
+###############################################################################
+# Set default behavior to automatically normalize line endings.
+###############################################################################
+* text=auto
+
+###############################################################################
+# Set default behavior for command prompt diff.
+#
+# This is need for earlier builds of msysgit that does not have it on by
+# default for csharp files.
+# Note: This is only used by command line
+###############################################################################
+#*.cs     diff=csharp
+
+###############################################################################
+# Set the merge driver for project and solution files
+#
+# Merging from the command prompt will add diff markers to the files if there
+# are conflicts (Merging from VS is not affected by the settings below, in VS
+# the diff markers are never inserted). Diff markers may cause the following 
+# file extensions to fail to load in VS. An alternative would be to treat
+# these files as binary and thus will always conflict and require user
+# intervention with every merge. To do so, just uncomment the entries below
+###############################################################################
+#*.sln       merge=binary
+#*.csproj    merge=binary
+#*.vbproj    merge=binary
+#*.vcxproj   merge=binary
+#*.vcproj    merge=binary
+#*.dbproj    merge=binary
+#*.fsproj    merge=binary
+#*.lsproj    merge=binary
+#*.wixproj   merge=binary
+#*.modelproj merge=binary
+#*.sqlproj   merge=binary
+#*.wwaproj   merge=binary
+
+###############################################################################
+# behavior for image files
+#
+# image files are treated as binary by default.
+###############################################################################
+#*.jpg   binary
+#*.png   binary
+#*.gif   binary
+
+###############################################################################
+# diff behavior for common document formats
+# 
+# Convert binary document formats to text before diffing them. This feature
+# is only available from the command line. Turn it on by uncommenting the 
+# entries below.
+###############################################################################
+#*.doc   diff=astextplain
+#*.DOC   diff=astextplain
+#*.docx  diff=astextplain
+#*.DOCX  diff=astextplain
+#*.dot   diff=astextplain
+#*.DOT   diff=astextplain
+#*.pdf   diff=astextplain
+#*.PDF   diff=astextplain
+#*.rtf   diff=astextplain
+#*.RTF   diff=astextplain

.gitignore

@@ -29,6 +29,6 @@ ipch/
 [Dd]ebug*/
 [Rr]elease*/
 Ankh.NoLoad
+*.orig
 
-assets/
 !libs/*.lib

.gitmodules

@@ -0,0 +1,4 @@
+[submodule "assets"]
+	path = assets
+	url = returngeance@shard.imon.nu:Assets
+	branch = master

deploy.bat

@@ -15,12 +15,12 @@ MKLINK "%ConfigPath%\Sounds\" "assets\Sounds\" /J
 :: Shaders
 MKLINK "%ConfigPath%\Shaders\" "src\Shaders\" /J
 :: DLLs
-MKLINK "%ConfigPath%\glfw3.dll" "libs\glfw-3.0.4\lib\%Configuration%\glfw3.dll" /H
-MKLINK "%ConfigPath%\OpenAL32.dll" "libs\openal-soft-1.15.1\lib\Win32\%Configuration%\OpenAL32.dll" /H
+COPY "libs\glfw-3.0.4\lib\%Configuration%\glfw3.dll" "%ConfigPath%\glfw3.dll"
+COPY "libs\FMOD\lib\fmodex.dll" "%ConfigPath%\fmodex.dll"
 IF %~1==Debug (
-	MKLINK "%ConfigPath%\glew32d.dll" "libs\glew-1.10.0\bin\%Configuration%\Win32\glew32d.dll" /H
+	COPY "libs\glew-1.10.0\bin\%Configuration%\Win32\glew32d.dll" "%ConfigPath%\glew32d.dll"
 )
 IF %~1==Release (
-	MKLINK "%ConfigPath%\glew32.dll" "libs\glew-1.10.0\bin\%Configuration%\Win32\glew32.dll" /H
+	COPY "libs\glew-1.10.0\bin\%Configuration%\Win32\glew32.dll" "%ConfigPath%\glew32.dll"
 )
 GOTO:eof

libs/FMOD/inc/fmod.hpp

@@ -0,0 +1,608 @@
+/* ========================================================================================== */
+/* FMOD Ex - C++ header file. Copyright (c), Firelight Technologies Pty, Ltd. 2004-2014.      */
+/*                                                                                            */
+/* Use this header in conjunction with fmod.h (which contains all the constants / callbacks)  */
+/* to develop using C++ classes.                                                              */
+/* ========================================================================================== */
+
+#ifndef _FMOD_HPP
+#define _FMOD_HPP
+
+#include "fmod.h"
+
+/*
+    Constant and defines
+*/
+
+/*
+    FMOD Namespace
+*/
+namespace FMOD
+{
+    class System;
+    class Sound;
+    class Channel;
+    class ChannelGroup;
+    class SoundGroup;
+    class Reverb;
+    class DSP;
+    class DSPConnection;
+    class Geometry;
+
+    /*
+        FMOD global system functions (optional).
+    */
+    inline FMOD_RESULT Memory_Initialize(void *poolmem, int poollen, FMOD_MEMORY_ALLOCCALLBACK useralloc, FMOD_MEMORY_REALLOCCALLBACK userrealloc, FMOD_MEMORY_FREECALLBACK userfree, FMOD_MEMORY_TYPE memtypeflags = FMOD_MEMORY_ALL) { return FMOD_Memory_Initialize(poolmem, poollen, useralloc, userrealloc, userfree, memtypeflags); }
+    inline FMOD_RESULT Memory_GetStats  (int *currentalloced, int *maxalloced, bool blocking = true) { return FMOD_Memory_GetStats(currentalloced, maxalloced, blocking); }
+    inline FMOD_RESULT Debug_SetLevel(FMOD_DEBUGLEVEL level)  { return FMOD_Debug_SetLevel(level); }
+    inline FMOD_RESULT Debug_GetLevel(FMOD_DEBUGLEVEL *level) { return FMOD_Debug_GetLevel(level); }
+    inline FMOD_RESULT File_SetDiskBusy(int busy) { return FMOD_File_SetDiskBusy(busy); }
+    inline FMOD_RESULT File_GetDiskBusy(int *busy) { return FMOD_File_GetDiskBusy(busy); }
+
+    /*
+        FMOD System factory functions.
+    */
+    inline FMOD_RESULT System_Create(System **system) { return FMOD_System_Create((FMOD_SYSTEM **)system); }
+
+    /*
+       'System' API
+    */
+
+    class System
+    {
+      private:
+
+        System();   /* Constructor made private so user cannot statically instance a System class.  
+                       System_Create must be used. */
+      public:
+
+        FMOD_RESULT F_API release                ();
+                                                 
+        // Pre-init functions.
+        FMOD_RESULT F_API setOutput              (FMOD_OUTPUTTYPE output);
+        FMOD_RESULT F_API getOutput              (FMOD_OUTPUTTYPE *output);
+        FMOD_RESULT F_API getNumDrivers          (int *numdrivers);
+        FMOD_RESULT F_API getDriverInfo          (int id, char *name, int namelen, FMOD_GUID *guid);
+        FMOD_RESULT F_API getDriverInfoW         (int id, short *name, int namelen, FMOD_GUID *guid);
+        FMOD_RESULT F_API getDriverCaps          (int id, FMOD_CAPS *caps, int *controlpaneloutputrate, FMOD_SPEAKERMODE *controlpanelspeakermode);
+        FMOD_RESULT F_API setDriver              (int driver);
+        FMOD_RESULT F_API getDriver              (int *driver);
+        FMOD_RESULT F_API setHardwareChannels    (int numhardwarechannels);
+        FMOD_RESULT F_API setSoftwareChannels    (int numsoftwarechannels);
+        FMOD_RESULT F_API getSoftwareChannels    (int *numsoftwarechannels);
+        FMOD_RESULT F_API setSoftwareFormat      (int samplerate, FMOD_SOUND_FORMAT format, int numoutputchannels, int maxinputchannels, FMOD_DSP_RESAMPLER resamplemethod);
+        FMOD_RESULT F_API getSoftwareFormat      (int *samplerate, FMOD_SOUND_FORMAT *format, int *numoutputchannels, int *maxinputchannels, FMOD_DSP_RESAMPLER *resamplemethod, int *bits);
+        FMOD_RESULT F_API setDSPBufferSize       (unsigned int bufferlength, int numbuffers);
+        FMOD_RESULT F_API getDSPBufferSize       (unsigned int *bufferlength, int *numbuffers);
+        FMOD_RESULT F_API setFileSystem          (FMOD_FILE_OPENCALLBACK useropen, FMOD_FILE_CLOSECALLBACK userclose, FMOD_FILE_READCALLBACK userread, FMOD_FILE_SEEKCALLBACK userseek, FMOD_FILE_ASYNCREADCALLBACK userasyncread, FMOD_FILE_ASYNCCANCELCALLBACK userasynccancel, int blockalign);
+        FMOD_RESULT F_API attachFileSystem       (FMOD_FILE_OPENCALLBACK useropen, FMOD_FILE_CLOSECALLBACK userclose, FMOD_FILE_READCALLBACK userread, FMOD_FILE_SEEKCALLBACK userseek);
+        FMOD_RESULT F_API setAdvancedSettings    (FMOD_ADVANCEDSETTINGS *settings);
+        FMOD_RESULT F_API getAdvancedSettings    (FMOD_ADVANCEDSETTINGS *settings);
+        FMOD_RESULT F_API setSpeakerMode         (FMOD_SPEAKERMODE speakermode);
+        FMOD_RESULT F_API getSpeakerMode         (FMOD_SPEAKERMODE *speakermode);
+        FMOD_RESULT F_API setCallback            (FMOD_SYSTEM_CALLBACK callback);
+                                                
+        // Plug-in support                       
+        FMOD_RESULT F_API setPluginPath          (const char *path);
+        FMOD_RESULT F_API loadPlugin             (const char *filename, unsigned int *handle, unsigned int priority = 0);
+        FMOD_RESULT F_API unloadPlugin           (unsigned int handle);
+        FMOD_RESULT F_API getNumPlugins          (FMOD_PLUGINTYPE plugintype, int *numplugins);
+        FMOD_RESULT F_API getPluginHandle        (FMOD_PLUGINTYPE plugintype, int index, unsigned int *handle);
+        FMOD_RESULT F_API getPluginInfo          (unsigned int handle, FMOD_PLUGINTYPE *plugintype, char *name, int namelen, unsigned int *version);
+        FMOD_RESULT F_API setOutputByPlugin      (unsigned int handle);
+        FMOD_RESULT F_API getOutputByPlugin      (unsigned int *handle);
+        FMOD_RESULT F_API createDSPByPlugin      (unsigned int handle, DSP **dsp);
+        FMOD_RESULT F_API registerCodec          (FMOD_CODEC_DESCRIPTION *description, unsigned int *handle, unsigned int priority = 0);
+        FMOD_RESULT F_API registerDSP            (FMOD_DSP_DESCRIPTION *description, unsigned int *handle);
+                                                 
+        // Init/Close                            
+        FMOD_RESULT F_API init                   (int maxchannels, FMOD_INITFLAGS flags, void *extradriverdata);
+        FMOD_RESULT F_API close                  ();
+                                                 
+        // General post-init system functions    
+        FMOD_RESULT F_API update                 ();        /* IMPORTANT! CALL THIS ONCE PER FRAME! */
+                                                 
+        FMOD_RESULT F_API set3DSettings          (float dopplerscale, float distancefactor, float rolloffscale);
+        FMOD_RESULT F_API get3DSettings          (float *dopplerscale, float *distancefactor, float *rolloffscale);
+        FMOD_RESULT F_API set3DNumListeners      (int numlisteners);
+        FMOD_RESULT F_API get3DNumListeners      (int *numlisteners);
+        FMOD_RESULT F_API set3DListenerAttributes(int listener, const FMOD_VECTOR *pos, const FMOD_VECTOR *vel, const FMOD_VECTOR *forward, const FMOD_VECTOR *up);
+        FMOD_RESULT F_API get3DListenerAttributes(int listener, FMOD_VECTOR *pos, FMOD_VECTOR *vel, FMOD_VECTOR *forward, FMOD_VECTOR *up);
+        FMOD_RESULT F_API set3DRolloffCallback   (FMOD_3D_ROLLOFFCALLBACK callback);
+        FMOD_RESULT F_API set3DSpeakerPosition   (FMOD_SPEAKER speaker, float x, float y, bool active);
+        FMOD_RESULT F_API get3DSpeakerPosition   (FMOD_SPEAKER speaker, float *x, float *y, bool *active);
+
+        FMOD_RESULT F_API setStreamBufferSize    (unsigned int filebuffersize, FMOD_TIMEUNIT filebuffersizetype);
+        FMOD_RESULT F_API getStreamBufferSize    (unsigned int *filebuffersize, FMOD_TIMEUNIT *filebuffersizetype);
+                                                
+        // System information functions.        
+        FMOD_RESULT F_API getVersion             (unsigned int *version);
+        FMOD_RESULT F_API getOutputHandle        (void **handle);
+        FMOD_RESULT F_API getChannelsPlaying     (int *channels);
+        FMOD_RESULT F_API getHardwareChannels    (int *numhardwarechannels);
+        FMOD_RESULT F_API getCPUUsage            (float *dsp, float *stream, float *geometry, float *update, float *total);
+        FMOD_RESULT F_API getSoundRAM            (int *currentalloced, int *maxalloced, int *total);
+        FMOD_RESULT F_API getNumCDROMDrives      (int *numdrives);
+        FMOD_RESULT F_API getCDROMDriveName      (int drive, char *drivename, int drivenamelen, char *scsiname, int scsinamelen, char *devicename, int devicenamelen);
+        FMOD_RESULT F_API getSpectrum            (float *spectrumarray, int numvalues, int channeloffset, FMOD_DSP_FFT_WINDOW windowtype);
+        FMOD_RESULT F_API getWaveData            (float *wavearray, int numvalues, int channeloffset);
+                                                
+        // Sound/DSP/Channel/FX creation and retrieval.       
+        FMOD_RESULT F_API createSound            (const char *name_or_data, FMOD_MODE mode, FMOD_CREATESOUNDEXINFO *exinfo, Sound **sound);
+        FMOD_RESULT F_API createStream           (const char *name_or_data, FMOD_MODE mode, FMOD_CREATESOUNDEXINFO *exinfo, Sound **sound);
+        FMOD_RESULT F_API createDSP              (FMOD_DSP_DESCRIPTION *description, DSP **dsp);
+        FMOD_RESULT F_API createDSPByType        (FMOD_DSP_TYPE type, DSP **dsp);
+        FMOD_RESULT F_API createChannelGroup     (const char *name, ChannelGroup **channelgroup);
+        FMOD_RESULT F_API createSoundGroup       (const char *name, SoundGroup **soundgroup);
+        FMOD_RESULT F_API createReverb           (Reverb **reverb); 
+                                                
+        FMOD_RESULT F_API playSound              (FMOD_CHANNELINDEX channelid, Sound *sound, bool paused, Channel **channel);
+        FMOD_RESULT F_API playDSP                (FMOD_CHANNELINDEX channelid, DSP *dsp, bool paused, Channel **channel);
+        FMOD_RESULT F_API getChannel             (int channelid, Channel **channel);
+        FMOD_RESULT F_API getMasterChannelGroup  (ChannelGroup **channelgroup);
+        FMOD_RESULT F_API getMasterSoundGroup    (SoundGroup **soundgroup);
+                                              
+        // Reverb API                           
+        FMOD_RESULT F_API setReverbProperties    (const FMOD_REVERB_PROPERTIES *prop);
+        FMOD_RESULT F_API getReverbProperties    (FMOD_REVERB_PROPERTIES *prop);
+        FMOD_RESULT F_API setReverbAmbientProperties(FMOD_REVERB_PROPERTIES *prop);
+        FMOD_RESULT F_API getReverbAmbientProperties(FMOD_REVERB_PROPERTIES *prop);
+                                                 
+        // System level DSP access.
+        FMOD_RESULT F_API getDSPHead             (DSP **dsp);
+        FMOD_RESULT F_API addDSP                 (DSP *dsp, DSPConnection **connection);
+        FMOD_RESULT F_API lockDSP                ();
+        FMOD_RESULT F_API unlockDSP              ();
+        FMOD_RESULT F_API getDSPClock            (unsigned int *hi, unsigned int *lo);
+                                               
+        // Recording API.
+        FMOD_RESULT F_API getRecordNumDrivers    (int *numdrivers);
+        FMOD_RESULT F_API getRecordDriverInfo    (int id, char *name, int namelen, FMOD_GUID *guid);
+        FMOD_RESULT F_API getRecordDriverInfoW   (int id, short *name, int namelen, FMOD_GUID *guid);
+        FMOD_RESULT F_API getRecordDriverCaps    (int id, FMOD_CAPS *caps, int *minfrequency, int *maxfrequency);
+        FMOD_RESULT F_API getRecordPosition      (int id, unsigned int *position);  
+
+        FMOD_RESULT F_API recordStart            (int id, Sound *sound, bool loop);
+        FMOD_RESULT F_API recordStop             (int id);
+        FMOD_RESULT F_API isRecording            (int id, bool *recording);
+
+        // Geometry API.
+        FMOD_RESULT F_API createGeometry         (int maxpolygons, int maxvertices, Geometry **geometry);
+        FMOD_RESULT F_API setGeometrySettings    (float maxworldsize);
+        FMOD_RESULT F_API getGeometrySettings    (float *maxworldsize);
+        FMOD_RESULT F_API loadGeometry           (const void *data, int datasize, Geometry **geometry);
+        FMOD_RESULT F_API getGeometryOcclusion   (const FMOD_VECTOR *listener, const FMOD_VECTOR *source, float *direct, float *reverb);
+
+        // Network functions.
+        FMOD_RESULT F_API setNetworkProxy        (const char *proxy);
+        FMOD_RESULT F_API getNetworkProxy        (char *proxy, int proxylen);
+        FMOD_RESULT F_API setNetworkTimeout      (int timeout);
+        FMOD_RESULT F_API getNetworkTimeout      (int *timeout);
+                                              
+        // Userdata set/get.
+        FMOD_RESULT F_API setUserData            (void *userdata);
+        FMOD_RESULT F_API getUserData            (void **userdata);
+
+        FMOD_RESULT F_API getMemoryInfo          (unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details);
+    };
+
+    /*
+        'Sound' API
+    */
+    class Sound
+    {
+      private:
+
+        Sound();   /* Constructor made private so user cannot statically instance a Sound class.
+                      Appropriate Sound creation or retrieval function must be used. */
+      public:
+
+        FMOD_RESULT F_API release                ();
+        FMOD_RESULT F_API getSystemObject        (System **system);
+
+        // Standard sound manipulation functions.                                                
+        FMOD_RESULT F_API lock                   (unsigned int offset, unsigned int length, void **ptr1, void **ptr2, unsigned int *len1, unsigned int *len2);
+        FMOD_RESULT F_API unlock                 (void *ptr1, void *ptr2, unsigned int len1, unsigned int len2);
+        FMOD_RESULT F_API setDefaults            (float frequency, float volume, float pan, int priority);
+        FMOD_RESULT F_API getDefaults            (float *frequency, float *volume, float *pan,  int *priority);
+        FMOD_RESULT F_API setVariations          (float frequencyvar, float volumevar, float panvar);
+        FMOD_RESULT F_API getVariations          (float *frequencyvar, float *volumevar, float *panvar);
+        FMOD_RESULT F_API set3DMinMaxDistance    (float min, float max);
+        FMOD_RESULT F_API get3DMinMaxDistance    (float *min, float *max);
+        FMOD_RESULT F_API set3DConeSettings      (float insideconeangle, float outsideconeangle, float outsidevolume);
+        FMOD_RESULT F_API get3DConeSettings      (float *insideconeangle, float *outsideconeangle, float *outsidevolume);
+        FMOD_RESULT F_API set3DCustomRolloff     (FMOD_VECTOR *points, int numpoints);
+        FMOD_RESULT F_API get3DCustomRolloff     (FMOD_VECTOR **points, int *numpoints);
+        FMOD_RESULT F_API setSubSound            (int index, Sound *subsound);
+        FMOD_RESULT F_API getSubSound            (int index, Sound **subsound);
+        FMOD_RESULT F_API setSubSoundSentence    (int *subsoundlist, int numsubsounds);
+        FMOD_RESULT F_API getName                (char *name, int namelen);
+        FMOD_RESULT F_API getLength              (unsigned int *length, FMOD_TIMEUNIT lengthtype);
+        FMOD_RESULT F_API getFormat              (FMOD_SOUND_TYPE *type, FMOD_SOUND_FORMAT *format, int *channels, int *bits);
+        FMOD_RESULT F_API getNumSubSounds        (int *numsubsounds);
+        FMOD_RESULT F_API getNumTags             (int *numtags, int *numtagsupdated);
+        FMOD_RESULT F_API getTag                 (const char *name, int index, FMOD_TAG *tag);
+        FMOD_RESULT F_API getOpenState           (FMOD_OPENSTATE *openstate, unsigned int *percentbuffered, bool *starving, bool *diskbusy);
+        FMOD_RESULT F_API readData               (void *buffer, unsigned int lenbytes, unsigned int *read);
+        FMOD_RESULT F_API seekData               (unsigned int pcm);
+
+        FMOD_RESULT F_API setSoundGroup          (SoundGroup *soundgroup);
+        FMOD_RESULT F_API getSoundGroup          (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 getNumSyncPoints       (int *numsyncpoints);
+        FMOD_RESULT F_API getSyncPoint           (int index, FMOD_SYNCPOINT **point);
+        FMOD_RESULT F_API getSyncPointInfo       (FMOD_SYNCPOINT *point, char *name, int namelen, unsigned int *offset, FMOD_TIMEUNIT offsettype);
+        FMOD_RESULT F_API addSyncPoint           (unsigned int offset, FMOD_TIMEUNIT offsettype, const char *name, FMOD_SYNCPOINT **point);
+        FMOD_RESULT F_API deleteSyncPoint        (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 setMode                (FMOD_MODE mode);
+        FMOD_RESULT F_API getMode                (FMOD_MODE *mode);
+        FMOD_RESULT F_API setLoopCount           (int loopcount);
+        FMOD_RESULT F_API getLoopCount           (int *loopcount);
+        FMOD_RESULT F_API setLoopPoints          (unsigned int loopstart, FMOD_TIMEUNIT loopstarttype, unsigned int loopend, FMOD_TIMEUNIT loopendtype);
+        FMOD_RESULT F_API getLoopPoints          (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 getMusicNumChannels    (int *numchannels);
+        FMOD_RESULT F_API setMusicChannelVolume  (int channel, float volume);
+        FMOD_RESULT F_API getMusicChannelVolume  (int channel, float *volume);
+        FMOD_RESULT F_API setMusicSpeed          (float speed);
+        FMOD_RESULT F_API getMusicSpeed          (float *speed);
+                            
+        // Userdata set/get.
+        FMOD_RESULT F_API setUserData            (void *userdata);
+        FMOD_RESULT F_API getUserData            (void **userdata);
+
+        FMOD_RESULT F_API getMemoryInfo          (unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details);
+    };
+
+    /*
+        'Channel' API.
+    */ 
+    class Channel
+    {
+      private:
+
+        Channel();   /* Constructor made private so user cannot statically instance a Channel class.  
+                        Appropriate Channel creation or retrieval function must be used. */
+      public:
+
+        FMOD_RESULT F_API getSystemObject        (System **system);
+
+        FMOD_RESULT F_API stop                   ();
+        FMOD_RESULT F_API setPaused              (bool paused);
+        FMOD_RESULT F_API getPaused              (bool *paused);
+        FMOD_RESULT F_API setVolume              (float volume);
+        FMOD_RESULT F_API getVolume              (float *volume);
+        FMOD_RESULT F_API setFrequency           (float frequency);
+        FMOD_RESULT F_API getFrequency           (float *frequency);
+        FMOD_RESULT F_API setPan                 (float pan);
+        FMOD_RESULT F_API getPan                 (float *pan);
+        FMOD_RESULT F_API setDelay               (FMOD_DELAYTYPE delaytype, unsigned int delayhi, unsigned int delaylo);
+        FMOD_RESULT F_API getDelay               (FMOD_DELAYTYPE delaytype, unsigned int *delayhi, unsigned int *delaylo);
+        FMOD_RESULT F_API setSpeakerMix          (float frontleft, float frontright, float center, float lfe, float backleft, float backright, float sideleft, float sideright);
+        FMOD_RESULT F_API getSpeakerMix          (float *frontleft, float *frontright, float *center, float *lfe, float *backleft, float *backright, float *sideleft, float *sideright);
+        FMOD_RESULT F_API setSpeakerLevels       (FMOD_SPEAKER speaker, float *levels, int numlevels);
+        FMOD_RESULT F_API getSpeakerLevels       (FMOD_SPEAKER speaker, float *levels, int numlevels);
+        FMOD_RESULT F_API setInputChannelMix     (float *levels, int numlevels);
+        FMOD_RESULT F_API getInputChannelMix     (float *levels, int numlevels);
+        FMOD_RESULT F_API setMute                (bool mute);
+        FMOD_RESULT F_API getMute                (bool *mute);
+        FMOD_RESULT F_API setPriority            (int priority);
+        FMOD_RESULT F_API getPriority            (int *priority);
+        FMOD_RESULT F_API setPosition            (unsigned int position, FMOD_TIMEUNIT postype);
+        FMOD_RESULT F_API getPosition            (unsigned int *position, FMOD_TIMEUNIT postype);
+        FMOD_RESULT F_API setReverbProperties    (const FMOD_REVERB_CHANNELPROPERTIES *prop);
+        FMOD_RESULT F_API getReverbProperties    (FMOD_REVERB_CHANNELPROPERTIES *prop);
+        FMOD_RESULT F_API setLowPassGain         (float gain);
+        FMOD_RESULT F_API getLowPassGain         (float *gain);
+
+        FMOD_RESULT F_API setChannelGroup        (ChannelGroup *channelgroup);
+        FMOD_RESULT F_API getChannelGroup        (ChannelGroup **channelgroup);
+        FMOD_RESULT F_API setCallback            (FMOD_CHANNEL_CALLBACK callback);
+
+        // 3D functionality.
+        FMOD_RESULT F_API set3DAttributes        (const FMOD_VECTOR *pos, const FMOD_VECTOR *vel);
+        FMOD_RESULT F_API get3DAttributes        (FMOD_VECTOR *pos, FMOD_VECTOR *vel);
+        FMOD_RESULT F_API set3DMinMaxDistance    (float mindistance, float maxdistance);
+        FMOD_RESULT F_API get3DMinMaxDistance    (float *mindistance, float *maxdistance);
+        FMOD_RESULT F_API set3DConeSettings      (float insideconeangle, float outsideconeangle, float outsidevolume);
+        FMOD_RESULT F_API get3DConeSettings      (float *insideconeangle, float *outsideconeangle, float *outsidevolume);
+        FMOD_RESULT F_API set3DConeOrientation   (FMOD_VECTOR *orientation);
+        FMOD_RESULT F_API get3DConeOrientation   (FMOD_VECTOR *orientation);
+        FMOD_RESULT F_API set3DCustomRolloff     (FMOD_VECTOR *points, int numpoints);
+        FMOD_RESULT F_API get3DCustomRolloff     (FMOD_VECTOR **points, int *numpoints);
+        FMOD_RESULT F_API set3DOcclusion         (float directocclusion, float reverbocclusion);
+        FMOD_RESULT F_API get3DOcclusion         (float *directocclusion, float *reverbocclusion);
+        FMOD_RESULT F_API set3DSpread            (float angle);
+        FMOD_RESULT F_API get3DSpread            (float *angle);
+        FMOD_RESULT F_API set3DPanLevel          (float level);
+        FMOD_RESULT F_API get3DPanLevel          (float *level);
+        FMOD_RESULT F_API set3DDopplerLevel      (float level);
+        FMOD_RESULT F_API get3DDopplerLevel      (float *level);
+        FMOD_RESULT F_API set3DDistanceFilter    (bool custom, float customLevel, float centerFreq);
+        FMOD_RESULT F_API get3DDistanceFilter    (bool *custom, float *customLevel, float *centerFreq);
+
+        // DSP functionality only for channels playing sounds created with FMOD_SOFTWARE.
+        FMOD_RESULT F_API getDSPHead             (DSP **dsp);
+        FMOD_RESULT F_API addDSP                 (DSP *dsp, DSPConnection **connection);
+
+        // Information only functions.
+        FMOD_RESULT F_API isPlaying              (bool *isplaying);
+        FMOD_RESULT F_API isVirtual              (bool *isvirtual);
+        FMOD_RESULT F_API getAudibility          (float *audibility);
+        FMOD_RESULT F_API getCurrentSound        (Sound **sound);
+        FMOD_RESULT F_API getSpectrum            (float *spectrumarray, int numvalues, int channeloffset, FMOD_DSP_FFT_WINDOW windowtype);
+        FMOD_RESULT F_API getWaveData            (float *wavearray, int numvalues, int channeloffset);
+        FMOD_RESULT F_API getIndex               (int *index);
+                                                
+        // Functions also found in Sound class but here they can be set per channel.
+        FMOD_RESULT F_API setMode                (FMOD_MODE mode);
+        FMOD_RESULT F_API getMode                (FMOD_MODE *mode);
+        FMOD_RESULT F_API setLoopCount           (int loopcount);
+        FMOD_RESULT F_API getLoopCount           (int *loopcount);
+        FMOD_RESULT F_API setLoopPoints          (unsigned int loopstart, FMOD_TIMEUNIT loopstarttype, unsigned int loopend, FMOD_TIMEUNIT loopendtype);
+        FMOD_RESULT F_API getLoopPoints          (unsigned int *loopstart, FMOD_TIMEUNIT loopstarttype, unsigned int *loopend, FMOD_TIMEUNIT loopendtype);
+
+        // Userdata set/get.                                                
+        FMOD_RESULT F_API setUserData            (void *userdata);
+        FMOD_RESULT F_API getUserData            (void **userdata);
+
+        FMOD_RESULT F_API getMemoryInfo          (unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details);
+    };
+
+    /*
+        'ChannelGroup' API
+    */
+    class ChannelGroup
+    {
+      private:
+
+        ChannelGroup();   /* Constructor made private so user cannot statically instance a ChannelGroup class.  
+                             Appropriate ChannelGroup creation or retrieval function must be used. */
+      public:
+
+        FMOD_RESULT F_API release                 ();
+        FMOD_RESULT F_API getSystemObject         (System **system);
+
+        // Channelgroup scale values.  (changes attributes relative to the channels, doesn't overwrite them)
+        FMOD_RESULT F_API setVolume               (float volume);
+        FMOD_RESULT F_API getVolume               (float *volume);
+        FMOD_RESULT F_API setPitch                (float pitch);
+        FMOD_RESULT F_API getPitch                (float *pitch);
+        FMOD_RESULT F_API set3DOcclusion          (float directocclusion, float reverbocclusion);
+        FMOD_RESULT F_API get3DOcclusion          (float *directocclusion, float *reverbocclusion);
+        FMOD_RESULT F_API setPaused               (bool paused);
+        FMOD_RESULT F_API getPaused               (bool *paused);
+        FMOD_RESULT F_API setMute                 (bool mute);
+        FMOD_RESULT F_API getMute                 (bool *mute);
+
+        // Channelgroup override values.  (recursively overwrites whatever settings the channels had)
+        FMOD_RESULT F_API stop                    ();
+        FMOD_RESULT F_API overrideVolume          (float volume);
+        FMOD_RESULT F_API overrideFrequency       (float frequency);
+        FMOD_RESULT F_API overridePan             (float pan);
+        FMOD_RESULT F_API overrideReverbProperties(const FMOD_REVERB_CHANNELPROPERTIES *prop);
+        FMOD_RESULT F_API override3DAttributes    (const FMOD_VECTOR *pos, const FMOD_VECTOR *vel);
+        FMOD_RESULT F_API overrideSpeakerMix      (float frontleft, float frontright, float center, float lfe, float backleft, float backright, float sideleft, float sideright);
+
+        // Nested channel groups.
+        FMOD_RESULT F_API addGroup                (ChannelGroup *group);
+        FMOD_RESULT F_API getNumGroups            (int *numgroups);
+        FMOD_RESULT F_API getGroup                (int index, ChannelGroup **group);
+        FMOD_RESULT F_API getParentGroup          (ChannelGroup **group);
+
+        // DSP functionality only for channel groups playing sounds created with FMOD_SOFTWARE.
+        FMOD_RESULT F_API getDSPHead              (DSP **dsp);
+        FMOD_RESULT F_API addDSP                  (DSP *dsp, DSPConnection **connection);
+
+        // Information only functions.
+        FMOD_RESULT F_API getName                 (char *name, int namelen);
+        FMOD_RESULT F_API getNumChannels          (int *numchannels);
+        FMOD_RESULT F_API getChannel              (int index, Channel **channel);
+        FMOD_RESULT F_API getSpectrum             (float *spectrumarray, int numvalues, int channeloffset, FMOD_DSP_FFT_WINDOW windowtype);
+        FMOD_RESULT F_API getWaveData             (float *wavearray, int numvalues, int channeloffset);
+
+        // Userdata set/get.
+        FMOD_RESULT F_API setUserData             (void *userdata);
+        FMOD_RESULT F_API getUserData             (void **userdata);
+
+        FMOD_RESULT F_API getMemoryInfo           (unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details);
+    };
+
+    /*
+        'SoundGroup' API
+    */
+    class SoundGroup
+    {
+      private:
+
+        SoundGroup();       /* Constructor made private so user cannot statically instance a SoundGroup class.  
+                               Appropriate SoundGroup creation or retrieval function must be used. */
+      public:
+
+        FMOD_RESULT F_API release                ();
+        FMOD_RESULT F_API getSystemObject        (System **system);
+
+        // SoundGroup control functions.
+        FMOD_RESULT F_API setMaxAudible          (int maxaudible);
+        FMOD_RESULT F_API getMaxAudible          (int *maxaudible);
+        FMOD_RESULT F_API setMaxAudibleBehavior  (FMOD_SOUNDGROUP_BEHAVIOR behavior);
+        FMOD_RESULT F_API getMaxAudibleBehavior  (FMOD_SOUNDGROUP_BEHAVIOR *behavior);
+        FMOD_RESULT F_API setMuteFadeSpeed       (float speed);
+        FMOD_RESULT F_API getMuteFadeSpeed       (float *speed);
+        FMOD_RESULT F_API setVolume              (float volume);
+        FMOD_RESULT F_API getVolume              (float *volume);
+        FMOD_RESULT F_API stop                   ();
+
+        // Information only functions.
+        FMOD_RESULT F_API getName                (char *name, int namelen);
+        FMOD_RESULT F_API getNumSounds           (int *numsounds);
+        FMOD_RESULT F_API getSound               (int index, Sound **sound);
+        FMOD_RESULT F_API getNumPlaying          (int *numplaying);
+
+        // Userdata set/get.
+        FMOD_RESULT F_API setUserData            (void *userdata);
+        FMOD_RESULT F_API getUserData            (void **userdata);
+    
+        FMOD_RESULT F_API getMemoryInfo          (unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details);
+    };
+
+    /*
+        'DSP' API
+    */
+    class DSP
+    {
+      private:
+
+        DSP();   /* Constructor made private so user cannot statically instance a DSP class.  
+                    Appropriate DSP creation or retrieval function must be used. */
+      public:
+
+        FMOD_RESULT F_API release                ();
+        FMOD_RESULT F_API getSystemObject        (System **system);
+
+        // Connection / disconnection / input and output enumeration.
+        FMOD_RESULT F_API addInput               (DSP *target, DSPConnection **connection);
+        FMOD_RESULT F_API disconnectFrom         (DSP *target);
+        FMOD_RESULT F_API disconnectAll          (bool inputs, bool outputs);
+        FMOD_RESULT F_API remove                 ();
+        FMOD_RESULT F_API getNumInputs           (int *numinputs);
+        FMOD_RESULT F_API getNumOutputs          (int *numoutputs);
+        FMOD_RESULT F_API getInput               (int index, DSP **input, DSPConnection **inputconnection);
+        FMOD_RESULT F_API getOutput              (int index, DSP **output, DSPConnection **outputconnection);
+
+        // DSP unit control.
+        FMOD_RESULT F_API setActive              (bool active);
+        FMOD_RESULT F_API getActive              (bool *active);
+        FMOD_RESULT F_API setBypass              (bool bypass);
+        FMOD_RESULT F_API getBypass              (bool *bypass);
+        FMOD_RESULT F_API setSpeakerActive		 (FMOD_SPEAKER speaker, bool active);
+		FMOD_RESULT F_API getSpeakerActive		 (FMOD_SPEAKER speaker, bool *active);
+		FMOD_RESULT F_API reset                  ();
+		
+
+        // DSP parameter control.
+        FMOD_RESULT F_API setParameter           (int index, float value);
+        FMOD_RESULT F_API getParameter           (int index, float *value, char *valuestr, int valuestrlen);
+        FMOD_RESULT F_API getNumParameters       (int *numparams);
+        FMOD_RESULT F_API getParameterInfo       (int index, char *name, char *label, char *description, int descriptionlen, float *min, float *max);
+        FMOD_RESULT F_API showConfigDialog       (void *hwnd, bool show);
+        
+        // DSP attributes.        
+        FMOD_RESULT F_API getInfo                (char *name, unsigned int *version, int *channels, int *configwidth, int *configheight);
+        FMOD_RESULT F_API getType                (FMOD_DSP_TYPE *type); 
+        FMOD_RESULT F_API setDefaults            (float frequency, float volume, float pan, int priority);
+        FMOD_RESULT F_API getDefaults            (float *frequency, float *volume, float *pan, int *priority);
+                                                
+        // Userdata set/get.
+        FMOD_RESULT F_API setUserData            (void *userdata);
+        FMOD_RESULT F_API getUserData            (void **userdata);
+
+        FMOD_RESULT F_API getMemoryInfo          (unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details);
+    };
+
+
+    /*
+        'DSPConnection' API
+    */
+    class DSPConnection
+    {
+      private:
+
+        DSPConnection();    /* Constructor made private so user cannot statically instance a DSPConnection class.  
+                               Appropriate DSPConnection creation or retrieval function must be used. */
+
+      public:
+
+        FMOD_RESULT F_API getInput              (DSP **input);
+        FMOD_RESULT F_API getOutput             (DSP **output);
+        FMOD_RESULT F_API setMix                (float volume);
+        FMOD_RESULT F_API getMix                (float *volume);
+        FMOD_RESULT F_API setLevels             (FMOD_SPEAKER speaker, float *levels, int numlevels);
+        FMOD_RESULT F_API getLevels             (FMOD_SPEAKER speaker, float *levels, int numlevels);
+
+        // Userdata set/get.
+        FMOD_RESULT F_API setUserData           (void *userdata);
+        FMOD_RESULT F_API getUserData           (void **userdata);
+
+        FMOD_RESULT F_API getMemoryInfo         (unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details);
+    };
+
+
+    /*
+        'Geometry' API
+    */
+    class Geometry
+    {
+      private:
+
+        Geometry();   /* Constructor made private so user cannot statically instance a Geometry class.  
+                         Appropriate Geometry creation or retrieval function must be used. */
+
+      public:        
+
+        FMOD_RESULT F_API release                ();
+
+        // Polygon manipulation.
+        FMOD_RESULT F_API addPolygon             (float directocclusion, float reverbocclusion, bool doublesided, int numvertices, const FMOD_VECTOR *vertices, int *polygonindex);
+        FMOD_RESULT F_API getNumPolygons         (int *numpolygons); 
+        FMOD_RESULT F_API getMaxPolygons         (int *maxpolygons, int *maxvertices);
+        FMOD_RESULT F_API getPolygonNumVertices  (int index, int *numvertices);
+        FMOD_RESULT F_API setPolygonVertex       (int index, int vertexindex, const FMOD_VECTOR *vertex); 
+        FMOD_RESULT F_API getPolygonVertex       (int index, int vertexindex, FMOD_VECTOR *vertex);
+        FMOD_RESULT F_API setPolygonAttributes   (int index, float directocclusion, float reverbocclusion, bool doublesided); 
+        FMOD_RESULT F_API getPolygonAttributes   (int index, float *directocclusion, float *reverbocclusion, bool *doublesided); 
+
+        // Object manipulation.
+        FMOD_RESULT F_API setActive              (bool active);                                                 
+        FMOD_RESULT F_API getActive              (bool *active);                                                 
+        FMOD_RESULT F_API setRotation            (const FMOD_VECTOR *forward, const FMOD_VECTOR *up);
+        FMOD_RESULT F_API getRotation            (FMOD_VECTOR *forward, FMOD_VECTOR *up);
+        FMOD_RESULT F_API setPosition            (const FMOD_VECTOR *position);
+        FMOD_RESULT F_API getPosition            (FMOD_VECTOR *position);
+        FMOD_RESULT F_API setScale               (const FMOD_VECTOR *scale);
+        FMOD_RESULT F_API getScale               (FMOD_VECTOR *scale);
+        FMOD_RESULT F_API save                   (void *data, int *datasize);
+
+        // Userdata set/get.
+        FMOD_RESULT F_API setUserData            (void *userdata);
+        FMOD_RESULT F_API getUserData            (void **userdata);
+
+        FMOD_RESULT F_API getMemoryInfo          (unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details);
+    };
+
+
+    /*
+        'Reverb' API
+    */
+    class Reverb
+    {
+      private:
+
+        Reverb();    /*  Constructor made private so user cannot statically instance a Reverb class.  
+                         Appropriate Reverb creation or retrieval function must be used. */
+
+      public:    
+
+        FMOD_RESULT F_API release                ();
+
+        // Reverb manipulation.
+        FMOD_RESULT F_API set3DAttributes        (const FMOD_VECTOR *position, float mindistance, float maxdistance);
+        FMOD_RESULT F_API get3DAttributes        (FMOD_VECTOR *position, float *mindistance,float *maxdistance);
+        FMOD_RESULT F_API setProperties          (const FMOD_REVERB_PROPERTIES *properties);
+        FMOD_RESULT F_API getProperties          (FMOD_REVERB_PROPERTIES *properties);
+        FMOD_RESULT F_API setActive              (bool active);
+        FMOD_RESULT F_API getActive              (bool *active);
+
+        // Userdata set/get.
+        FMOD_RESULT F_API setUserData            (void *userdata);
+        FMOD_RESULT F_API getUserData            (void **userdata);    
+
+        FMOD_RESULT F_API getMemoryInfo          (unsigned int memorybits, unsigned int event_memorybits, unsigned int *memoryused, FMOD_MEMORY_USAGE_DETAILS *memoryused_details);
+    };
+}
+
+#endif

libs/FMOD/inc/fmod_codec.h

@@ -0,0 +1,159 @@
+/* ==================================================================================================== */
+/* FMOD Ex - codec development header file. Copyright (c), Firelight Technologies Pty, Ltd. 2004-2014.  */
+/*                                                                                                      */
+/* 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.           */
+/*                                                                                                      */
+/* ==================================================================================================== */
+
+#ifndef _FMOD_CODEC_H
+#define _FMOD_CODEC_H
+
+typedef struct FMOD_CODEC_STATE FMOD_CODEC_STATE;
+typedef struct FMOD_CODEC_WAVEFORMAT FMOD_CODEC_WAVEFORMAT;
+
+/*
+    Codec callbacks
+*/ 
+typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_OPENCALLBACK)        (FMOD_CODEC_STATE *codec_state, FMOD_MODE usermode, FMOD_CREATESOUNDEXINFO *userexinfo);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_CLOSECALLBACK)       (FMOD_CODEC_STATE *codec_state);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_READCALLBACK)        (FMOD_CODEC_STATE *codec_state, void *buffer, unsigned int sizebytes, unsigned int *bytesread);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_GETLENGTHCALLBACK)   (FMOD_CODEC_STATE *codec_state, unsigned int *length, FMOD_TIMEUNIT lengthtype);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_SETPOSITIONCALLBACK) (FMOD_CODEC_STATE *codec_state, int subsound, unsigned int position, FMOD_TIMEUNIT postype);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_GETPOSITIONCALLBACK) (FMOD_CODEC_STATE *codec_state, unsigned int *position, FMOD_TIMEUNIT postype);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_SOUNDCREATECALLBACK) (FMOD_CODEC_STATE *codec_state, int subsound, FMOD_SOUND *sound);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_METADATACALLBACK)    (FMOD_CODEC_STATE *codec_state, FMOD_TAGTYPE tagtype, char *name, void *data, unsigned int datalen, FMOD_TAGDATATYPE datatype, int unique);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_CODEC_GETWAVEFORMAT)       (FMOD_CODEC_STATE *codec_state, int index, FMOD_CODEC_WAVEFORMAT *waveformat);
+
+
+/*
+[STRUCTURE] 
+[
+    [DESCRIPTION]
+    When creating a codec, declare one of these and provide the relevant callbacks and name for FMOD to use when it opens and reads a file.
+
+    [REMARKS]
+    Members marked with [in] mean the variable can be written to.  The user can set the value.
+    Members marked with [out] mean the variable is modified by FMOD and is for reading purposes only.  Do not change this value.
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]
+    FMOD_CODEC_STATE
+]
+*/
+typedef struct FMOD_CODEC_DESCRIPTION
+{
+    const char                     *name;            /* [in] Name of the codec. */
+    unsigned int                    version;         /* [in] Plugin writer's version number. */
+    int                             defaultasstream; /* [in] Tells FMOD to open the file as a stream when calling System::createSound, and not a static sample.  Should normally be 0 (FALSE), because generally the user wants to decode the file into memory when using System::createSound.   Mainly used for formats that decode for a very long time, or could use large amounts of memory when decoded.  Usually sequenced formats such as mod/s3m/xm/it/midi fall into this category.   It is mainly to stop users that don't know what they're doing from getting FMOD_ERR_MEMORY returned from createSound when they should have in fact called System::createStream or used FMOD_CREATESTREAM in System::createSound. */
+    FMOD_TIMEUNIT                   timeunits;       /* [in] When setposition codec is called, only these time formats will be passed to the codec. Use bitwise OR to accumulate different types. */
+    FMOD_CODEC_OPENCALLBACK         open;            /* [in] Open callback for the codec for when FMOD tries to open a sound using this codec. */
+    FMOD_CODEC_CLOSECALLBACK        close;           /* [in] Close callback for the codec for when FMOD tries to close a sound using this codec.  */
+    FMOD_CODEC_READCALLBACK         read;            /* [in] Read callback for the codec for when FMOD tries to read some data from the file to the destination format (specified in the open callback). */
+    FMOD_CODEC_GETLENGTHCALLBACK    getlength;       /* [in] Callback to return the length of the song in whatever format required when Sound::getLength is called. */
+    FMOD_CODEC_SETPOSITIONCALLBACK  setposition;     /* [in] Seek callback for the codec for when FMOD tries to seek within the file with Channel::setPosition. */
+    FMOD_CODEC_GETPOSITIONCALLBACK  getposition;     /* [in] Tell callback for the codec for when FMOD tries to get the current position within the with Channel::getPosition. */
+    FMOD_CODEC_SOUNDCREATECALLBACK  soundcreate;     /* [in] Sound creation callback for the codec when FMOD finishes creating the sound.  (So the codec can set more parameters for the related created sound, ie loop points/mode or 3D attributes etc). */
+    FMOD_CODEC_GETWAVEFORMAT        getwaveformat;   /* [in] Callback to tell FMOD about the waveformat of a particular subsound.  This is to save memory, rather than saving 1000 FMOD_CODEC_WAVEFORMAT structures in the codec, the codec might have a more optimal way of storing this information. */
+} FMOD_CODEC_DESCRIPTION;
+
+
+/*
+[STRUCTURE] 
+[
+    [DESCRIPTION]
+    Set these values marked 'in' to tell fmod what sort of sound to create.
+    The format, channels and frequency tell FMOD what sort of hardware buffer to create when you initialize your code.  So if you wrote an MP3 codec that decoded to stereo 16bit integer PCM, you would specify FMOD_SOUND_FORMAT_PCM16, and channels would be equal to 2.
+    Members marked as 'out' are set by fmod.  Do not modify these.  Simply specify 0 for these values when declaring the structure, FMOD will fill in the values for you after creation with the correct function pointers.
+
+    [REMARKS]
+    Members marked with [in] mean the variable can be written to.  The user can set the value.
+    Members marked with [out] mean the variable is modified by FMOD and is for reading purposes only.  Do not change this value.
+    
+    An FMOD file might be from disk, memory or network, however the file may be opened by the user.
+    
+    'numsubsounds' should be 0 if the file is a normal single sound stream or sound.  Examples of this would be .WAV, .WMA, .MP3, .AIFF.
+    'numsubsounds' should be 1+ if the file is a container format, and does not contain wav data itself.  Examples of these types would be CDDA (multiple CD tracks), FSB (contains multiple sounds), MIDI/MOD/S3M/XM/IT (contain instruments).
+    The arrays of format, channel, frequency, length and blockalign should point to arrays of information based on how many subsounds are in the format.  If the number of subsounds is 0 then it should point to 1 of each attribute, the same as if the number of subsounds was 1.  If subsounds was 100 for example, each pointer should point to an array of 100 of each attribute.
+    When a sound has 1 or more subsounds, you must play the individual sounds specified by first obtaining the subsound with Sound::getSubSound.
+    
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]
+    FMOD_SOUND_FORMAT
+    FMOD_FILE_READCALLBACK      
+    FMOD_FILE_SEEKCALLBACK      
+    FMOD_CODEC_METADATACALLBACK
+    Sound::getSubSound
+    Sound::getNumSubSounds
+]
+*/
+struct FMOD_CODEC_WAVEFORMAT
+{
+    char               name[256];     /* [in] Name of sound.*/
+    FMOD_SOUND_FORMAT  format;        /* [in] Format for (decompressed) codec output, ie FMOD_SOUND_FORMAT_PCM8, FMOD_SOUND_FORMAT_PCM16.*/
+    int                channels;      /* [in] Number of channels used by codec, ie mono = 1, stereo = 2. */
+    int                frequency;     /* [in] Default frequency in hz of the codec, ie 44100. */
+    unsigned int       lengthbytes;   /* [in] Length in bytes of the source data. */
+    unsigned int       lengthpcm;     /* [in] Length in decompressed, PCM samples of the file, ie length in seconds * frequency.  Used for Sound::getLength and for memory allocation of static decompressed sample data. */
+    int                blockalign;    /* [in] Blockalign in decompressed, PCM samples of the optimal decode chunk size for this format.  The codec read callback will be called in multiples of this value. */
+    int                loopstart;     /* [in] Loopstart in decompressed, PCM samples of file. */
+    int                loopend;       /* [in] Loopend in decompressed, PCM samples of file. */
+    FMOD_MODE          mode;          /* [in] Mode to determine whether the sound should by default load as looping, non looping, 2d or 3d. */
+    unsigned int       channelmask;   /* [in] Microsoft speaker channel mask, as defined for WAVEFORMATEXTENSIBLE and is found in ksmedia.h.  Leave at 0 to play in natural speaker order. */
+};
+
+
+/*
+[STRUCTURE] 
+[
+    [DESCRIPTION]
+    Codec plugin structure that is passed into each callback.
+    
+    Set these numsubsounds and waveformat members when called in FMOD_CODEC_OPENCALLBACK to tell fmod what sort of sound to create.
+    
+    The format, channels and frequency tell FMOD what sort of hardware buffer to create when you initialize your code.  So if you wrote an MP3 codec that decoded to stereo 16bit integer PCM, you would specify FMOD_SOUND_FORMAT_PCM16, and channels would be equal to 2.
+
+    [REMARKS]
+    Members marked with [in] mean the variable can be written to.  The user can set the value.
+    Members marked with [out] mean the variable is modified by FMOD and is for reading purposes only.  Do not change this value.
+    
+    An FMOD file might be from disk, memory or internet, however the file may be opened by the user.
+    
+    'numsubsounds' should be 0 if the file is a normal single sound stream or sound.  Examples of this would be .WAV, .WMA, .MP3, .AIFF.
+    'numsubsounds' should be 1+ if the file is a container format, and does not contain wav data itself.  Examples of these types would be CDDA (multiple CD tracks), FSB (contains multiple sounds), DLS (contain instruments).
+    The arrays of format, channel, frequency, length and blockalign should point to arrays of information based on how many subsounds are in the format.  If the number of subsounds is 0 then it should point to 1 of each attribute, the same as if the number of subsounds was 1.  If subsounds was 100 for example, each pointer should point to an array of 100 of each attribute.
+    When a sound has 1 or more subsounds, you must play the individual sounds specified by first obtaining the subsound with Sound::getSubSound.
+    
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]
+    FMOD_SOUND_FORMAT
+    FMOD_FILE_READCALLBACK      
+    FMOD_FILE_SEEKCALLBACK      
+    FMOD_CODEC_METADATACALLBACK
+    Sound::getSubSound
+    Sound::getNumSubSounds
+]
+*/
+struct FMOD_CODEC_STATE
+{
+    int                         numsubsounds;  /* [in] Number of 'subsounds' in this sound.  Anything other than 0 makes it a 'container' format (ie CDDA/DLS/FSB etc which contain 1 or more su bsounds).  For most normal, single sound codec such as WAV/AIFF/MP3, this should be 0 as they are not a container for subsounds, they are the sound by itself. */
+    FMOD_CODEC_WAVEFORMAT      *waveformat;    /* [in] Pointer to an array of format structures containing information about each sample.  Can be 0 or NULL if FMOD_CODEC_GETWAVEFORMAT callback is preferred.  The number of entries here must equal the number of subsounds defined in the subsound parameter. If numsubsounds = 0 then there should be 1 instance of this structure. */
+    void                       *plugindata;    /* [in] Plugin writer created data the codec author wants to attach to this object. */
+                                               
+    void                       *filehandle;    /* [out] This will return an internal FMOD file handle to use with the callbacks provided.  */
+    unsigned int                filesize;      /* [out] This will contain the size of the file in bytes. */
+    FMOD_FILE_READCALLBACK      fileread;      /* [out] This will return a callable FMOD file function to use from codec. */
+    FMOD_FILE_SEEKCALLBACK      fileseek;      /* [out] This will return a callable FMOD file function to use from codec.  */
+    FMOD_CODEC_METADATACALLBACK metadata;      /* [out] This will return a callable FMOD metadata function to use from codec.  */
+};
+
+#endif
+
+

libs/FMOD/inc/fmod_dsp.h

@@ -0,0 +1,745 @@
+/* ========================================================================================== */
+/* FMOD Ex - DSP header file. Copyright (c), Firelight Technologies Pty, Ltd. 2004-2014.      */
+/*                                                                                            */
+/* Use this header if you are interested in delving deeper into the FMOD software mixing /    */
+/* DSP engine.  In this header you can find parameter structures for FMOD system reigstered   */
+/* DSP effects and generators.                                                                */
+/* Also use this header if you are wanting to develop your own DSP plugin to use with FMOD's  */
+/* 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.     */
+/*                                                                                            */
+/* ========================================================================================== */
+
+#ifndef _FMOD_DSP_H
+#define _FMOD_DSP_H
+
+typedef struct FMOD_DSP_STATE FMOD_DSP_STATE;
+
+/* 
+    DSP callbacks
+*/
+typedef FMOD_RESULT (F_CALLBACK *FMOD_DSP_CREATECALLBACK)     (FMOD_DSP_STATE *dsp_state);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_DSP_RELEASECALLBACK)    (FMOD_DSP_STATE *dsp_state);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_DSP_RESETCALLBACK)      (FMOD_DSP_STATE *dsp_state);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_DSP_READCALLBACK)       (FMOD_DSP_STATE *dsp_state, float *inbuffer, float *outbuffer, unsigned int length, int inchannels, int outchannels);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_DSP_SETPOSITIONCALLBACK)(FMOD_DSP_STATE *dsp_state, unsigned int pos);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_DSP_SETPARAMCALLBACK)   (FMOD_DSP_STATE *dsp_state, int index, float value);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_DSP_GETPARAMCALLBACK)   (FMOD_DSP_STATE *dsp_state, int index, float *value, char *valuestr);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_DSP_DIALOGCALLBACK)     (FMOD_DSP_STATE *dsp_state, void *hwnd, int show);
+
+/*
+[ENUM]
+[
+    [DESCRIPTION]   
+    These definitions can be used for creating FMOD defined special effects or DSP units.
+
+    [REMARKS]
+    To get them to be active, first create the unit, then add it somewhere into the DSP network, either at the front of the network near the soundcard unit to affect the global output (by using System::getDSPHead), or on a single channel (using Channel::getDSPHead).
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]
+    System::createDSPByType
+]
+*/
+typedef enum
+{
+    FMOD_DSP_TYPE_UNKNOWN,            /* This unit was created via a non FMOD plugin so has an unknown purpose. */
+    FMOD_DSP_TYPE_MIXER,              /* This unit does nothing but take inputs and mix them together then feed the result to the soundcard unit. */
+    FMOD_DSP_TYPE_OSCILLATOR,         /* This unit generates sine/square/saw/triangle or noise tones. */
+    FMOD_DSP_TYPE_LOWPASS,            /* This unit filters sound using a high quality, resonant lowpass filter algorithm but consumes more CPU time. */
+    FMOD_DSP_TYPE_ITLOWPASS,          /* This unit filters sound using a resonant lowpass filter algorithm that is used in Impulse Tracker, but with limited cutoff range (0 to 8060hz). */
+    FMOD_DSP_TYPE_HIGHPASS,           /* This unit filters sound using a resonant highpass filter algorithm. */
+    FMOD_DSP_TYPE_ECHO,               /* This unit produces an echo on the sound and fades out at the desired rate. */
+    FMOD_DSP_TYPE_FLANGE,             /* This unit produces a flange effect on the sound. */
+    FMOD_DSP_TYPE_DISTORTION,         /* This unit distorts the sound. */
+    FMOD_DSP_TYPE_NORMALIZE,          /* This unit normalizes or amplifies the sound to a certain level. */
+    FMOD_DSP_TYPE_PARAMEQ,            /* This unit attenuates or amplifies a selected frequency range. */
+    FMOD_DSP_TYPE_PITCHSHIFT,         /* This unit bends the pitch of a sound without changing the speed of playback. */
+    FMOD_DSP_TYPE_CHORUS,             /* This unit produces a chorus effect on the sound. */
+    FMOD_DSP_TYPE_VSTPLUGIN,          /* This unit allows the use of Steinberg VST plugins */
+    FMOD_DSP_TYPE_WINAMPPLUGIN,       /* This unit allows the use of Nullsoft Winamp plugins */
+    FMOD_DSP_TYPE_ITECHO,             /* This unit produces an echo on the sound and fades out at the desired rate as is used in Impulse Tracker. */
+    FMOD_DSP_TYPE_COMPRESSOR,         /* This unit implements dynamic compression (linked multichannel, wideband) */
+    FMOD_DSP_TYPE_SFXREVERB,          /* This unit implements SFX reverb */
+    FMOD_DSP_TYPE_LOWPASS_SIMPLE,     /* This unit filters sound using a simple lowpass with no resonance, but has flexible cutoff and is fast. */
+    FMOD_DSP_TYPE_DELAY,              /* This unit produces different delays on individual channels of the sound. */
+    FMOD_DSP_TYPE_TREMOLO,            /* This unit produces a tremolo / chopper effect on the sound. */
+    FMOD_DSP_TYPE_LADSPAPLUGIN,       /* This unit allows the use of LADSPA standard plugins. */
+    FMOD_DSP_TYPE_HIGHPASS_SIMPLE,    /* This unit filters sound using a simple highpass with no resonance, but has flexible cutoff and is fast. */
+    FMOD_DSP_TYPE_HARDWARE = 1000,    /* Offset that platform specific FMOD_HARDWARE DSPs will start at. */
+    FMOD_DSP_TYPE_FORCEINT = 65536    /* Makes sure this enum is signed 32bit. */
+} FMOD_DSP_TYPE;
+
+
+/*
+[STRUCTURE] 
+[
+    [DESCRIPTION]
+    Structure to define a parameter for a DSP unit.
+
+    [REMARKS]
+    Members marked with [r] mean the variable is modified by FMOD and is for reading purposes only.  Do not change this value.
+    Members marked with [w] mean the variable can be written to.  The user can set the value.
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]    
+    System::createDSP
+    DSP::setParameter
+]
+*/
+typedef struct FMOD_DSP_PARAMETERDESC
+{
+    float       min;                                /* [w] Minimum value of the parameter (ie 100.0). */
+    float       max;                                /* [w] Maximum value of the parameter (ie 22050.0). */
+    float       defaultval;                         /* [w] Default value of parameter. */
+    char        name[16];                           /* [w] Name of the parameter to be displayed (ie "Cutoff frequency"). */
+    char        label[16];                          /* [w] Short string to be put next to value to denote the unit type (ie "hz"). */
+    const char *description;                        /* [w] Description of the parameter to be displayed as a help item / tooltip for this parameter. */
+} FMOD_DSP_PARAMETERDESC;
+
+
+/*
+[STRUCTURE] 
+[
+    [DESCRIPTION]
+    When creating a DSP unit, declare one of these and provide the relevant callbacks and name for FMOD to use when it creates and uses a DSP unit of this type.
+
+    [REMARKS]
+    Some members of this structure are referenced directly inside FMOD so the structure should be allocated statically or at least remain in memory for the lifetime of the system.
+    
+    Members marked with [r] mean the variable is modified by FMOD and is for reading purposes only.  Do not change this value.
+    Members marked with [w] mean the variable can be written to.  The user can set the value.
+    
+    There are 2 different ways to change a parameter in this architecture.
+    One is to use DSP::setParameter / DSP::getParameter.  This is platform independant and is dynamic, so new unknown plugins can have their parameters enumerated and used.
+    The other is to use DSP::showConfigDialog.  This is platform specific and requires a GUI, and will display a dialog box to configure the plugin.
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]    
+    System::createDSP
+    FMOD_DSP_STATE
+]
+*/
+typedef struct FMOD_DSP_DESCRIPTION
+{
+    char                         name[32];           /* [w] Name of the unit to be displayed in the network. */
+    unsigned int                 version;            /* [w] Plugin writer's version number. */
+    int                          channels;           /* [w] Number of channels.  Use 0 to process whatever number of channels is currently in the network.  >0 would be mostly used if the unit is a unit that only generates sound. */
+    FMOD_DSP_CREATECALLBACK      create;             /* [w] Create callback.  This is called when DSP unit is created.  Can be null. */
+    FMOD_DSP_RELEASECALLBACK     release;            /* [w] Release callback.  This is called just before the unit is freed so the user can do any cleanup needed for the unit.  Can be null. */
+    FMOD_DSP_RESETCALLBACK       reset;              /* [w] Reset callback.  This is called by the user to reset any history buffers that may need resetting for a filter, when it is to be used or re-used for the first time to its initial clean state.  Use to avoid clicks or artifacts. */
+    FMOD_DSP_READCALLBACK        read;               /* [w] Read callback.  Processing is done here.  Can be null. */
+    FMOD_DSP_SETPOSITIONCALLBACK setposition;        /* [w] Set position callback.  This is called if the unit wants to update its position info but not process data, or reset a cursor position internally if it is reading data from a certain source.  Can be null. */
+
+    int                          numparameters;      /* [w] Number of parameters used in this filter.  The user finds this with DSP::getNumParameters */
+    FMOD_DSP_PARAMETERDESC      *paramdesc;          /* [w] Variable number of parameter structures. */
+    FMOD_DSP_SETPARAMCALLBACK    setparameter;       /* [w] This is called when the user calls DSP::setParameter.  Can be null. */
+    FMOD_DSP_GETPARAMCALLBACK    getparameter;       /* [w] This is called when the user calls DSP::getParameter.  Can be null. */
+    FMOD_DSP_DIALOGCALLBACK      config;             /* [w] This is called when the user calls DSP::showConfigDialog.  Can be used to display a dialog to configure the filter.  Can be null. */
+    int                          configwidth;        /* [w] Width of config dialog graphic if there is one.  0 otherwise.*/
+    int                          configheight;       /* [w] Height of config dialog graphic if there is one.  0 otherwise.*/
+    void                        *userdata;           /* [w] Optional. Specify 0 to ignore. This is user data to be attached to the DSP unit during creation.  Access via DSP::getUserData. */
+} FMOD_DSP_DESCRIPTION;
+
+
+/*
+[STRUCTURE] 
+[
+    [DESCRIPTION]
+    DSP plugin structure that is passed into each callback.
+
+    [REMARKS]
+    Members marked with [r] mean the variable is modified by FMOD and is for reading purposes only.  Do not change this value.
+    Members marked with [w] mean the variable can be written to.  The user can set the value.
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]
+    FMOD_DSP_DESCRIPTION
+]
+*/
+struct FMOD_DSP_STATE
+{
+    FMOD_DSP      *instance;      /* [r] Handle to the DSP hand the user created.  Not to be modified.  C++ users cast to FMOD::DSP to use.  */
+    void          *plugindata;    /* [w] Plugin writer created data the output author wants to attach to this object. */
+	unsigned short speakermask;	  /* [w] Specifies which speakers the DSP effect is active on */
+};
+
+
+/*
+    ===================================================================================================
+
+    FMOD built in effect parameters.  
+    Use DSP::setParameter with these enums for the 'index' parameter.
+
+    ===================================================================================================
+*/
+
+/*
+[ENUM]
+[  
+    [DESCRIPTION]   
+    Parameter types for the FMOD_DSP_TYPE_OSCILLATOR filter.
+
+    [REMARKS]
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]      
+    DSP::setParameter
+    DSP::getParameter
+    FMOD_DSP_TYPE
+]
+*/
+typedef enum
+{
+    FMOD_DSP_OSCILLATOR_TYPE,   /* Waveform type.  0 = sine.  1 = square. 2 = sawup. 3 = sawdown. 4 = triangle. 5 = noise.  */
+    FMOD_DSP_OSCILLATOR_RATE    /* Frequency of the sinewave in hz.  1.0 to 22000.0.  Default = 220.0. */
+} FMOD_DSP_OSCILLATOR;
+
+
+/*
+[ENUM]
+[  
+    [DESCRIPTION]   
+    Parameter types for the FMOD_DSP_TYPE_LOWPASS filter.
+
+    [REMARKS]
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]      
+    DSP::setParameter
+    DSP::getParameter
+    FMOD_DSP_TYPE
+]
+*/
+typedef enum
+{
+    FMOD_DSP_LOWPASS_CUTOFF,    /* Lowpass cutoff frequency in hz.   10.0 to 22000.0.  Default = 5000.0. */
+    FMOD_DSP_LOWPASS_RESONANCE  /* Lowpass resonance Q value. 1.0 to 10.0.  Default = 1.0. */
+} FMOD_DSP_LOWPASS;
+
+
+/*
+[ENUM]
+[  
+    [DESCRIPTION]   
+    Parameter types for the FMOD_DSP_TYPE_ITLOWPASS filter.
+    This is different to the default FMOD_DSP_TYPE_ITLOWPASS filter in that it uses a different quality algorithm and is 
+    the filter used to produce the correct sounding playback in .IT files. 
+    FMOD Ex's .IT playback uses this filter.
+
+    [REMARKS]
+    Note! This filter actually has a limited cutoff frequency below the specified maximum, due to its limited design, 
+    so for a more  open range filter use FMOD_DSP_LOWPASS or if you don't mind not having resonance, 
+    FMOD_DSP_LOWPASS_SIMPLE.
+    The effective maximum cutoff is about 8060hz.
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]      
+    DSP::setParameter
+    DSP::getParameter
+    FMOD_DSP_TYPE
+]
+*/
+typedef enum
+{
+    FMOD_DSP_ITLOWPASS_CUTOFF,    /* Lowpass cutoff frequency in hz.  1.0 to 22000.0.  Default = 5000.0/ */
+    FMOD_DSP_ITLOWPASS_RESONANCE  /* Lowpass resonance Q value.  0.0 to 127.0.  Default = 1.0. */
+} FMOD_DSP_ITLOWPASS;
+
+
+/*
+[ENUM]
+[  
+    [DESCRIPTION]   
+    Parameter types for the FMOD_DSP_TYPE_HIGHPASS filter.
+
+    [REMARKS]
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]      
+    DSP::setParameter
+    DSP::getParameter
+    FMOD_DSP_TYPE
+]
+*/
+typedef enum
+{
+    FMOD_DSP_HIGHPASS_CUTOFF,    /* Highpass cutoff frequency in hz.  1.0 to output 22000.0.  Default = 5000.0. */
+    FMOD_DSP_HIGHPASS_RESONANCE  /* Highpass resonance Q value.  1.0 to 10.0.  Default = 1.0. */
+} FMOD_DSP_HIGHPASS;
+
+
+/*
+[ENUM]
+[  
+    [DESCRIPTION]   
+    Parameter types for the FMOD_DSP_TYPE_ECHO filter.
+
+    [REMARKS]
+    Note.  Every time the delay is changed, the plugin re-allocates the echo buffer.  This means the echo will dissapear at that time while it refills its new buffer.
+    Larger echo delays result in larger amounts of memory allocated.
+    
+    '<i>maxchannels</i>' also dictates the amount of memory allocated.  By default, the maxchannels value is 0.  If FMOD is set to stereo, the echo unit will allocate enough memory for 2 channels.  If it is 5.1, it will allocate enough memory for a 6 channel echo, etc.
+    If the echo effect is only ever applied to the global mix (ie it was added with System::addDSP), then 0 is the value to set as it will be enough to handle all speaker modes.
+    When the echo is added to a channel (ie Channel::addDSP) then the channel count that comes in could be anything from 1 to 8 possibly.  It is only in this case where you might want to increase the channel count above the output's channel count.
+    If a channel echo is set to a lower number than the sound's channel count that is coming in, it will not echo the sound.
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]      
+    DSP::setParameter
+    DSP::getParameter
+    FMOD_DSP_TYPE
+]
+*/
+typedef enum
+{
+    FMOD_DSP_ECHO_DELAY,       /* Echo delay in ms.  10  to 5000.  Default = 500. */
+    FMOD_DSP_ECHO_DECAYRATIO,  /* Echo decay per delay.  0 to 1.  1.0 = No decay, 0.0 = total decay (ie simple 1 line delay).  Default = 0.5. */
+    FMOD_DSP_ECHO_MAXCHANNELS, /* Maximum channels supported.  0 to 16.  0 = same as fmod's default output polyphony, 1 = mono, 2 = stereo etc.  See remarks for more.  Default = 0.  It is suggested to leave at 0! */
+    FMOD_DSP_ECHO_DRYMIX,      /* Volume of original signal to pass to output.  0.0 to 1.0. Default = 1.0. */
+    FMOD_DSP_ECHO_WETMIX       /* Volume of echo signal to pass to output.  0.0 to 1.0. Default = 1.0. */
+} FMOD_DSP_ECHO;
+
+
+/*
+[ENUM]
+[  
+    [DESCRIPTION]   
+    Parameter types for the FMOD_DSP_TYPE_DELAY filter.
+
+    [REMARKS]
+    Note.  Every time MaxDelay is changed, the plugin re-allocates the delay buffer.  This means the delay will dissapear at that time while it refills its new buffer.
+    A larger MaxDelay results in larger amounts of memory allocated.
+    Channel delays above MaxDelay will be clipped to MaxDelay and the delay buffer will not be resized.
+    
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]      
+    DSP::setParameter
+    DSP::getParameter
+    FMOD_DSP_TYPE
+]
+*/
+typedef enum
+{
+    FMOD_DSP_DELAY_CH0,      /* Channel #0 Delay in ms.  0  to 10000.  Default = 0. */
+    FMOD_DSP_DELAY_CH1,      /* Channel #1 Delay in ms.  0  to 10000.  Default = 0. */
+    FMOD_DSP_DELAY_CH2,      /* Channel #2 Delay in ms.  0  to 10000.  Default = 0. */
+    FMOD_DSP_DELAY_CH3,      /* Channel #3 Delay in ms.  0  to 10000.  Default = 0. */
+    FMOD_DSP_DELAY_CH4,      /* Channel #4 Delay in ms.  0  to 10000.  Default = 0. */
+    FMOD_DSP_DELAY_CH5,      /* Channel #5 Delay in ms.  0  to 10000.  Default = 0. */
+    FMOD_DSP_DELAY_CH6,      /* Channel #6 Delay in ms.  0  to 10000.  Default = 0. */
+    FMOD_DSP_DELAY_CH7,      /* Channel #7 Delay in ms.  0  to 10000.  Default = 0. */
+    FMOD_DSP_DELAY_CH8,      /* Channel #8 Delay in ms.  0  to 10000.  Default = 0. */
+    FMOD_DSP_DELAY_CH9,      /* Channel #9 Delay in ms.  0  to 10000.  Default = 0. */
+    FMOD_DSP_DELAY_CH10,     /* Channel #10 Delay in ms.  0  to 10000.  Default = 0. */
+    FMOD_DSP_DELAY_CH11,     /* Channel #11 Delay in ms.  0  to 10000.  Default = 0. */
+    FMOD_DSP_DELAY_CH12,     /* Channel #12 Delay in ms.  0  to 10000.  Default = 0. */
+    FMOD_DSP_DELAY_CH13,     /* Channel #13 Delay in ms.  0  to 10000.  Default = 0. */
+    FMOD_DSP_DELAY_CH14,     /* Channel #14 Delay in ms.  0  to 10000.  Default = 0. */
+    FMOD_DSP_DELAY_CH15,     /* Channel #15 Delay in ms.  0  to 10000.  Default = 0. */
+    FMOD_DSP_DELAY_MAXDELAY  /* Maximum delay in ms.  0  to 10000.  Default = 10. */
+} FMOD_DSP_DELAY;
+
+
+/*
+[ENUM]
+[  
+    [DESCRIPTION]   
+    Parameter types for the FMOD_DSP_TYPE_FLANGE filter.
+
+    [REMARKS]
+    Flange is an effect where the signal is played twice at the same time, and one copy slides back and forth creating a whooshing or flanging effect.
+    As there are 2 copies of the same signal, by default each signal is given 50% mix, so that the total is not louder than the original unaffected signal.
+    
+    Flange depth is a percentage of a 10ms shift from the original signal.  Anything above 10ms is not considered flange because to the ear it begins to 'echo' so 10ms is the highest value possible.
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]      
+    DSP::setParameter
+    DSP::getParameter
+    FMOD_DSP_TYPE
+]
+*/
+typedef enum
+{
+    FMOD_DSP_FLANGE_DRYMIX,      /* Volume of original signal to pass to output.  0.0 to 1.0. Default = 0.45. */
+    FMOD_DSP_FLANGE_WETMIX,      /* Volume of flange signal to pass to output.  0.0 to 1.0. Default = 0.55. */
+    FMOD_DSP_FLANGE_DEPTH,       /* Flange depth (percentage of 40ms delay).  0.01 to 1.0.  Default = 1.0. */
+    FMOD_DSP_FLANGE_RATE         /* Flange speed in hz.  0.0 to 20.0.  Default = 0.1. */
+} FMOD_DSP_FLANGE;
+
+
+/*
+[ENUM]
+[  
+    [DESCRIPTION]   
+    Parameter types for the FMOD_DSP_TYPE_TREMOLO filter.
+
+    [REMARKS]
+    The tremolo effect varies the amplitude of a sound. Depending on the settings, this unit can produce a tremolo, chopper or auto-pan effect.
+    
+    The shape of the LFO (low freq. oscillator) can morphed between sine, triangle and sawtooth waves using the FMOD_DSP_TREMOLO_SHAPE and FMOD_DSP_TREMOLO_SKEW parameters.
+    FMOD_DSP_TREMOLO_DUTY and FMOD_DSP_TREMOLO_SQUARE are useful for a chopper-type effect where the first controls the on-time duration and second controls the flatness of the envelope.
+    FMOD_DSP_TREMOLO_SPREAD varies the LFO phase between channels to get an auto-pan effect. This works best with a sine shape LFO.
+    The LFO can be synchronized using the FMOD_DSP_TREMOLO_PHASE parameter which sets its instantaneous phase.
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]      
+    DSP::setParameter
+    DSP::getParameter
+    FMOD_DSP_TYPE
+]
+*/
+typedef enum
+{
+    FMOD_DSP_TREMOLO_FREQUENCY,     /* LFO frequency in Hz.  0.1 to 20.  Default = 4. */
+    FMOD_DSP_TREMOLO_DEPTH,         /* Tremolo depth.  0 to 1.  Default = 0. */
+    FMOD_DSP_TREMOLO_SHAPE,         /* LFO shape morph between triangle and sine.  0 to 1.  Default = 0. */
+    FMOD_DSP_TREMOLO_SKEW,          /* Time-skewing of LFO cycle.  -1 to 1.  Default = 0. */
+    FMOD_DSP_TREMOLO_DUTY,          /* LFO on-time.  0 to 1.  Default = 0.5. */
+    FMOD_DSP_TREMOLO_SQUARE,        /* Flatness of the LFO shape.  0 to 1.  Default = 0. */
+    FMOD_DSP_TREMOLO_PHASE,         /* Instantaneous LFO phase.  0 to 1.  Default = 0. */
+    FMOD_DSP_TREMOLO_SPREAD         /* Rotation / auto-pan effect.  -1 to 1.  Default = 0. */
+} FMOD_DSP_TREMOLO;
+
+
+/*
+[ENUM]
+[  
+    [DESCRIPTION]   
+    Parameter types for the FMOD_DSP_TYPE_DISTORTION filter.
+
+    [REMARKS]
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]      
+    DSP::setParameter
+    DSP::getParameter
+    FMOD_DSP_TYPE
+]
+*/
+typedef enum
+{
+    FMOD_DSP_DISTORTION_LEVEL    /* Distortion value.  0.0 to 1.0.  Default = 0.5. */
+} FMOD_DSP_DISTORTION;
+
+
+/*
+[ENUM]
+[  
+    [DESCRIPTION]   
+    Parameter types for the FMOD_DSP_TYPE_NORMALIZE filter.
+
+    [REMARKS]
+    Normalize amplifies the sound based on the maximum peaks within the signal.
+    For example if the maximum peaks in the signal were 50% of the bandwidth, it would scale the whole sound by 2.
+    The lower threshold value makes the normalizer ignores peaks below a certain point, to avoid over-amplification if a loud signal suddenly came in, and also to avoid amplifying to maximum things like background hiss.
+    
+    Because FMOD is a realtime audio processor, it doesn't have the luxury of knowing the peak for the whole sound (ie it can't see into the future), so it has to process data as it comes in.
+    To avoid very sudden changes in volume level based on small samples of new data, fmod fades towards the desired amplification which makes for smooth gain control.  The fadetime parameter can control this.
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]      
+    DSP::setParameter
+    DSP::getParameter
+    FMOD_DSP_TYPE
+]
+*/
+typedef enum
+{
+    FMOD_DSP_NORMALIZE_FADETIME,    /* Time to ramp the silence to full in ms.  0.0 to 20000.0. Default = 5000.0. */
+    FMOD_DSP_NORMALIZE_THRESHHOLD,  /* Lower volume range threshold to ignore.  0.0 to 1.0.  Default = 0.1.  Raise higher to stop amplification of very quiet signals. */
+    FMOD_DSP_NORMALIZE_MAXAMP       /* Maximum amplification allowed.  1.0 to 100000.0.  Default = 20.0.  1.0 = no amplifaction, higher values allow more boost. */
+} FMOD_DSP_NORMALIZE;
+
+
+/*
+[ENUM]
+[  
+    [DESCRIPTION]   
+    Parameter types for the FMOD_DSP_TYPE_PARAMEQ filter.
+
+    [REMARKS]
+    Parametric EQ is a bandpass filter that attenuates or amplifies a selected frequency and its neighbouring frequencies.
+    
+    To create a multi-band EQ create multiple FMOD_DSP_TYPE_PARAMEQ units and set each unit to different frequencies, for example 1000hz, 2000hz, 4000hz, 8000hz, 16000hz with a range of 1 octave each.
+    
+    When a frequency has its gain set to 1.0, the sound will be unaffected and represents the original signal exactly.
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]      
+    DSP::setParameter
+    DSP::getParameter
+    FMOD_DSP_TYPE
+]
+*/
+typedef enum
+{
+    FMOD_DSP_PARAMEQ_CENTER,     /* Frequency center.  20.0 to 22000.0.  Default = 8000.0. */
+    FMOD_DSP_PARAMEQ_BANDWIDTH,  /* Octave range around the center frequency to filter.  0.2 to 5.0.  Default = 1.0. */
+    FMOD_DSP_PARAMEQ_GAIN        /* Frequency Gain.  0.05 to 3.0.  Default = 1.0.  */
+} FMOD_DSP_PARAMEQ;
+
+
+
+/*
+[ENUM]
+[  
+    [DESCRIPTION]   
+    Parameter types for the FMOD_DSP_TYPE_PITCHSHIFT filter.
+
+    [REMARKS]
+    This pitch shifting unit can be used to change the pitch of a sound without speeding it up or slowing it down.
+    It can also be used for time stretching or scaling, for example if the pitch was doubled, and the frequency of the sound was halved, the pitch of the sound would sound correct but it would be twice as slow.
+    
+    <b>Warning!</b> This filter is very computationally expensive!  Similar to a vocoder, it requires several overlapping FFT and IFFT's to produce smooth output, and can require around 440mhz for 1 stereo 48khz signal using the default settings.
+    Reducing the signal to mono will half the cpu usage.
+    Reducing this will lower audio quality, but what settings to use are largely dependant on the sound being played.  A noisy polyphonic signal will need higher fft size compared to a speaking voice for example.
+    
+    This pitch shifter is based on the pitch shifter code at http://www.dspdimension.com, written by Stephan M. Bernsee.
+    The original code is COPYRIGHT 1999-2003 Stephan M. Bernsee <smb@dspdimension.com>.
+    
+    '<i>maxchannels</i>' dictates the amount of memory allocated.  By default, the maxchannels value is 0.  If FMOD is set to stereo, the pitch shift unit will allocate enough memory for 2 channels.  If it is 5.1, it will allocate enough memory for a 6 channel pitch shift, etc.
+    If the pitch shift effect is only ever applied to the global mix (ie it was added with System::addDSP), then 0 is the value to set as it will be enough to handle all speaker modes.
+    When the pitch shift is added to a channel (ie Channel::addDSP) then the channel count that comes in could be anything from 1 to 8 possibly.  It is only in this case where you might want to increase the channel count above the output's channel count.
+    If a channel pitch shift is set to a lower number than the sound's channel count that is coming in, it will not pitch shift the sound.
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]      
+    DSP::setParameter
+    DSP::getParameter
+    FMOD_DSP_TYPE
+]
+*/
+typedef enum
+{
+    FMOD_DSP_PITCHSHIFT_PITCH,       /* Pitch value.  0.5 to 2.0.  Default = 1.0. 0.5 = one octave down, 2.0 = one octave up.  1.0 does not change the pitch. */
+    FMOD_DSP_PITCHSHIFT_FFTSIZE,     /* FFT window size.  256, 512, 1024, 2048, 4096.  Default = 1024.  Increase this to reduce 'smearing'.  This effect is a warbling sound similar to when an mp3 is encoded at very low bitrates. */
+    FMOD_DSP_PITCHSHIFT_OVERLAP,     /* Removed.  Do not use.  FMOD now uses 4 overlaps and cannot be changed. */
+    FMOD_DSP_PITCHSHIFT_MAXCHANNELS  /* Maximum channels supported.  0 to 16.  0 = same as fmod's default output polyphony, 1 = mono, 2 = stereo etc.  See remarks for more.  Default = 0.  It is suggested to leave at 0! */
+} FMOD_DSP_PITCHSHIFT;
+
+
+
+/*
+[ENUM]
+[  
+    [DESCRIPTION]   
+    Parameter types for the FMOD_DSP_TYPE_CHORUS filter.
+
+    [REMARKS]
+    Chrous is an effect where the sound is more 'spacious' due to 1 to 3 versions of the sound being played along side the original signal but with the pitch of each copy modulating on a sine wave.
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]      
+    DSP::setParameter
+    DSP::getParameter
+    FMOD_DSP_TYPE
+]
+*/
+typedef enum
+{
+    FMOD_DSP_CHORUS_DRYMIX,   /* Volume of original signal to pass to output.  0.0 to 1.0. Default = 0.5. */
+    FMOD_DSP_CHORUS_WETMIX1,  /* Volume of 1st chorus tap.  0.0 to 1.0.  Default = 0.5. */
+    FMOD_DSP_CHORUS_WETMIX2,  /* Volume of 2nd chorus tap. This tap is 90 degrees out of phase of the first tap.  0.0 to 1.0.  Default = 0.5. */
+    FMOD_DSP_CHORUS_WETMIX3,  /* Volume of 3rd chorus tap. This tap is 90 degrees out of phase of the second tap.  0.0 to 1.0.  Default = 0.5. */
+    FMOD_DSP_CHORUS_DELAY,    /* Chorus delay in ms.  0.1 to 100.0.  Default = 40.0 ms. */
+    FMOD_DSP_CHORUS_RATE,     /* Chorus modulation rate in hz.  0.0 to 20.0.  Default = 0.8 hz. */
+    FMOD_DSP_CHORUS_DEPTH     /* Chorus modulation depth.  0.0 to 1.0.  Default = 0.03. */
+} FMOD_DSP_CHORUS;
+
+
+/*
+[ENUM]
+[  
+    [DESCRIPTION]   
+    Parameter types for the FMOD_DSP_TYPE_ITECHO filter.
+    This is effectively a software based echo filter that emulates the DirectX DMO echo effect.  Impulse tracker files can support this, and FMOD will produce the effect on ANY platform, not just those that support DirectX effects!
+
+    [REMARKS]
+    Note.  Every time the delay is changed, the plugin re-allocates the echo buffer.  This means the echo will dissapear at that time while it refills its new buffer.
+    Larger echo delays result in larger amounts of memory allocated.
+    
+    As this is a stereo filter made mainly for IT playback, it is targeted for stereo signals.
+    With mono signals only the FMOD_DSP_ITECHO_LEFTDELAY is used.
+    For multichannel signals (>2) there will be no echo on those channels.
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]      
+    DSP::SetParameter
+    DSP::GetParameter
+    FMOD_DSP_TYPE
+    System::addDSP
+]
+*/
+typedef enum
+{
+    FMOD_DSP_ITECHO_WETDRYMIX,      /* Ratio of wet (processed) signal to dry (unprocessed) signal. Must be in the range from 0.0 through 100.0 (all wet). The default value is 50. */
+    FMOD_DSP_ITECHO_FEEDBACK,       /* Percentage of output fed back into input, in the range from 0.0 through 100.0. The default value is 50. */
+    FMOD_DSP_ITECHO_LEFTDELAY,      /* Delay for left channel, in milliseconds, in the range from 1.0 through 2000.0. The default value is 500 ms. */
+    FMOD_DSP_ITECHO_RIGHTDELAY,     /* Delay for right channel, in milliseconds, in the range from 1.0 through 2000.0. The default value is 500 ms. */
+    FMOD_DSP_ITECHO_PANDELAY        /* Value that specifies whether to swap left and right delays with each successive echo. The default value is zero, meaning no swap. Possible values are defined as 0.0 (equivalent to FALSE) and 1.0 (equivalent to TRUE).  CURRENTLY NOT SUPPORTED. */
+} FMOD_DSP_ITECHO;
+
+/*
+[ENUM]
+[  
+    [DESCRIPTION]   
+    Parameter types for the FMOD_DSP_TYPE_COMPRESSOR unit.
+    This is a simple linked multichannel software limiter that is uniform across the whole spectrum.
+
+    [REMARKS]
+    The limiter is not guaranteed to catch every peak above the threshold level,
+    because it cannot apply gain reduction instantaneously - the time delay is
+    determined by the attack time. However setting the attack time too short will
+    distort the sound, so it is a compromise. High level peaks can be avoided by
+    using a short attack time - but not too short, and setting the threshold a few
+    decibels below the critical level.
+    
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]      
+    DSP::SetParameter
+    DSP::GetParameter
+    FMOD_DSP_TYPE
+    System::addDSP
+]
+*/
+typedef enum
+{
+    FMOD_DSP_COMPRESSOR_THRESHOLD,  /* Threshold level (dB) in the range from -60 through 0. The default value is 0. */ 
+    FMOD_DSP_COMPRESSOR_ATTACK,     /* Gain reduction attack time (milliseconds), in the range from 10 through 200. The default value is 50. */
+    FMOD_DSP_COMPRESSOR_RELEASE,    /* Gain reduction release time (milliseconds), in the range from 20 through 1000. The default value is 50. */
+    FMOD_DSP_COMPRESSOR_GAINMAKEUP  /* Make-up gain (dB) applied after limiting, in the range from 0 through 30. The default value is 0. */
+} FMOD_DSP_COMPRESSOR;
+
+/*
+[ENUM]
+[  
+    [DESCRIPTION]   
+    Parameter types for the FMOD_DSP_TYPE_SFXREVERB unit.
+    
+    [REMARKS]
+    This is a high quality I3DL2 based reverb.
+    On top of the I3DL2 property set, "Dry Level" is also included to allow the dry mix to be changed.
+    
+    These properties can be set with presets in FMOD_REVERB_PRESETS.
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]      
+    DSP::SetParameter
+    DSP::GetParameter
+    FMOD_DSP_TYPE
+    System::addDSP
+    FMOD_REVERB_PRESETS
+]
+*/
+typedef enum
+{
+    FMOD_DSP_SFXREVERB_DRYLEVEL,            /* Dry Level      : Mix level of dry signal in output in mB.  Ranges from -10000.0 to 0.0.  Default is 0. */
+    FMOD_DSP_SFXREVERB_ROOM,                /* Room           : Room effect level at low frequencies in mB.  Ranges from -10000.0 to 0.0.  Default is -10000.0. */
+    FMOD_DSP_SFXREVERB_ROOMHF,              /* Room HF        : Room effect high-frequency level re. low frequency level in mB.  Ranges from -10000.0 to 0.0.  Default is 0.0. */
+    FMOD_DSP_SFXREVERB_DECAYTIME,           /* Decay Time     : Reverberation decay time at low-frequencies in seconds.  Ranges from 0.1 to 20.0. Default is 1.0. */
+    FMOD_DSP_SFXREVERB_DECAYHFRATIO,        /* Decay HF Ratio : High-frequency to low-frequency decay time ratio.  Ranges from 0.1 to 2.0. Default is 0.5. */
+    FMOD_DSP_SFXREVERB_REFLECTIONSLEVEL,    /* Reflections    : Early reflections level relative to room effect in mB.  Ranges from -10000.0 to 1000.0.  Default is -10000.0. */
+    FMOD_DSP_SFXREVERB_REFLECTIONSDELAY,    /* Reflect Delay  : Delay time of first reflection in seconds.  Ranges from 0.0 to 0.3.  Default is 0.02. */
+    FMOD_DSP_SFXREVERB_REVERBLEVEL,         /* Reverb         : Late reverberation level relative to room effect in mB.  Ranges from -10000.0 to 2000.0.  Default is 0.0. */
+    FMOD_DSP_SFXREVERB_REVERBDELAY,         /* Reverb Delay   : Late reverberation delay time relative to first reflection in seconds.  Ranges from 0.0 to 0.1.  Default is 0.04. */
+    FMOD_DSP_SFXREVERB_DIFFUSION,           /* Diffusion      : Reverberation diffusion (echo density) in percent.  Ranges from 0.0 to 100.0.  Default is 100.0. */
+    FMOD_DSP_SFXREVERB_DENSITY,             /* Density        : Reverberation density (modal density) in percent.  Ranges from 0.0 to 100.0.  Default is 100.0. */
+    FMOD_DSP_SFXREVERB_HFREFERENCE,         /* HF Reference   : Reference high frequency in Hz.  Ranges from 20.0 to 20000.0. Default is 5000.0. */
+    FMOD_DSP_SFXREVERB_ROOMLF,              /* Room LF        : Room effect low-frequency level in mB.  Ranges from -10000.0 to 0.0.  Default is 0.0. */
+    FMOD_DSP_SFXREVERB_LFREFERENCE          /* LF Reference   : Reference low-frequency in Hz.  Ranges from 20.0 to 1000.0. Default is 250.0. */
+} FMOD_DSP_SFXREVERB;
+
+/*
+[ENUM]
+[  
+    [DESCRIPTION]   
+    Parameter types for the FMOD_DSP_TYPE_LOWPASS_SIMPLE filter.
+    This is a very simple low pass filter, based on two single-pole RC time-constant modules.
+    The emphasis is on speed rather than accuracy, so this should not be used for task requiring critical filtering. 
+
+    [REMARKS]
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]      
+    DSP::setParameter
+    DSP::getParameter
+    FMOD_DSP_TYPE
+]
+*/
+typedef enum
+{
+    FMOD_DSP_LOWPASS_SIMPLE_CUTOFF     /* Lowpass cutoff frequency in hz.  10.0 to 22000.0.  Default = 5000.0 */
+} FMOD_DSP_LOWPASS_SIMPLE;
+
+/*
+[ENUM]
+[  
+    [DESCRIPTION]   
+    Parameter types for the FMOD_DSP_TYPE_HIGHPASS_SIMPLE filter.
+    This is a very simple single-order high pass filter.
+    The emphasis is on speed rather than accuracy, so this should not be used for task requiring critical filtering. 
+
+    [REMARKS]
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]      
+    DSP::setParameter
+    DSP::getParameter
+    FMOD_DSP_TYPE
+]
+*/
+typedef enum
+{
+    FMOD_DSP_HIGHPASS_SIMPLE_CUTOFF     /* Highpass cutoff frequency in hz.  10.0 to 22000.0.  Default = 1000.0 */
+} FMOD_DSP_HIGHPASS_SIMPLE;
+
+#endif
+

libs/FMOD/inc/fmod_errors.h

@@ -0,0 +1,123 @@
+
+/* ============================================================================================== */
+/* FMOD Ex - Error string header file. Copyright (c), Firelight Technologies Pty, Ltd. 2004-2014. */
+/*                                                                                                */
+/* Use this header if you want to store or display a string version / english explanation of      */
+/* the FMOD error codes.                                                                          */
+/*                                                                                                */
+/* ============================================================================================== */
+
+#ifndef _FMOD_ERRORS_H
+#define _FMOD_ERRORS_H
+
+#include "fmod.h"
+
+#ifdef __GNUC__ 
+static const char *FMOD_ErrorString(FMOD_RESULT errcode) __attribute__((unused));
+#endif
+
+static const char *FMOD_ErrorString(FMOD_RESULT errcode)
+{
+    switch (errcode)
+    {
+        case FMOD_ERR_ALREADYLOCKED:          return "Tried to call lock a second time before unlock was called. ";
+        case FMOD_ERR_BADCOMMAND:             return "Tried to call a function on a data type that does not allow this type of functionality (ie calling Sound::lock on a streaming sound). ";
+        case FMOD_ERR_CDDA_DRIVERS:           return "Neither NTSCSI nor ASPI could be initialised. ";
+        case FMOD_ERR_CDDA_INIT:              return "An error occurred while initialising the CDDA subsystem. ";
+        case FMOD_ERR_CDDA_INVALID_DEVICE:    return "Couldn't find the specified device. ";
+        case FMOD_ERR_CDDA_NOAUDIO:           return "No audio tracks on the specified disc. ";
+        case FMOD_ERR_CDDA_NODEVICES:         return "No CD/DVD devices were found. ";
+        case FMOD_ERR_CDDA_NODISC:            return "No disc present in the specified drive. ";
+        case FMOD_ERR_CDDA_READ:              return "A CDDA read error occurred. ";
+        case FMOD_ERR_CHANNEL_ALLOC:          return "Error trying to allocate a channel. ";
+        case FMOD_ERR_CHANNEL_STOLEN:         return "The specified channel has been reused to play another sound. ";
+        case FMOD_ERR_COM:                    return "A Win32 COM related error occured. COM failed to initialize or a QueryInterface failed meaning a Windows codec or driver was not installed properly. ";
+        case FMOD_ERR_DMA:                    return "DMA Failure.  See debug output for more information. ";
+        case FMOD_ERR_DSP_CONNECTION:         return "DSP connection error.  Connection possibly caused a cyclic dependancy.  Or tried to connect a tree too many units deep (more than 128). ";
+        case FMOD_ERR_DSP_FORMAT:             return "DSP Format error.  A DSP unit may have attempted to connect to this network with the wrong format. ";
+        case FMOD_ERR_DSP_NOTFOUND:           return "DSP connection error.  Couldn't find the DSP unit specified. ";
+        case FMOD_ERR_DSP_RUNNING:            return "DSP error.  Cannot perform this operation while the network is in the middle of running.  This will most likely happen if a connection or disconnection is attempted in a DSP callback. ";
+        case FMOD_ERR_DSP_TOOMANYCONNECTIONS: return "DSP connection error.  The unit being connected to or disconnected should only have 1 input or output. ";
+        case FMOD_ERR_EVENT_ALREADY_LOADED:   return "The specified project or bank has already been loaded. Having multiple copies of the same project loaded simultaneously is forbidden. ";
+        case FMOD_ERR_EVENT_FAILED:           return "An Event failed to be retrieved, most likely due to 'just fail' being specified as the max playbacks behavior. ";
+        case FMOD_ERR_EVENT_GUIDCONFLICT:     return "An event with the same GUID already exists. ";
+        case FMOD_ERR_EVENT_INFOONLY:         return "Can't execute this command on an EVENT_INFOONLY event. ";
+        case FMOD_ERR_EVENT_INTERNAL:         return "An error occured that wasn't supposed to.  See debug log for reason. ";
+        case FMOD_ERR_EVENT_MAXSTREAMS:       return "Event failed because 'Max streams' was hit when FMOD_EVENT_INIT_FAIL_ON_MAXSTREAMS was specified. ";
+        case FMOD_ERR_EVENT_MISMATCH:         return "FSB mismatches the FEV it was compiled with, the stream/sample mode it was meant to be created with was different, or the FEV was built for a different platform. ";
+        case FMOD_ERR_EVENT_NAMECONFLICT:     return "A category with the same name already exists. ";
+        case FMOD_ERR_EVENT_NEEDSSIMPLE:      return "Tried to call a function on a complex event that's only supported by simple events. ";
+        case FMOD_ERR_EVENT_NOTFOUND:         return "The requested event, event group, event category or event property could not be found. ";
+        case FMOD_ERR_FILE_BAD:               return "Error loading file. ";
+        case FMOD_ERR_FILE_COULDNOTSEEK:      return "Couldn't perform seek operation.  This is a limitation of the medium (ie netstreams) or the file format. ";
+        case FMOD_ERR_FILE_DISKEJECTED:       return "Media was ejected while reading. ";
+        case FMOD_ERR_FILE_EOF:               return "End of file unexpectedly reached while trying to read essential data (truncated data?). ";
+        case FMOD_ERR_FILE_NOTFOUND:          return "File not found. ";
+        case FMOD_ERR_FILE_UNWANTED:          return "Unwanted file access occured. ";
+        case FMOD_ERR_FORMAT:                 return "Unsupported file or audio format. ";
+        case FMOD_ERR_HTTP:                   return "A HTTP error occurred. This is a catch-all for HTTP errors not listed elsewhere. ";
+        case FMOD_ERR_HTTP_ACCESS:            return "The specified resource requires authentication or is forbidden. ";
+        case FMOD_ERR_HTTP_PROXY_AUTH:        return "Proxy authentication is required to access the specified resource. ";
+        case FMOD_ERR_HTTP_SERVER_ERROR:      return "A HTTP server error occurred. ";
+        case FMOD_ERR_HTTP_TIMEOUT:           return "The HTTP request timed out. ";
+        case FMOD_ERR_INITIALIZATION:         return "FMOD was not initialized correctly to support this function. ";
+        case FMOD_ERR_INITIALIZED:            return "Cannot call this command after System::init. ";
+        case FMOD_ERR_INTERNAL:               return "An error occured that wasn't supposed to.  Contact support. ";
+        case FMOD_ERR_INVALID_ADDRESS:        return "On Xbox 360, this memory address passed to FMOD must be physical, (ie allocated with XPhysicalAlloc.) ";
+        case FMOD_ERR_INVALID_FLOAT:          return "Value passed in was a NaN, Inf or denormalized float. ";
+        case FMOD_ERR_INVALID_HANDLE:         return "An invalid object handle was used. ";
+        case FMOD_ERR_INVALID_PARAM:          return "An invalid parameter was passed to this function. ";
+        case FMOD_ERR_INVALID_POSITION:       return "An invalid seek position was passed to this function. ";
+        case FMOD_ERR_INVALID_SPEAKER:        return "An invalid speaker was passed to this function based on the current speaker mode. ";
+        case FMOD_ERR_INVALID_SYNCPOINT:      return "The syncpoint did not come from this sound handle. ";
+        case FMOD_ERR_INVALID_VECTOR:         return "The vectors passed in are not unit length, or perpendicular. ";
+        case FMOD_ERR_MAXAUDIBLE:             return "Reached maximum audible playback count for this sound's soundgroup. ";
+        case FMOD_ERR_MEMORY:                 return "Not enough memory or resources. ";
+        case FMOD_ERR_MEMORY_CANTPOINT:       return "Can't use FMOD_OPENMEMORY_POINT on non PCM source data, or non mp3/xma/adpcm data if FMOD_CREATECOMPRESSEDSAMPLE was used. ";
+        case FMOD_ERR_MEMORY_SRAM:            return "Not enough memory or resources on console sound ram. ";
+        case FMOD_ERR_MUSIC_NOCALLBACK:       return "The music callback is required, but it has not been set. ";
+        case FMOD_ERR_MUSIC_NOTFOUND:         return "The requested music entity could not be found. ";
+        case FMOD_ERR_MUSIC_UNINITIALIZED:    return "Music system is not initialized probably because no music data is loaded. ";
+        case FMOD_ERR_NEEDS2D:                return "Tried to call a command on a 3d sound when the command was meant for 2d sound. ";
+        case FMOD_ERR_NEEDS3D:                return "Tried to call a command on a 2d sound when the command was meant for 3d sound. ";
+        case FMOD_ERR_NEEDSHARDWARE:          return "Tried to use a feature that requires hardware support.  (ie trying to play a GCADPCM compressed sound in software on Wii). ";
+        case FMOD_ERR_NEEDSSOFTWARE:          return "Tried to use a feature that requires the software engine.  Software engine has either been turned off, or command was executed on a hardware channel which does not support this feature. ";
+        case FMOD_ERR_NET_CONNECT:            return "Couldn't connect to the specified host. ";
+        case FMOD_ERR_NET_SOCKET_ERROR:       return "A socket error occurred.  This is a catch-all for socket-related errors not listed elsewhere. ";
+        case FMOD_ERR_NET_URL:                return "The specified URL couldn't be resolved. ";
+        case FMOD_ERR_NET_WOULD_BLOCK:        return "Operation on a non-blocking socket could not complete immediately. ";
+        case FMOD_ERR_NOTREADY:               return "Operation could not be performed because specified sound/DSP connection is not ready. ";
+        case FMOD_ERR_OUTPUT_ALLOCATED:       return "Error initializing output device, but more specifically, the output device is already in use and cannot be reused. ";
+        case FMOD_ERR_OUTPUT_CREATEBUFFER:    return "Error creating hardware sound buffer. ";
+        case FMOD_ERR_OUTPUT_DRIVERCALL:      return "A call to a standard soundcard driver failed, which could possibly mean a bug in the driver or resources were missing or exhausted. ";
+        case FMOD_ERR_OUTPUT_ENUMERATION:     return "Error enumerating the available driver list. List may be inconsistent due to a recent device addition or removal. ";
+        case FMOD_ERR_OUTPUT_FORMAT:          return "Soundcard does not support the minimum features needed for this soundsystem (16bit stereo output). ";
+        case FMOD_ERR_OUTPUT_INIT:            return "Error initializing output device. ";
+        case FMOD_ERR_OUTPUT_NOHARDWARE:      return "FMOD_HARDWARE was specified but the sound card does not have the resources necessary to play it. ";
+        case FMOD_ERR_OUTPUT_NOSOFTWARE:      return "Attempted to create a software sound but no software channels were specified in System::init. ";
+        case FMOD_ERR_PAN:                    return "Panning only works with mono or stereo sound sources. ";
+        case FMOD_ERR_PLUGIN:                 return "An unspecified error has been returned from a 3rd party plugin. ";
+        case FMOD_ERR_PLUGIN_INSTANCES:       return "The number of allowed instances of a plugin has been exceeded. ";
+        case FMOD_ERR_PLUGIN_MISSING:         return "A requested output, dsp unit type or codec was not available. ";
+        case FMOD_ERR_PLUGIN_RESOURCE:        return "A resource that the plugin requires cannot be found. (ie the DLS file for MIDI playback or other DLLs that it needs to load) ";
+        case FMOD_ERR_PRELOADED:              return "The specified sound is still in use by the event system, call EventSystem::unloadFSB before trying to release it. ";
+        case FMOD_ERR_PROGRAMMERSOUND:        return "The specified sound is still in use by the event system, wait for the event which is using it finish with it. ";
+        case FMOD_ERR_RECORD:                 return "An error occured trying to initialize the recording device. ";
+        case FMOD_ERR_REVERB_INSTANCE:        return "Specified instance in FMOD_REVERB_PROPERTIES couldn't be set. Most likely because it is an invalid instance number or the reverb doesnt exist. ";
+        case FMOD_ERR_SUBSOUNDS:              return "The error occured because the sound referenced contains subsounds when it shouldn't have, or it doesn't contain subsounds when it should have.  The operation may also not be able to be performed on a parent sound, or a parent sound was played without setting up a sentence first. ";
+        case FMOD_ERR_SUBSOUND_ALLOCATED:     return "This subsound is already being used by another sound, you cannot have more than one parent to a sound.  Null out the other parent's entry first. ";
+        case FMOD_ERR_SUBSOUND_CANTMOVE:      return "Shared subsounds cannot be replaced or moved from their parent stream, such as when the parent stream is an FSB file. ";
+        case FMOD_ERR_SUBSOUND_MODE:          return "The subsound's mode bits do not match with the parent sound's mode bits.  See documentation for function that it was called with. ";
+        case FMOD_ERR_TAGNOTFOUND:            return "The specified tag could not be found or there are no tags. ";
+        case FMOD_ERR_TOOMANYCHANNELS:        return "The sound created exceeds the allowable input channel count.  This can be increased using the maxinputchannels parameter in System::setSoftwareFormat. ";
+        case FMOD_ERR_UNIMPLEMENTED:          return "Something in FMOD hasn't been implemented when it should be! contact support! ";
+        case FMOD_ERR_UNINITIALIZED:          return "This command failed because System::init or System::setDriver was not called. ";
+        case FMOD_ERR_UNSUPPORTED:            return "A command issued was not supported by this object.  Possibly a plugin without certain callbacks specified. ";
+        case FMOD_ERR_UPDATE:                 return "An error caused by System::update occured. ";
+        case FMOD_ERR_VERSION:                return "The version number of this file format is not supported. ";
+        case FMOD_OK:                         return "No errors.";
+        default :                             return "Unknown error.";
+    };
+}
+
+#endif

libs/FMOD/inc/fmod_memoryinfo.h

@@ -0,0 +1,201 @@
+/* ============================================================================================= */
+/* FMOD Ex - Memory info header file. Copyright (c), Firelight Technologies Pty, Ltd. 2008-2014. */
+/*                                                                                               */
+/* Use this header if you are interested in getting detailed information on FMOD's memory        */
+/* usage. See the documentation for more details.                                                */
+/*                                                                                               */
+/* ============================================================================================= */
+
+#ifndef _FMOD_MEMORYINFO_H
+#define _FMOD_MEMORYINFO_H
+
+/*
+[STRUCTURE]
+[
+    [DESCRIPTION]
+    Structure to be filled with detailed memory usage information of an FMOD object
+
+    [REMARKS]
+    Every public FMOD class has a getMemoryInfo function which can be used to get detailed information on what memory resources are associated with the object in question. 
+    On return from getMemoryInfo, each member of this structure will hold the amount of memory used for its type in bytes.
+    
+    Members marked with [in] mean the user sets the value before passing it to the function.
+    Members marked with [out] mean FMOD sets the value to be used after the function exits.
+
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]
+    System::getMemoryInfo
+    EventSystem::getMemoryInfo
+    FMOD_MEMBITS    
+    FMOD_EVENT_MEMBITS
+]
+*/
+typedef struct FMOD_MEMORY_USAGE_DETAILS
+{
+    unsigned int other;                          /* [out] Memory not accounted for by other types */
+    unsigned int string;                         /* [out] String data */
+    unsigned int system;                         /* [out] System object and various internals */
+    unsigned int plugins;                        /* [out] Plugin objects and internals */
+    unsigned int output;                         /* [out] Output module object and internals */
+    unsigned int channel;                        /* [out] Channel related memory */
+    unsigned int channelgroup;                   /* [out] ChannelGroup objects and internals */
+    unsigned int codec;                          /* [out] Codecs allocated for streaming */
+    unsigned int file;                           /* [out] File buffers and structures */
+    unsigned int sound;                          /* [out] Sound objects and internals */
+    unsigned int secondaryram;                   /* [out] Sound data stored in secondary RAM */
+    unsigned int soundgroup;                     /* [out] SoundGroup objects and internals */
+    unsigned int streambuffer;                   /* [out] Stream buffer memory */
+    unsigned int dspconnection;                  /* [out] DSPConnection objects and internals */
+    unsigned int dsp;                            /* [out] DSP implementation objects */
+    unsigned int dspcodec;                       /* [out] Realtime file format decoding DSP objects */
+    unsigned int profile;                        /* [out] Profiler memory footprint. */
+    unsigned int recordbuffer;                   /* [out] Buffer used to store recorded data from microphone */
+    unsigned int reverb;                         /* [out] Reverb implementation objects */
+    unsigned int reverbchannelprops;             /* [out] Reverb channel properties structs */
+    unsigned int geometry;                       /* [out] Geometry objects and internals */
+    unsigned int syncpoint;                      /* [out] Sync point memory. */
+    unsigned int eventsystem;                    /* [out] EventSystem and various internals */
+    unsigned int musicsystem;                    /* [out] MusicSystem and various internals */
+    unsigned int fev;                            /* [out] Definition of objects contained in all loaded projects e.g. events, groups, categories */
+    unsigned int memoryfsb;                      /* [out] Data loaded with preloadFSB */
+    unsigned int eventproject;                   /* [out] EventProject objects and internals */
+    unsigned int eventgroupi;                    /* [out] EventGroup objects and internals */
+    unsigned int soundbankclass;                 /* [out] Objects used to manage wave banks */
+    unsigned int soundbanklist;                  /* [out] Data used to manage lists of wave bank usage */
+    unsigned int streaminstance;                 /* [out] Stream objects and internals */
+    unsigned int sounddefclass;                  /* [out] Sound definition objects */
+    unsigned int sounddefdefclass;               /* [out] Sound definition static data objects */
+    unsigned int sounddefpool;                   /* [out] Sound definition pool data */
+    unsigned int reverbdef;                      /* [out] Reverb definition objects */
+    unsigned int eventreverb;                    /* [out] Reverb objects */
+    unsigned int userproperty;                   /* [out] User property objects */
+    unsigned int eventinstance;                  /* [out] Event instance base objects */
+    unsigned int eventinstance_complex;          /* [out] Complex event instance objects */
+    unsigned int eventinstance_simple;           /* [out] Simple event instance objects */
+    unsigned int eventinstance_layer;            /* [out] Event layer instance objects */
+    unsigned int eventinstance_sound;            /* [out] Event sound instance objects */
+    unsigned int eventenvelope;                  /* [out] Event envelope objects */
+    unsigned int eventenvelopedef;               /* [out] Event envelope definition objects */
+    unsigned int eventparameter;                 /* [out] Event parameter objects */
+    unsigned int eventcategory;                  /* [out] Event category objects */
+    unsigned int eventenvelopepoint;             /* [out] Event envelope point objects */
+    unsigned int eventinstancepool;              /* [out] Event instance pool memory */
+} FMOD_MEMORY_USAGE_DETAILS;
+
+
+/*
+[DEFINE]
+[
+    [NAME]
+    FMOD_MEMBITS
+
+    [DESCRIPTION]
+    Bitfield used to request specific memory usage information from the getMemoryInfo function of every public FMOD Ex class.
+    Use with the "memorybits" parameter of getMemoryInfo to get information on FMOD Ex memory usage.
+
+    [REMARKS]
+    Every public FMOD class has a getMemoryInfo function which can be used to get detailed information on what memory resources are associated with the object in question. 
+    The FMOD_MEMBITS defines can be OR'd together to specify precisely what memory usage you'd like to get information on. See System::getMemoryInfo for an example.
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]
+    FMOD_EVENT_MEMBITS
+    System::getMemoryInfo
+]
+*/
+#define FMOD_MEMBITS_OTHER                       0x00000001  /* Memory not accounted for by other types */
+#define FMOD_MEMBITS_STRING                      0x00000002  /* String data */
+
+#define FMOD_MEMBITS_SYSTEM                      0x00000004  /* System object and various internals */
+#define FMOD_MEMBITS_PLUGINS                     0x00000008  /* Plugin objects and internals */
+#define FMOD_MEMBITS_OUTPUT                      0x00000010  /* Output module object and internals */
+#define FMOD_MEMBITS_CHANNEL                     0x00000020  /* Channel related memory */
+#define FMOD_MEMBITS_CHANNELGROUP                0x00000040  /* ChannelGroup objects and internals */
+#define FMOD_MEMBITS_CODEC                       0x00000080  /* Codecs allocated for streaming */
+#define FMOD_MEMBITS_FILE                        0x00000100  /* Codecs allocated for streaming */
+#define FMOD_MEMBITS_SOUND                       0x00000200  /* Sound objects and internals */
+#define FMOD_MEMBITS_SOUND_SECONDARYRAM          0x00000400  /* Sound data stored in secondary RAM */
+#define FMOD_MEMBITS_SOUNDGROUP                  0x00000800  /* SoundGroup objects and internals */
+#define FMOD_MEMBITS_STREAMBUFFER                0x00001000  /* Stream buffer memory */
+#define FMOD_MEMBITS_DSPCONNECTION               0x00002000  /* DSPConnection objects and internals */
+#define FMOD_MEMBITS_DSP                         0x00004000  /* DSP implementation objects */
+#define FMOD_MEMBITS_DSPCODEC                    0x00008000  /* Realtime file format decoding DSP objects */
+#define FMOD_MEMBITS_PROFILE                     0x00010000  /* Profiler memory footprint. */
+#define FMOD_MEMBITS_RECORDBUFFER                0x00020000  /* Buffer used to store recorded data from microphone */
+#define FMOD_MEMBITS_REVERB                      0x00040000  /* Reverb implementation objects */
+#define FMOD_MEMBITS_REVERBCHANNELPROPS          0x00080000  /* Reverb channel properties structs */
+#define FMOD_MEMBITS_GEOMETRY                    0x00100000  /* Geometry objects and internals */
+#define FMOD_MEMBITS_SYNCPOINT                   0x00200000  /* Sync point memory. */
+#define FMOD_MEMBITS_ALL                         0xffffffff  /* All memory used by FMOD Ex */
+/* [DEFINE_END] */
+
+
+/*
+[DEFINE]
+[
+    [NAME]
+    FMOD_EVENT_MEMBITS
+
+    [DESCRIPTION]
+    Bitfield used to request specific memory usage information from the getMemoryInfo function of every public FMOD Event System class.
+    Use with the "event_memorybits" parameter of getMemoryInfo to get information on FMOD Event System memory usage.
+
+    [REMARKS]
+    Every public FMOD Event System class has a getMemoryInfo function which can be used to get detailed information on what memory resources are associated with the object in question. 
+    The FMOD_EVENT_MEMBITS defines can be OR'd together to specify precisely what memory usage you'd like to get information on. See EventSystem::getMemoryInfo for an example.
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]
+    FMOD_MEMBITS
+    System::getMemoryInfo
+]
+*/                                               
+#define FMOD_EVENT_MEMBITS_EVENTSYSTEM           0x00000001  /* EventSystem and various internals */
+#define FMOD_EVENT_MEMBITS_MUSICSYSTEM           0x00000002  /* MusicSystem and various internals */
+#define FMOD_EVENT_MEMBITS_FEV                   0x00000004  /* Definition of objects contained in all loaded projects e.g. events, groups, categories */
+#define FMOD_EVENT_MEMBITS_MEMORYFSB             0x00000008  /* Data loaded with preloadFSB */
+#define FMOD_EVENT_MEMBITS_EVENTPROJECT          0x00000010  /* EventProject objects and internals */
+#define FMOD_EVENT_MEMBITS_EVENTGROUPI           0x00000020  /* EventGroup objects and internals */
+#define FMOD_EVENT_MEMBITS_SOUNDBANKCLASS        0x00000040  /* Objects used to manage wave banks */
+#define FMOD_EVENT_MEMBITS_SOUNDBANKLIST         0x00000080  /* Data used to manage lists of wave bank usage */
+#define FMOD_EVENT_MEMBITS_STREAMINSTANCE        0x00000100  /* Stream objects and internals */
+#define FMOD_EVENT_MEMBITS_SOUNDDEFCLASS         0x00000200  /* Sound definition objects */
+#define FMOD_EVENT_MEMBITS_SOUNDDEFDEFCLASS      0x00000400  /* Sound definition static data objects */
+#define FMOD_EVENT_MEMBITS_SOUNDDEFPOOL          0x00000800  /* Sound definition pool data */
+#define FMOD_EVENT_MEMBITS_REVERBDEF             0x00001000  /* Reverb definition objects */
+#define FMOD_EVENT_MEMBITS_EVENTREVERB           0x00002000  /* Reverb objects */
+#define FMOD_EVENT_MEMBITS_USERPROPERTY          0x00004000  /* User property objects */
+#define FMOD_EVENT_MEMBITS_EVENTINSTANCE         0x00008000  /* Event instance base objects */
+#define FMOD_EVENT_MEMBITS_EVENTINSTANCE_COMPLEX 0x00010000  /* Complex event instance objects */
+#define FMOD_EVENT_MEMBITS_EVENTINSTANCE_SIMPLE  0x00020000  /* Simple event instance objects */
+#define FMOD_EVENT_MEMBITS_EVENTINSTANCE_LAYER   0x00040000  /* Event layer instance objects */
+#define FMOD_EVENT_MEMBITS_EVENTINSTANCE_SOUND   0x00080000  /* Event sound instance objects */
+#define FMOD_EVENT_MEMBITS_EVENTENVELOPE         0x00100000  /* Event envelope objects */
+#define FMOD_EVENT_MEMBITS_EVENTENVELOPEDEF      0x00200000  /* Event envelope definition objects */
+#define FMOD_EVENT_MEMBITS_EVENTPARAMETER        0x00400000  /* Event parameter objects */
+#define FMOD_EVENT_MEMBITS_EVENTCATEGORY         0x00800000  /* Event category objects */
+#define FMOD_EVENT_MEMBITS_EVENTENVELOPEPOINT    0x01000000  /* Event envelope point object+s */
+#define FMOD_EVENT_MEMBITS_EVENTINSTANCEPOOL     0x02000000  /* Event instance pool data */
+#define FMOD_EVENT_MEMBITS_ALL                   0xffffffff  /* All memory used by FMOD Event System */
+
+/* All event instance memory */
+#define FMOD_EVENT_MEMBITS_EVENTINSTANCE_GROUP   (FMOD_EVENT_MEMBITS_EVENTINSTANCE            | \
+                                                     FMOD_EVENT_MEMBITS_EVENTINSTANCE_COMPLEX | \
+                                                     FMOD_EVENT_MEMBITS_EVENTINSTANCE_SIMPLE  | \
+                                                     FMOD_EVENT_MEMBITS_EVENTINSTANCE_LAYER   | \
+                                                     FMOD_EVENT_MEMBITS_EVENTINSTANCE_SOUND)
+
+/* All sound definition memory */
+#define FMOD_EVENT_MEMBITS_SOUNDDEF_GROUP        (FMOD_EVENT_MEMBITS_SOUNDDEFCLASS            | \
+                                                     FMOD_EVENT_MEMBITS_SOUNDDEFDEFCLASS      | \
+                                                     FMOD_EVENT_MEMBITS_SOUNDDEFPOOL)
+/* [DEFINE_END] */
+
+#endif

libs/FMOD/inc/fmod_output.h

@@ -0,0 +1,93 @@
+/* ==================================================================================================== */
+/* FMOD Ex - output development header file. Copyright (c), Firelight Technologies Pty, Ltd. 2004-2014. */
+/*                                                                                                      */
+/* 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.           */
+/*                                                                                                      */
+/* ==================================================================================================== */
+
+#ifndef _FMOD_OUTPUT_H
+#define _FMOD_OUTPUT_H
+
+#include "fmod.h"
+
+typedef struct FMOD_OUTPUT_STATE FMOD_OUTPUT_STATE;
+
+/*
+    Output callbacks
+*/ 
+typedef FMOD_RESULT (F_CALLBACK *FMOD_OUTPUT_GETNUMDRIVERSCALLBACK)(FMOD_OUTPUT_STATE *output_state, int *numdrivers);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_OUTPUT_GETDRIVERNAMECALLBACK)(FMOD_OUTPUT_STATE *output_state, int id, char *name, int namelen);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_OUTPUT_GETDRIVERCAPSCALLBACK)(FMOD_OUTPUT_STATE *output_state, int id, FMOD_CAPS *caps);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_OUTPUT_INITCALLBACK)         (FMOD_OUTPUT_STATE *output_state, int selecteddriver, FMOD_INITFLAGS flags, int *outputrate, int outputchannels, FMOD_SOUND_FORMAT *outputformat, int dspbufferlength, int dspnumbuffers, void *extradriverdata);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_OUTPUT_CLOSECALLBACK)        (FMOD_OUTPUT_STATE *output_state);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_OUTPUT_UPDATECALLBACK)       (FMOD_OUTPUT_STATE *output_state);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_OUTPUT_GETHANDLECALLBACK)    (FMOD_OUTPUT_STATE *output_state, void **handle);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_OUTPUT_GETPOSITIONCALLBACK)  (FMOD_OUTPUT_STATE *output_state, unsigned int *pcm);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_OUTPUT_LOCKCALLBACK)         (FMOD_OUTPUT_STATE *output_state, unsigned int offset, unsigned int length, void **ptr1, void **ptr2, unsigned int *len1, unsigned int *len2);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_OUTPUT_UNLOCKCALLBACK)       (FMOD_OUTPUT_STATE *output_state, void *ptr1, void *ptr2, unsigned int len1, unsigned int len2);
+typedef FMOD_RESULT (F_CALLBACK *FMOD_OUTPUT_READFROMMIXER)        (FMOD_OUTPUT_STATE *output_state, void *buffer, unsigned int length);
+
+
+/*
+[STRUCTURE] 
+[
+    [DESCRIPTION]
+    When creating an output, declare one of these and provide the relevant callbacks and name for FMOD to use when it opens and reads a file of this type.
+
+    [REMARKS]
+    Members marked with [in] mean the variable can be written to.  The user can set the value.
+    Members marked with [out] mean the variable is modified by FMOD and is for reading purposes only.  Do not change this value.
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]
+    FMOD_OUTPUT_STATE
+]
+*/
+typedef struct FMOD_OUTPUT_DESCRIPTION
+{
+    const char                        *name;                  /* [in] Name of the output. */
+    unsigned int                       version;               /* [in] Plugin writer's version number. */
+    int                                polling;               /* [in] If TRUE (non zero), this tells FMOD to start a thread and call getposition / lock / unlock for feeding data.  If 0, the output is probably callback based, so all the plugin needs to do is call readfrommixer to the appropriate pointer. */ 
+    FMOD_OUTPUT_GETNUMDRIVERSCALLBACK  getnumdrivers;         /* [in] For sound device enumeration.  This callback is to give System::getNumDrivers somthing to return. */
+    FMOD_OUTPUT_GETDRIVERNAMECALLBACK  getdrivername;         /* [in] For sound device enumeration.  This callback is to give System::getDriverName somthing to return. */
+    FMOD_OUTPUT_GETDRIVERCAPSCALLBACK  getdrivercaps;         /* [in] For sound device enumeration.  This callback is to give System::getDriverCaps somthing to return. */
+    FMOD_OUTPUT_INITCALLBACK           init;                  /* [in] Initialization function for the output device.  This is called from System::init. */
+    FMOD_OUTPUT_CLOSECALLBACK          close;                 /* [in] Cleanup / close down function for the output device.  This is called from System::close. */
+    FMOD_OUTPUT_UPDATECALLBACK         update;                /* [in] Update function that is called once a frame by the user.  This is called from System::update. */
+    FMOD_OUTPUT_GETHANDLECALLBACK      gethandle;             /* [in] This is called from System::getOutputHandle.  This is just to return a pointer to the internal system device object that the system may be using.*/
+    FMOD_OUTPUT_GETPOSITIONCALLBACK    getposition;           /* [in] This is called from the FMOD software mixer thread if 'polling' = true.  This returns a position value in samples so that FMOD knows where and when to fill its buffer. */
+    FMOD_OUTPUT_LOCKCALLBACK           lock;                  /* [in] This is called from the FMOD software mixer thread if 'polling' = true.  This function provides a pointer to data that FMOD can write to when software mixing. */
+    FMOD_OUTPUT_UNLOCKCALLBACK         unlock;                /* [in] This is called from the FMOD software mixer thread if 'polling' = true.  This optional function accepts the data that has been mixed and copies it or does whatever it needs to before sending it to the hardware. */
+} FMOD_OUTPUT_DESCRIPTION;
+
+
+/*
+[STRUCTURE] 
+[
+    [DESCRIPTION]
+    Output plugin structure that is passed into each callback.
+
+    [REMARKS]
+    Members marked with [in] mean the variable can be written to.  The user can set the value.
+    Members marked with [out] mean the variable is modified by FMOD and is for reading purposes only.  Do not change this value.
+
+    [PLATFORMS]
+    Win32, Win64, Linux, Linux64, Macintosh, Xbox360, PlayStation Portable, PlayStation 3, Wii, iPhone, 3GS, NGP, Android
+
+    [SEE_ALSO]
+    FMOD_OUTPUT_DESCRIPTION
+]
+*/
+struct FMOD_OUTPUT_STATE
+{
+    void                      *plugindata;      /* [in] Plugin writer created data the output author wants to attach to this object. */
+    FMOD_OUTPUT_READFROMMIXER  readfrommixer;   /* [out] Function to update mixer and write the result to the provided pointer.  Used from callback based output only.  Polling based output uses lock/unlock/getposition. */
+};
+
+#endif
+
+

libs/FMOD/lib/which library do I use.txt

@@ -0,0 +1,28 @@
+Which library do I link?
+------------------------
+
+If you want to use fmodex.dll: 
+
+Visual Studio users             - fmodex_vc.lib.
+Metrowerks Codewarrior users    - fmodex_vc.lib.
+Borland users                   - fmodex_bc.lib.
+LCC-Win32 users                 - fmodex_lcc.lib.
+Dev-C++, MinGW and CygWin users - libfmodex.a.
+
+If you want to use fmodexL.dll: (same as fmodex.dll but with debug logging enabled)
+
+Visual Studio users             - fmodexL_vc.lib.
+Metrowerks Codewarrior users    - fmodexL_vc.lib.
+Borland users                   - fmodexL_bc.lib.
+LCC-Win32 users                 - fmodexL_lcc.lib.
+Dev-C++, MinGW and CygWin users - libfmodexL.a.
+
+If you want to use fmodex64.dll: (same as fmodex.dll but for 64bit machines)
+
+Visual Studio users             - fmodex64_vc.lib.
+
+If you want to use fmodexL64.dll: (same as fmodex64.dll but with debug logging enabled)
+
+Visual Studio users             - fmodexL64_vc.lib.
+
+No other compilers are supported for 64bit libraries.

libs/bullet-2.82-r2704/AUTHORS

@@ -1,22 +0,0 @@
-
-Bullet Physics Library is an open source project with help from the community at the Physics Forum
-See the forum at http://bulletphysics.com
-
-The project was started by Erwin Coumans
-
-Following people contributed to Bullet
-(random order, please let us know on the forum if your name should be in this list)
-
-Gino van den Bergen: LinearMath classes
-Christer Ericson: parts of the voronoi simplex solver
-Simon Hobbs: 3d axis sweep and prune, Extras/SATCollision, separating axis theorem + SIMD code
-Dirk Gregorius: generic D6 constraint
-Erin Catto: accumulated impulse in sequential impulse
-Nathanael Presson: EPA penetration depth calculation
-Francisco Leon: GIMPACT Concave Concave collision
-Joerg Henrichs: make buildsystem (work in progress)
-Eric Sunshine: jam + msvcgen buildsystem
-Steve Baker: GPU physics and general implementation improvements
-Jay Lee: Double precision support
-KleMiX, aka Vsevolod Klementjev, managed version, rewritten in C# for XNA
-Erwin Coumans: most other source code

libs/bullet-2.82-r2704/BulletLicense.txt

@@ -1,18 +0,0 @@
-/*
-Copyright (c) 2003-2010 Erwin Coumans  http://continuousphysics.com/Bullet/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-
-Free for commercial use, please report projects in the forum at http://www.bulletphysics.org
-
-In case you want to display a Bullet logo in your software: you can download the Bullet logo in various vector formats and high resolution at the download section in http://bullet.googlecode.com

libs/bullet-2.82-r2704/COPYING

@@ -1,17 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2011 Erwin Coumans  http://bulletphysics.org
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose,
-including commercial applications, and to alter it and redistribute it freely,
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-All files in the Bullet/src folder are under this Zlib license.
-Files in the Extras and Demos folder may have a different license, see the respective files.

libs/bullet-2.82-r2704/ChangeLog

@@ -1,795 +0,0 @@
-Bullet Continuous Collision Detection and Physics Library
-Primary author and maintainer: Erwin Coumans
-
-This ChangeLog is incomplete, for an up-to-date list of all fixed issues see http://bullet.googlecode.com
-using http://tinyurl.com/yabmjjj
-
-2013 October 23
-	- Bullet 2.82 release
-	- See docs/BulletQuickstart.pdf or issue tracked for details.
-
-2012 September 10
-	- Bullet 2.81 release preparation
-	
-2011 September 15
-	- Bullet 2.79 release, revision 2433 (mainly a bugfix release)
-	- Revert a change in 2.78 related to speculative contacts (it has undesired side effects)
-	- Use HACD Hierachical Approximate Convex Decomposition (thanks to Khaled Mammou and Sujeon Kim)
-	- Add Intel cmake-build support for OpenCL accelerated cloth/particle
-	- add premake4 build system support to autogenerate visual studio project files that can be shipped (see msvc folder)
-	- preliminary build support for Google NativeClient, using premake4 (see msvc folder)
-			
-	
-2011 April 8
-	- Bullet 2.78 release 2383
-	- Added FractureDemo
-	- Added Separatinx Axis Test and Polyhedral Clipping support (See InternalEdgeDemo)
-	- Added speculative contacts as CCD response method (See CcdPhysicsDemo)
-	- OpenCL and DirectCompute cloth as basic support for capsule collision
-
-2010 September 7
-	- autotools now uses CamelCase naming for libraries just like cmake:
-	libbulletdynamics -> libBulletDynamics, libbulletmath -> libLinearMath
-
-2010 July 21
-	- Preparing for Bullet 2.77 release, around revision r2135
-	- Added an OpenCL particle demo, running on NVidia, AMD and MiniCL
-	Thanks to NVidia for the original particle demo from their OpenCL SDK
-	- Added GPU deformable object solvers for OpenCL and DirectCompute, and a DirectX 11 cloth demo
-	Thanks to AMD
-	- Create a separate library for MiniCL, 
-	MiniCL is a rudimentary OpenCL wrapper that allows to compile OpenCL kernels for multi-core CPU, using Win32 Threads or Posix
-	- Moved vectormath into Bullet/src, and added a SSE implementation
-	- Added a btParallelConstraintSolver, mainly for PlayStation 3 Cell SPUs (although it runs fine on CPU too)
-
-2010 March 6
-	- Dynamica Maya plugin (and COLLADA support) is moved to http://dynamica.googlecode.com
-
-2010 February
-	- Bullet 2.76 release, revision 2010
-	- support for the .bullet binary file format
-	- btInternalEdgeUtility to adjust unwanted collisions against internal triangle edges
-	- Improved Maya Dynamica plugin with better constraint authoring and .bullet file export
-
-
-2009 September 17
-	- Minor update to Bullet 2.75 release, revision 1776
-	- Support for btConvex2dShape, check out Bullet/Demos/Box2dDemo
-	- Fixes in build systems
-	- Minor fix in btGjkPairDetector
-	- Initialize world transform for btCollisionShape in constructor
-
-
-2009 September 6
-	- Bullet 2.75 release
-	- Added SPH fluid simulation in Extras, not integrated with rigid body / soft body yet
-	Thanks to Rama Hoetzlein to make this contribution available under the ZLib license
-	- add special capsule-capsule collider code in btConvexConvexCollisionAlgorithm, to speed up capsule-ragdolls
-	- soft body improvement: faster building of bending constraints
-	- soft body improvement: allow to disable/enable cluster self-collision
-	- soft body fix: 'exploding' soft bodies when using cluster collision
-	- fix some degenerate cases in continuous convex cast, could impact ray cast/convex cast
-	Thanks to Jacob Langford for the report and reproduction cases, see http://code.google.com/p/bullet/issues/detail?id=250&can=1&start=200
-	- re-enabled split impulse
-	- added btHinge2Constraint, btUniversalConstraint, btGeneric6DofSpringConstraint
-	- demonstrate 2D physics with 2D/3D object interaction
-	
-
-2008 December 2
-	- Fix contact refresh issues with btCompoundShape, introduced with btDbvt acceleration structure in btCompoundCollisionAlgorithm
-	- Made btSequentialImpulseConstraintSolver 100% compatible with ODE quickstep
-	constraints can use 'solveConstraint' method or 'getInfo/getInfo2'
-
-2008 November 30
-	- Add highly optimized SIMD branchless PGS/SI solver innerloop 
-
-2008 November 12
-	- Add compound shape export to BulletColladaConverter
-	Thanks to JamesH for the report: http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=12&t=2840
-	- Fix compiler build for Visual Studio 6
-	Thanks to JoF for the report: http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=9&t=2841
-
-2008 November 11
-	- Add CProfileManager::dumpAll() to dump performance statistics to console using printf.
-	- Add support for interaction between btSoftBody and btCollisionObject/btGhostObject
-
-2008 November 8
-	- Fix PosixThreadSupport
-	- Add improved btHeightfieldTerrainShape support and new Demos/TerrainDemo
-	Thanks to tomva, http://code.google.com/p/bullet/issues/detail?id=63&can=1
-	- Moved kinematic character controller from Demos/CharacterDemo into src/BulletDynamics/Character/btKinematicCharacterController.cpp
-
-2008 November 6
-	- reduced default memory pool allocation from 40Mb to 3Mb. This should be more suitable for all platforms, including iPhone
-	- improved CUDA broadphase
-	- IBM Cell SDK 3.x support, fix ibmsdk Makefiles
-	- improved CMake support with 'install' and 'framework option
-	
-2008 November 4
-	- add btAxisSweep::resetPool to avoid non-determinism due to shuffled linked list
-	Thanks to Ole for the contribution, 
-
-2008 October 30
-	- disabled btTriangleMesh duplicate search by default, it is extremely slow
-	- added Extras/IFF binary chunk serialization library as preparation for in-game native platform serialization (planned COLLADA DOM -> IFF converter)
-
-2008 October 20
-	- added SCE Physics Effects box-box collision detection for SPU/BulletMultiThreaded version
-	See Bullet/src/BulletMultiThreaded/SpuNarrowPhaseCollisionTask/boxBoxDistance.cpp
-	Thanks to Sony Computer Entertainment Japan, SCEI for the contribution
-
-2008 October 17
-	- Added btGhostObject support, this helps character controller, explosions, triggers and other local spatial queries
-
-2008 October 10
-	- Moved aabb to btBroadphaseProxy, improves rayTest dramatically. Further raytest improvements using the broadphase acceleration structures are planned
-	- Moved BulletMultiThreaded from Extras to /src/BulletMultiThreaded for better integration
-
-
-2008 October 3
-	- Add support for autoconf automake
-	./autogen.sh and ./configure will create both Makefile and Jamfile. CMake and autogenerated Visual Studio projectfiles remain supported too.
-	- Improved ColladaConverter: plane shape export, and callback for shape construction to allow deletion of memory
-	
-2008 Sept 30
-	- Improved Soft Body support, fixed issues related to soft body colliding against concave triangle meshes
-	- Shared more code between regular version and SPU/BulletMultiThreaded, in particular GJK/EPA
-
-2008 Sept 28
-	- Fixed rotation issues in Dynamic Maya Plugin
-
-2008 Sept 11
-	- Enable CCD motion clamping for btDiscreteDynamicsWorld, to avoid tunneling. A more advanced solution will be implemented in btContinuousDynamicsWorld.
-
-2008 Sept 7
-	- Add btScaledBvhTriangleMeshShape, to allow re-use of btBvhTriangleMeshShape of different sizes, without copying of the BVH data.
-
-2008 Sept 5
-	- Enabled Demos/ForkLiftDemo
-	Thanks Roman Ponomarev.
-
-2008 Sept 4
-	- Added btCudaBroadphase in Extras/CUDA: some research into accelerating Bullet using CUDA.
-	Thanks to the particle demo from the NVidia CUDA SDK.
-	
-2008 Sept 3
-	- Several bug fixes and contributions related to inertia tensor, memory leaks etc.
-	Thanks to Ole K.
-
-2008 Sept 1
-	- Updated CDTestFramework, with latest version of OPCODE Array SAP. See Extras/CDTestFramework
-	Thanks to Pierre Terdiman for the update
-
-2008 August 25
-	- Walt Disney Studios contributes their in-house Maya Plugin for simulating Bullet physics, with options for other engines such as PhysBam or PhysX.
-	Thanks to Nicola Candussi and Arthur Shek
-	
-2008 August 14
-	- Improved performance for btDbvtBroadphase, based on dual dynamic AABB trees (one for static, one for dynamic objects, where objects can move from one to the other tree)
-	Thanks to Nathanael Presson again, for all his work.
-	
-2008 July 31
-	- Added Havok .hkx to COLLADA Physics .dae converter patch+information
-	- Fix btSubsimplexConvexCast
-	Thanks to Nacho, http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=9&t=2422)
-	- Fix in rendering, GL_STENCIL
-	- btTriangleIndexVertexArray indices should be unsigned int/unsigned short int,
-	- Made InternalProcessAllTriangles virtual, thanks to
-	Both thank to Fullmetalcoder, http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=9&t=2401
-	- clamp impulse for btPoint2PointConstraint
-	Thanks to Martijn Reuvers, http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=9&t=2418
-	- Free memory of bvh, pass in scaling factor (optional)
-	Thanks to Roy Eltham, http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=9&t=2375
-
-2008 July 27
-
-btDbvtBroadphase:
-	- Fixed a performance issues reported by 'reltham'
-	- Added btDbvtBroadphase::optimize() for people who want good performances right
-away or don't do dynamics.
-	- fixed compilation issues when DBVT_BP_PROFILE was set.
-btSoftBody:
-	- Fixed singular matrix issues related to polar decomposition (flat meshes).
-DemoApplication:
-	- Shadows (enable/disable through 'g' or DemoApplication::setShadows(bool)).
-	- Texture can be enable/disable through 'u'
-CDFramework:
-	- fixed compilation issues.
-	All thanks to Nathanael Presson
-
-2008 July 10
-	- Added btMultimaterialTriangleMeshShape and MultiMaterialDemo
-	Thanks to Alex Silverman for the contribution
-
-2008 June 30
-	- Added initial support for kinematic character controller
-	Thanks to John McCutchan
-
-2008 April 14
-	- Added ray cast support for Soft Bodies
-	Thanks to Nathanael Presson for the contribution
-	
-2008 April 9
-	- Cleanup of Stan Melax ConvexHull, removed Extras/ConvexHull, moved sources into LinearMath/BulletCollision
-
-2008 April 4
-	- Added btSliderConstraint and demo
-	Thanks Roman Ponomarev
-	
-2008 April 3
-	- Fixed btMinkowskiSumShape, and added hitpoint to btSubsimplexConvexCast
-
-2008 April 2
-	- Added Extras/CdTestFrameWork
-	Thanks Pierre Terdiman
-
-2008 April 1
-	- Added posix thread (pthread) support
-	Thanks Enrico
-
-2008 March 30
-	- Added Soft Body, cloth, rope and deformable volumes, including demos and interaction
-	Thanks Nathanael Presson for this great contribution
-	
-	2008 March 17
-	- Improved BulletColladaConverter
-	Thanks John McCutchan
-
-2008 March 15
-	- btMultiSapBroadphase in a working state. Needs more optimizations to be fully useable.
-	- Allow btOptimizedBvh to be used for arbitrary objects, not just triangles
-	- added quicksort to btAlignedObjectArray
-	- removed btTypedUserInfo, added btHashMap
-
-2008 March 30
-	- Moved quickstep solver and boxbox into Bullet/src folder
-	Thanks Russell L. Smith for permission to redistribute Open Dynamics Engine quickstep and box-box under the ZLib license	
-
-2008 Feb 27
-	- Added initial version for Character Control Demo
-	- Applied fixes to IBM Cell SDK 3.0 build makefiles
-	Thanks Jochen and mojo for reporting/providing patch: http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=9&t=1922
-
-2008 Feb 8
-	- Bugfixes in ConvexCast support against the world.
-	Thanks to Isgmasa for reporting/providing fix: http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=9&t=1823
-
-2008 Feb 6
-	- Added btCapsuleShapeX and btCapsuleShapeZ for capsules around X and Z axis (default capsule is around Y)
-	
-2008 Feb 3
-	- Added btTypedUserInfo, useful for serialization
-
-2008 Jan 31
-	- Add support for 16 and 32-bit indices for SPU / BulletMultiThreaded version.
-
-2008 Jan 29
-	- Added COLLADA Physics export/serialization/snapshot from any Bullet btDynamicsWorld. Saving the physics world into a text .xml file is useful for debugging etc.
-
-2008 Jan 23
-	- Added Stan Melax Convex Hull utility library in Extras/ConvexHull. This is useful to render non-polyhedral convex objects, and to simplify convex polyhedra.
-	
-2008 Jan 14
-	- Add support for batch raycasting on SPU / BulletMultiThreaded
-	
-2007 Dec 16
-	- Added btRigidBodyConstructionInfo, to make it easier to set individual setting (and leave other untouched) during rigid body construction.
-	Thanks Vangelis Kokkevis for pointing this out.
-	- Fixed memoryleak in the ConstraintDemo and Raytracer demo.
-	- Fixed issue with clearing forces/gravity at the end of the stepSimulation, instead of during internalSingleStepSimulation.
-	Thanks chunky for pointing this out: http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=9&t=1780
-	- Disabled additional damping in rigid body by default, but enable it in most demos. Set btRigidBodyConstructionInfo m_additionalDamping to true to enable this.
-	- Removed obsolete QUICKPROF BEGIN/END_PROFILE, and enabled BT_PROFILE. Profiling is enabled by default (see Bullet/Demos/OpenGL/DemoApplication.cpp how to use this).
-	User can switch off profiling by enabling define BT_NO_PROFILE in Bullet/src/btQuickprof.h.
-
-2007 Dec 14
-	- Added Hello World and BulletMultiThreaded demos
-	- Add portable version of BulletMultiThreaded, through SequentialThreadSupport (non-parallel but sharing the same code-path)
-	- Add Cmake support for AllBulletDemos
-	
-
-2007 Dec 11
-	- Moved the 'btRigidBody::clearForce' to the end of the stepSimulation, instead of in each substep.
-	See discussion http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=9&t=1601
-	- Added btConvexPlaneCollisionAlgorithm, makes planes perform better, and prevents tunneling
-	Thanks Andy O'Neil for reporting the performance/functionality issue
-	- Fixes for IBM Cell SDK 3.0
-	Thanks to Jochen Roth for the patch.
-
-2007 Dec 10
-	- Fixes in btHeightfieldTerrainShape
-	Thanks to Jay Lee for the patch.
-
-2007	Dec 9
-	- Only update aabb of active objects
-	Thanks Peter Tchernev for reporting (http://bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=9&t=1764 )
-	- Added workaround to compile libxml under Visual Studio 2008 Beta 2
-	- Make glui compile under MSVC 9.0 beta (vsnprintf is already defined)
-
-2007 Dec 6
-	- Added DynamicControlDemo, showing dynamic control through constraint motors
-		Thanks to Eddy Boxerman
-	- Add support for generic concave shapes for convex cast.
-	- Added convex cast query to collision world.
-	- Added workaround for OpenGL bug in Mac OS X 10.5.0 (Leopard)
-	- Added concave raycast demo
-		All above thanks to John McCutchan (JMC)
-	- Fixed issues that prevent Linux version to compile. 
-	Thanks to Enrico for reporting and patch, see
-	- Fixed misleading name 'numTriangleIndices' into 'numTriangles'
-	Thanks Sean Tasker for reporting:
-
-2007 Nov 28:
-	- Added raycast against trianglemesh. Will be extended to object cast soon.
-	Thanks John McCutchan (JMC)
-	- make getNumPoints const correct, add const getPoints(). 
-	Thanks Dirk Gregorius
-	- Bugfix: allow btCollisionObjects (non-btRigidBody) to interact properly with btRigidBody for cache-friendly btSequentialImpulseConstraintSolver.
-	Thanks Andy O'Neil for pointing this out.
-	- Bugfix: don't fail if spheres have identical center, use arbitrary separating normal (1,0,0)
-	Thanks Sean Tasker for reporting! http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=9&t=1681
-
-
-2007, November 20
-	- Added hierarchical profiling
-	- Fixed memory leak in btMultiSapBroadphase,
-	- Fixed hash function (typo, should use 2 proxies)
-	Thanks to Stephen (shatcher) for reporting and fixes! http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=9&t=1696
-
-2007 Nov 11
-	- Fixed parallel solver (BulletMultiThreaded) friction issue
-	- Terminate Win32 Threads when closing the CcdPhysicsDemo (when USE_PARALLEL_SOLVER/USE_PARALLEL_DISPATCHER is defined)
-
-2007 Nov 6
-	- Added support for 16-bit indices for triangle meshes
-	- Added support for multiple mesh parts using btBvhTriangleMeshShape.
-	Thanks to Tim Johansson
-	
-2007 Oct 22
-	- All memory allocations go through btAlignedAlloc/btAlignedFree. User can override this to verify memory leaks
-	- added a few more demos to AllBulletDemos
-	- fix for one of the constructors of btHingeConstraint
-	Thanks Marcus Hennix
-	
-2007 Oct 20
-	- included glui, a GLUT/OpenGL based toolkit for some graphical user elements
-	Removed dynamic_cast from glui, to allow linkage without rtti
-	- added Box2D framework using glui, allowing all demos to run within one executable
-	Thanks Erin Catto for the FrameWork skeleton (http://www.box2d.org)
-
-2007 Ocy 17
-	- Allow user to pass in their own memory (stack and pool) allocators, through collisionConfiguration. See demos how to use this
-
-2007 Oct 14
-	- Included working version of Cell SPU parallel optimized version for Libspe2 SPU task scheduler.
-	This version compiles and runs on Playstation 3 Linux and IBM CellBlade, see BulletSpuOptimized.pdf for build instructions
-	(Official Playstation 3 developers can request a SPURS version through Sony PS3 Devnet.)
-	Thanks to IBM 'Extreme Blue' project for the contribution
-	http://www-913.ibm.com/employment/us/extremeblue/ 
-	Thanks Minh Cuong Tran, Benjamin Hoeferlin, Frederick Roth and Martina Huellmann
-	for various contributions to get this initial Libspe2 parallel version up and running.
-
-2007 Oct 13
-	- made 'btCollisionShape::calculateLocalInertia' const
-	Thanks to cgripeos, see http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=9&t=1514
-	- applied a large patch to remove warnings
-	Thanks to Enrico, see http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=9&t=1568
-	- removed SSE includes, added #incude <string.h> for memset in Extras/quickstep, thanks Eternl Knight
-
-2007 Oct 11
-	- added Hashed Overlapping Pair Cache, recommended by Pierre Terdiman. It works like a charm, thanks Pierre and Erin Catto (code from Box2D)
-	- modified some margins inside btBoxShape, btCylinderShape and btSphereShape
-	- added cone debug rendering (for cones with x, y and z up-axis)
-	- added improvements for optional Extra/quickstep, thanks to Remotion
-	- some performance improvements for Bullet constraint solver
-
-2007 Sept 28
-	- upgraded GIMPACT to version 0.3
-	Thanks to Francisco Leon
-
-2007 Sept 27
-	- added contribution from IBM Extreme Blue project for Libspe2 support. This allow to execute BulletMultiThreaded on Cell SPU under PS3 Linux and Cell Blade. See http://www-913.ibm.com/employment/us/extremeblue
-	Thanks to Minh Cuong Tran, Frederick Roth, Martina Heullmann and Benjamin Hoeferlin.
-
-2007 Sept 13
-	- Improved btGenericD6Constraint. It can be used to create ragdolls (similar to the new btConeTwistConstraint). See GenericJointDemo
-	- Added support for Bullet constraints in the optional Extras/quickstep ODE solver. See CcdPhysicsDemo, enable #COMPARE_WITH_QUICKSTEP and add libquickstep to the dependencies.
-	For both patches/improvements thanks Francisco Leon/projectileman
-		
-2007 Sept 10
-	- removed union from btQuadWordStorage, it caused issues under certain version of gcc/Linux
-
-2007 Sept 10
-	- Reverted constraint solver, due to some issues. Need to review the recent memory allocation changes.
-	- Fixed issue with kinematic objects rotating at low speed: quaternion was de-normalized, passing value > 1 into acosf returns #IND00 invalid values
-	- 16 byte memory alignment for BVH serialization
-	- memory cleanup for btPoolAllocator
-
-2007 Sept 9
-	- Added serialization for BVH/btBvhTriangleMeshShape, including endian swapping. See ConcaveDemo for an example.
-	Thanks to Phil Knight for the contribution.
-	- Fixed issues related to stack allocator/compound collision algorithm
-	Thanks Proctoid, http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=18&t=1460
-	- Increase some default memory pool settings, and added a fallback for the constraints solver to use heap memory
-	- Removed accidential testing code in btScalar.h related to operator new.	
-	- Enable btAxis3Sweep and bt32BitAxis3Sweep to be linked in at the same time, using template
-	
-2007 Sept 7
-	- Replaced several dynamic memory allocations by stack allocation and pool allocations
-	- Added branch-free quantized aabb bounding box overlap check, works better on Playstation 3 and XBox 360
-	Thanks to Phil Knight. Also see www.cellperformance.com for related articles
-	- Collision algorithms and settings for the memory/stack allocator can be done using btDefaultCollisionConfiguration
-	This is an API change. See demos how to modify existing implementations with a one-liner.
-	- Register several collision algorithms by default (sphere-sphere, sphere-box, sphere-triangle)
-	- Use other traveral method for BVH by default, this improves triangle mesh collision performance.
-	
-2007 Aug 31
-	- fixed MSVC 6 build
-	Thanks Proctoid, http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1375
-	- fixed double precision build issues
-	Thanks Alex Silverman, http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1434
-
-2007 Aug 24
-	- fixed bug in btMatrix3x3::transposeTimes(const btMatrix3x3& m) const. Luckily it wasn't used in core parts of the library (yet).
-	Thanks to Jay Lee
-	
-2007 Aug 15
-	- fixed bug in Extras/GIMPACT 0.2 related to moving triangle meshes
-	Thanks Thomas, http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1368
-
-2007 Aug 14
-	- added parallel constraint solver. Works on Playstation 3 Cell SPU and multi core (Win Threads on PC and XBox 360).
-	  See Extras/BulletMultiThreaded for SpuSolverTask subfolder and SpuParallelSolver.cpp
-	  Thanks Marten Svanfeldt (Starbreeze Studios)	
-	- fixed some bugs related to parallel collision detection (Extras/BulletMultiThreaded)
-	  Thanks Marten Svanfeldt (Starbreeze Studios)	
-	
-2007 Aug 2
-	- added compound and concave-convex (swapped) case for BulletMultiThreaded collision detection, thanks to Marten Svanfeldt
-	- refactored broadphase and overlapping pair cache. This allows performance improvement by combining multiple broadphases. This helps add/remove of large batches of objects and large worlds. See also Pierre Terdiman forum topic:
-	http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1329
-
-
-2007 July 27
-	- added Ragdoll Demo
-		Thanks to Marten Svanfeldt (Starbreeze Studios)
-
-	- added Vector Math library for SIMD 3D graphics linear algebra (vector, matrix, quaternion)
-		See Bullet/Extras/vectormathlibrary
-		Supports SIMD SSE, PowerPC PPU and Cell SPU (including PS3 Linux and CellBlade), as well as generic portable scalar version
-		Will be used to improve BulletMultiThreaded performance
-		Open Sourced by Sony Computer Entertainment Inc. under the new BSD license
-	- added SIMD math library
-		4-way SIMD for common math functions like atan2f4, cosf4, floorf4, fabsf4, rsqrtf4 etc. Used by Vector Math library under PPU and SPU.
-		Supports PowerPC (PPU) and Cell SPU, including PS3 Linux and CellBlade.
-		See Bullet/Extras/simdmathlibrary
-		Open sourced by Sony Computer Entertainment Inc. under the new BSD license
-
-	
-2007 July 25
-	- added several patches: per-rigidbody sleeping threshold. added Assert to prevent deletion of rigidbody while constraints are still pointing at it
-		Thanks to Marten Svanfeldt (Starbreeze Studios)
-	
-2007 July 13
-	- fixed relative #include paths again. We can't use "../" relative paths: some compilers choke on it (it causes extreme long paths)
-		Within the libraries, we always need to start with "BulletCollision/" or "BulletDynamics/ or "LinearMath/"
-
-2007 July 10
-	- Updated Bullet User Manual
-
-2007 July 5
-	- added btConeTwistConstraint, especially useful for ragdolls. See Demos/RagdollDemo
-		Thanks to Marten Svanfeldt (Starbreeze Studios)
-
-2007 June 29
-	- btHeightfieldTerrainShape: Added heightfield support, with customizations
-	- Upgraded to GIMPACT 0.2, see Extras/GIMPACT and MovingConcaveDemo
-	- Several patches from Marten Svanfeldt (Starbreeze Studios)
-		Improved collision filtering (in broadphase and rigidbody)
-		Improved debug rendering
-		Allow to set collision filter group/mask in addRigidBody
-		
-		
-2007 June 15
-	- Changed btAlignedObjectArray to call copy constructor/replacement new for duplication, rather then assignment operator (operator=).
-
-2007 June 11
-	- Added multi-threading. Originally for Playstation 3 Cell SPU, but the same code can run using Win32 Threads using fake DMA transfers (memcpy)
-		Libspe2 support for Cell Blade / PS3 Linux is upcoming
-		See Extras/BulletMultiThreaded. Usage: replace btCollisionDispatcher by btSpuGatheringCollisionDispatcher
-
-	- Added managed Bullet library, entirely rewritten in C# for Windows and XBox 360 XNA
-		See Extras/BulletX
-		Thanks to KleMiX, aka Vsevolod Klementjev
-
-2007 May 31
-	- sign-bit went wrong in case of 32-bit broadphase, causing quantization problems. 
-		Thanks DevO for reporting.
-
-2007 May 23
-	- Fixed quantization problem for planar triangle meshes in btOptimizedBvh
-		Thanks Phil Knight for reporting and helping to fix this bug.
-		
-2007 May 20
-	- btAxisSweep3: Fixed a bug in btAxisSweep3 (sweep and prune) related to object removal. Only showed up when at least one btStaticPlaneShape was inserted.
-		Thanks tbp for more details on reproducing case.
-	- btAxisSweep3: Fixed issue with full 32bit precision btAxisSweep3 (define BP_USE_FIXEDPOINT_INT_32), it used only 0xffff/65536 for quantization instead of full integer space (0xffffffff)
-	- btRaycastVehicle: Added 'getForwardVector' and getCurrentSpeedKmHour utility functions
-	- Fixed local scaling issues (btConvexTriangleMeshShape, btBvhTriangleMeshShape, removed scaling from btMatrix3x3). 
-		Thanks Volker for reporting!
-	- Added second filename search, so that starting BspDemo and ConvexDecompositionDemo from within Visual Studio (without setting the starting path) still works
-
-2007 April 22
-	- Added braking functionality to btRaycastVehicle
-	- Removed tons of warnings, under MSVC 2005 compilation in -W4
-	
-2007 March 21
-	- Fixed issues: comma at end of enum causes errors for some compilers
-	- Fixed initialization bug in LocalRayResult (	m_localShapeInfo(localShapeInfo) )
-	
-2007 March 20
-	- Added refit tree to quantized stackless tree, and updated ConcaveDemo as example.
-	
-2007 March 17
-	- Added constraint solver optimizations, avoiding cross products during iterations, and gather rigidbody/constraint info in contiguous memory (btSolverBody/btSolverConstraint)
-	- These optimizations don't give large benefit yet, but it has good potential. Turned on by default. Can be switched off using solver->setSolverMode(SOLVER_RANDMIZE_ORDER).
-	- Enabled anti-jitter for rigid bodies. This is experimental, and can be switched off by setting a global (it is experimental so no proper interface) gJitterVelocityDampingFactor = 1.0;
-	- Fixed bug in islandmanifold.heapSort(btPersistentManifoldSortPredicate()); , thanks Noehrgel for reporting this (affected Sun Solaris)
-	
-2007 March 12
-	- Added compile-time toggle between on 16-bit and 32-bit fixed-point SAP broadphase. 
-		This allows the number of bodies to exceed 32767
-	- Enable useQuantizedAabbCompression on btTriangleMesh, see ColladaDemo
-	
-2007 March 8
-	- Fixed bug in constraint/island sorting (caused by replacing STL by dedicated btAlignedObjectArray with heapSort)
-		Thanks Clemens Unterkofler for pointing this out!
-
-2007 March 6
-	- removed STL from the Bullet library: replace std::vector by btAlignedObjectArray. Also removed the std::set for overlapping pair set, and turned it into an overlapping pair array. The SAP only adds objects, never removed. Removal is postponed for during traversal of overlapping pairs (duplicates and non-overlapping pairs are removed during that traversal).
-	- added heap sort and binary search/linear search to btAlignedObjectArray
-	- fixed wrong cast, thanks Hamstray, http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1015
-
-
-2007 Feb 25
-	- Improved performance of convex collision shapes, cache local AABB instead of recomputation. This fixes issue with very slow performance in larger .bsp levels
-	
-2007 Feb 24
-	- Added compressed/quantized AABB tree, 16 bytes per node, while supporting 32-bit (triangle) indices. 
-	  Should be faster and smaller then original version (quantized aabb check is done in integer space)
-		Original aabb tree nodes are still supported. They are 44 bytes, with full floating point precision and additional subPart index.
-	- added meter-unit scaling support in ColladaConverter.cpp
-
-2007 Feb 21
-	- Build system: updated bullet.pc.in library names
-	- Updated EPA comparison integration (missing parameter)
-	
-2007 Jan 04
-	- fixed optimized AABB tree building: in some cases the tree building fails due to unbalanced trees, which generated stack overflow
-	
-2006 Dec 15
-	- added contribution to allow double precision collision detection/dynamics. Define BT_USE_DOUBLE_PRECISION in your project and libraries that include Bullet
-
-2006 Dec 14
-	- merged contact and non-contact constraint solving into one loop, will improve stability of jointed bodies during collisions
-	- added first draft for hingeConstraint motor
-	
-2006 Dec 8, Erwin Coumans
-	- preparation for SIMD: added btAlignedAllocator and btAlignedObjectArray, to replace stl std::vector, same interface, but compatible with 16 byte alignment
-	- cleaned up dependencies in autogenerated msvc projectfiles
-	- aligned btVector3 on 16 bytes boundary, under win32. see if developers will come up with problems
-
-2006 Dec 04, Erwin Coumans
-	Added btNearCallback. This is similar to Open Dynamics Engine (ODE) dNearCallback, but important differences:
-	- contact points are persistent (lifetime more then one frame, for warmstarting/incremental contact point management)
-	- continuous collision detection, time of impact
-	Added btRigidBody::isInWorld(), returns true if btRigidBody is inside a btCollisionWorld/btDynamicsWorld derived class
-	Added angularFactor to btRigidbody, this helps some character control (no angular impulse applied)
-
-
-2006 Nov 28
-	Moved StackAlloc from EPA into LinearMath/btStackAlloc
-	renamed internal class ConcaveShape into btConcaveShape
-	added btHeightfieldTerrainShape (not completed yet)
-		
-2006 Nov 15 Nathanael Presson
-	Added EPA penetration depth algorithm, Expanding Polytope Algorithm
-	Added Pierre Terdiman penetration depth comparison/test DEMO
-	Fixed Bullet's Minkowski sampling penetration depth solver
-	Contributed by Nathanael Presson
-	
-2006 Nov 11 Francisco León Nájera
-	Added GIMPACT trimesh collision detection: concave versus concave,
-	Contributed by Francisco León Nájera
-
-2006 Nov 2
-	Minor refactoring: btCollisionObject changes from struct into class, added accessor methods
-	Force use of btMotionState to synchronize graphics transform, disabled old btRigidBody constructor that accepts btTransform
-	Renamed treshold into threshold throughout the code
-	
-2006 Oct 30
-	Enable decoupling of physics and graphics framerate using interpolation and internal fixed timestep, based on btMotionState
-	Enabled raycast vehicle demo (still needs tuning)
-	Refresh contact points, even when they are already persistent.
-	Fixed debugDraw colors (thanks pc0de for reporting)
-	Use Dispatcher in ConcaveConvexCollisionAlgorithm (so it uses the registered collision algorithm, not hardcoded convexconcave)
-	Improved performance of constraint solver by precalculating the cross product/impulse arm
-	Added collision comparison code: ODE box-box, also sphere-triangle
-	Added safety check into GJK, and an assert for AABB's that are very large
-	Fixed kinematic support (deriving velocities for animated objects)
-	Updated comparison/optional quickstep solver in Extras
-	UserCollisionAlgorithm demonstrates btTriangleMesh usage (easier trimesh compared to index array version)
-	Removed scaling from btTransform (we only want to deal with rigid transforms)
-	
-2006 Oct 4
-	Fixed minor leak in btOptimizeBVH
-	Cleanup of btRigidBody construction
-	added getW() in btQuaternion
-	assert when setLinearVelocity is called on btRigidBody
-	renamed projectfile library from collada-dom to colladadom (to make VC6 happy)
-	
-2006 Sept 27
-	Big Refactoring: renamed and moved files, create a replacement for CcdPhysicsEnvironment/CcdPhysicsController.
-	All Bullet classes in LinearMath, BulletCollision and BulletDynamics start with bt, and methods start with lowercase.
-	Moved classes into src folder, which is the only include folder needed.
-	Added 2 headerfiles in src: btBulletCollisionCommon.h and btBulletDynamicsCommon.h
-
-2006 Sept 23
-	Fixed 2 bugs, causing crashes when removing objects. Should do better unit-testing. UnionFind and 3D SAP were involved.
-	
-2006 Sept 19
-	Allow programmable friction and contact solver model. User can register their own functions for several interaction types.
-	Improved performance, and removed hardcoded maximum overlaps (switched from C-array to stl::set)
-	
-2006 Sept 16
-	Added Bullet 2.0  User Manual
-	Allow registration of custom user collision algorithms
-
-2006 Sept 10
-	Started cleaning up demos
-	
-2006 Sept 4
-	Fixed concave collision bug (caused instability/missing collisions in meshes/compounds)
-	Fixed memoryleak in OptimizedBvh, added RayTestSingle to CollisionWorld
-	Prepared for VehicleDemo
-	Increased Performance (island generation for sleeping objects took too much time)
-	Better COLLADA 1.4.1 physics conformance in ColladaDemo
-
-2006 August 11
-	Added Quake BspDemo
-	Improved CCD for compound and non-convex objects
-
-2006 August 10
-	Added per-triangle material (friction/restitution) support for non-convex meshes. See ConcaveDemo for usage.
-
-2006 August 9
-	Added CMake support (see http://cmake.org)
-	This can autogenerate makefiles, projectfiles cross platform (including MacOS X Xcode )
-	Just run cmake . in the root folder and it will autogenerate build files
-	
-2006 July 26 Erwin Coumans
-	Upgraded to COLLADA-DOM 1.4.1, latest SVN version
-	ColladaDemo can export snapshots to .dae
-	
-2006 July 24 Erwin Coumans
-	Added Compound CollisionShape support
-	(this is still low performance -> requires stackless tree-versus-tree traversal for better performance)
-
-2006 July 15 Erwin Coumans
-	Added initial support for Parallel execution (collision detection, constraint solving)
-	See ParallelPhysicsEnvironment in Extras\PhysicsInterface\CcdPhysics
-	
-2006 July 10 Erwin Coumans
-	Added MacOS X support (some build issues mainly)
-		
-2006 July 5 Erwin Coumans
-	Improved COLLADA 1.4 physics import, both COLLADA-DOM and FCollada
-
-2006 June 29 Erwin Coumans
-	Refactoring of the broadphase
-	Moved some optional files to Extras: Algebraic ccd and EPA, quickstep
-	Moved the limits on bodies/overlap to 32k and 65k
-	
-2006 June 25 Erwin Coumans
-	Added basic Collision Filtering, during broadphase
-	Allow adding meshes to the TriangleIndexVertexArray,
-	(input for TriangleMeshShape) 
-	Preparation for CompoundShape
-
-2006 June 19 Erwin Coumans
-	Added support for COLLADA Physics Import.
-	Both jam and Visual Studio can compile ColladaDemo
-
-2006 June 18 Dirk Gregorius <dirk@dirkgregorius.de>
-	Started implementing Generic6DOF joint and setup basic interface
-
-
-2006 June 17 Frank Richter <resqu@gmx.ch>
-	Bumped version in configure.ac to 1.5.6 (assuming that "1.5f" is
-	  the next version released).
-	Updated files in mk/autoconf and mk/jam with copies from CS; fixes a 
-	  GLU detection issue on MinGW.
-	Set msvc/bullet_ico.ico as the default application icon.
-	Disabled exceptions for gcc builds.
-	Applied a patch from Michael D. Adams to fix a warning with gcc.
-2006 jUNE 16 Erwin Coumans
-	Constraints now merge simulation islands.
-
-2006 May 24
-	Improved GJK accuracy, fixed GjkConvexCast issue, thanks to ~MyXa~ for reporting
-	
-2006 May 19
-	Added restitution support
-	Moved out Friction and Dynamics info from ManifoldPoint (removed logical dependency)
-	Added a void* m_userPersistentData in ManifoldPoint.
-	Added a ContactDestroyedCallback, to allow user to handle destruction of m_userPersistentData
-
-2006 May 13
-	Fixed some bugs in friction / jacobian calculations. Reported by Dirk Gregorius. Thanks!
-
-2006 May 9
-	Fixed raycasting filtering
-	Moved repository to SVN at https://svn.sourceforge.net/svnroot/bullet
-		
-2006 April 27
-	Moved raycasting to CollisionWorld, to make it more generic
-	Added basic CCD option in the CcdCollisionDemo
-	Fixed 'noResponse' mode, for triggering rigidbodies (useful for Artificial Intelligence queries)
-	Improved Bullet/ODE sample (in Extras)
-		
-2006 April 10
-	Separating Axis Test (SAT) convex hull collision detector, contribution by Simon Hobbs
-	Added SIMD SSE Math classes (for above SAT)
-	Added Mouse picking in CcdPhysicsDemo
-	Improved penetration depth estimation in MinkowskiPenetrationDepthSolver, both accuracy and performance
-	Added Hinge constraint
-	Added quickprof profiling (see http://sourceforge.net/projects/quickprof )
-		
-2006 March 21 Frank Richter <resqu@gmx.ch>
-	Removed VC manifest files.
-	Removed superfluous "grpplugins" projects.
-
-2006 March 20 Erwin Coumans
-	Clamped the acculumated impulse rather then intermediate impulse (within the iteration)
-	Use the persistent contacts for reusing the impulse
-	Separated friction and normal solving for better stability
-	Decreased the default number of iterations of the constraint solver from 10 to 4
-
-2006 March 19 Frank Richter <resqu@gmx.ch>
-	Removed a couple of CSisms from the VC projects.
-	Fixed VC include & lib paths to go to the Addtional* options
-	  instead the command line arguments.
-	Added pkgconfig support.
-
-2006 March 14 Frank Richter <resqu@gmx.ch>
-	Added support for shipped GLUT on MinGW.
-	Fixed GLUT support on MinGW.
-
-2006 March 13 Frank Richter <resqu@gmx.ch>
-	Bolted on Jam-based build system.
-	Generated VC project files.
-	Fixed GCC warnings.
-	Fixed Linux build issues.
-
-2006 March 13
-Added 3D Sweep and Prune Broadphase Collision Detection, Contribution from Simon Hobbs.
-
-2006 March 2
-	Minor change in license to ZLib/LibPNG
-	This makes it legally a bit easier to deploy on Playstation 3
-	Prepared for more generic constraints, added ConstraintsDemo
-
-2006 Feb 23
-	Rearranged files and dependencies to allow for easier standalone Collision Detection without Bullet Dynamics.
-	See Demos/CollisionInterfaceDemo and Extras/ode/ode/test/test_BulletGjk.cpp for examples how to use.
-
-2005 August 6
-	Bullet 0.2 release with demos, sources, doxygen, draft manual
-
-2005 June 1
-	First public release of Bullet
-	
-
-... todo: add history
-
-2003 Initial version (continuous collision detection)

libs/bullet-2.82-r2704/NEWS

@@ -1,5 +0,0 @@
-
-For news, visit the Bullet Physics forums at
-http://www.bulletphysics.org and http://bullet.googlecode.com
-
-

libs/bullet-2.82-r2704/README

@@ -1,6 +0,0 @@
-
-Bullet is a 3D Collision Detection and Rigid Body Dynamics Library for games and animation.
-Free for commercial use, including Playstation 3, open source under the ZLib License.
-
-See the Bullet_User_Manual.pdf for more info and visit the Bullet Physics Forum at
-http://bulletphysics.org

libs/bullet-2.82-r2704/VERSION

@@ -1 +0,0 @@
-2.82

libs/bullet-2.82-r2704/lib/readme.txt

@@ -1,13 +0,0 @@
-At the moment there are no binary packages from Bullet library.
-Once this is done, the libraries will be placed here
-
-LinearMath
-BulletCollision
-BulletDynamics
-
-The C-API will be available in the include folder.
-
-For now, there is only C++ files, see src/btBulletCollisionCommon.h and src/btBulletDynamicsCommon.h
-
-http://bullet.googlecode.com
-Erwin Coumans

libs/bullet-2.82-r2704/src/Bullet-C-Api.h

@@ -1,176 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-/*
-	Draft high-level generic physics C-API. For low-level access, use the physics SDK native API's.
-	Work in progress, functionality will be added on demand.
-
-	If possible, use the richer Bullet C++ API, by including "btBulletDynamicsCommon.h"
-*/
-
-#ifndef BULLET_C_API_H
-#define BULLET_C_API_H
-
-#define PL_DECLARE_HANDLE(name) typedef struct name##__ { int unused; } *name
-
-#ifdef BT_USE_DOUBLE_PRECISION
-typedef double	plReal;
-#else
-typedef float	plReal;
-#endif
-
-typedef plReal	plVector3[3];
-typedef plReal	plQuaternion[4];
-
-#ifdef __cplusplus
-extern "C" { 
-#endif
-
-/**	Particular physics SDK (C-API) */
-	PL_DECLARE_HANDLE(plPhysicsSdkHandle);
-
-/** 	Dynamics world, belonging to some physics SDK (C-API)*/
-	PL_DECLARE_HANDLE(plDynamicsWorldHandle);
-
-/** Rigid Body that can be part of a Dynamics World (C-API)*/	
-	PL_DECLARE_HANDLE(plRigidBodyHandle);
-
-/** 	Collision Shape/Geometry, property of a Rigid Body (C-API)*/
-	PL_DECLARE_HANDLE(plCollisionShapeHandle);
-
-/** Constraint for Rigid Bodies (C-API)*/
-	PL_DECLARE_HANDLE(plConstraintHandle);
-
-/** Triangle Mesh interface (C-API)*/
-	PL_DECLARE_HANDLE(plMeshInterfaceHandle);
-
-/** Broadphase Scene/Proxy Handles (C-API)*/
-	PL_DECLARE_HANDLE(plCollisionBroadphaseHandle);
-	PL_DECLARE_HANDLE(plBroadphaseProxyHandle);
-	PL_DECLARE_HANDLE(plCollisionWorldHandle);
-
-/**
-	Create and Delete a Physics SDK	
-*/
-
-	extern	plPhysicsSdkHandle	plNewBulletSdk(void); //this could be also another sdk, like ODE, PhysX etc.
-	extern	void		plDeletePhysicsSdk(plPhysicsSdkHandle	physicsSdk);
-
-/** Collision World, not strictly necessary, you can also just create a Dynamics World with Rigid Bodies which internally manages the Collision World with Collision Objects */
-
-	typedef void(*btBroadphaseCallback)(void* clientData, void* object1,void* object2);
-
-	extern plCollisionBroadphaseHandle	plCreateSapBroadphase(btBroadphaseCallback beginCallback,btBroadphaseCallback endCallback);
-
-	extern void	plDestroyBroadphase(plCollisionBroadphaseHandle bp);
-
-	extern 	plBroadphaseProxyHandle plCreateProxy(plCollisionBroadphaseHandle bp, void* clientData, plReal minX,plReal minY,plReal minZ, plReal maxX,plReal maxY, plReal maxZ);
-
-	extern void plDestroyProxy(plCollisionBroadphaseHandle bp, plBroadphaseProxyHandle proxyHandle);
-
-	extern void plSetBoundingBox(plBroadphaseProxyHandle proxyHandle, plReal minX,plReal minY,plReal minZ, plReal maxX,plReal maxY, plReal maxZ);
-
-/* todo: add pair cache support with queries like add/remove/find pair */
-	
-	extern plCollisionWorldHandle plCreateCollisionWorld(plPhysicsSdkHandle physicsSdk);
-
-/* todo: add/remove objects */
-	
-
-/* Dynamics World */
-
-	extern  plDynamicsWorldHandle plCreateDynamicsWorld(plPhysicsSdkHandle physicsSdk);
-
-	extern  void           plDeleteDynamicsWorld(plDynamicsWorldHandle world);
-
-	extern	void	plStepSimulation(plDynamicsWorldHandle,	plReal	timeStep);
-
-	extern  void plAddRigidBody(plDynamicsWorldHandle world, plRigidBodyHandle object);
-
-	extern  void plRemoveRigidBody(plDynamicsWorldHandle world, plRigidBodyHandle object);
-
-
-/* Rigid Body  */
-
-	extern  plRigidBodyHandle plCreateRigidBody(	void* user_data,  float mass, plCollisionShapeHandle cshape );
-
-	extern  void plDeleteRigidBody(plRigidBodyHandle body);
-
-
-/* Collision Shape definition */
-
-	extern  plCollisionShapeHandle plNewSphereShape(plReal radius);
-	extern  plCollisionShapeHandle plNewBoxShape(plReal x, plReal y, plReal z);
-	extern  plCollisionShapeHandle plNewCapsuleShape(plReal radius, plReal height);	
-	extern  plCollisionShapeHandle plNewConeShape(plReal radius, plReal height);
-	extern  plCollisionShapeHandle plNewCylinderShape(plReal radius, plReal height);
-	extern	plCollisionShapeHandle plNewCompoundShape(void);
-	extern	void	plAddChildShape(plCollisionShapeHandle compoundShape,plCollisionShapeHandle childShape, plVector3 childPos,plQuaternion childOrn);
-
-	extern  void plDeleteShape(plCollisionShapeHandle shape);
-
-	/* Convex Meshes */
-	extern  plCollisionShapeHandle plNewConvexHullShape(void);
-	extern  void		plAddVertex(plCollisionShapeHandle convexHull, plReal x,plReal y,plReal z);
-/* Concave static triangle meshes */
-	extern  plMeshInterfaceHandle		   plNewMeshInterface(void);
-	extern  void		plAddTriangle(plMeshInterfaceHandle meshHandle, plVector3 v0,plVector3 v1,plVector3 v2);
-	extern  plCollisionShapeHandle plNewStaticTriangleMeshShape(plMeshInterfaceHandle);
-
-	extern  void plSetScaling(plCollisionShapeHandle shape, plVector3 scaling);
-
-/* SOLID has Response Callback/Table/Management */
-/* PhysX has Triggers, User Callbacks and filtering */
-/* ODE has the typedef void dNearCallback (void *data, dGeomID o1, dGeomID o2); */
-
-/*	typedef void plUpdatedPositionCallback(void* userData, plRigidBodyHandle	rbHandle, plVector3 pos); */
-/*	typedef void plUpdatedOrientationCallback(void* userData, plRigidBodyHandle	rbHandle, plQuaternion orientation); */
-
-	/* get world transform */
-	extern void	plGetOpenGLMatrix(plRigidBodyHandle object, plReal* matrix);
-	extern void	plGetPosition(plRigidBodyHandle object,plVector3 position);
-	extern void plGetOrientation(plRigidBodyHandle object,plQuaternion orientation);
-
-	/* set world transform (position/orientation) */
-	extern  void plSetPosition(plRigidBodyHandle object, const plVector3 position);
-	extern  void plSetOrientation(plRigidBodyHandle object, const plQuaternion orientation);
-	extern	void plSetEuler(plReal yaw,plReal pitch,plReal roll, plQuaternion orient);
-	extern	void plSetOpenGLMatrix(plRigidBodyHandle object, plReal* matrix);
-
-	typedef struct plRayCastResult {
-		plRigidBodyHandle		m_body;  
-		plCollisionShapeHandle	m_shape; 		
-		plVector3				m_positionWorld; 		
-		plVector3				m_normalWorld;
-	} plRayCastResult;
-
-	extern  int plRayCast(plDynamicsWorldHandle world, const plVector3 rayStart, const plVector3 rayEnd, plRayCastResult res);
-
-	/* Sweep API */
-
-	/* extern  plRigidBodyHandle plObjectCast(plDynamicsWorldHandle world, const plVector3 rayStart, const plVector3 rayEnd, plVector3 hitpoint, plVector3 normal); */
-
-	/* Continuous Collision Detection API */
-	
-	// needed for source/blender/blenkernel/intern/collision.c
-	double plNearestPoints(float p1[3], float p2[3], float p3[3], float q1[3], float q2[3], float q3[3], float *pa, float *pb, float normal[3]);
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif //BULLET_C_API_H
-

libs/bullet-2.82-r2704/src/BulletCollision/BroadphaseCollision/btAxisSweep3.cpp

@@ -1,37 +0,0 @@
-
-//Bullet Continuous Collision Detection and Physics Library
-//Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
-
-
-//
-// btAxisSweep3
-//
-// Copyright (c) 2006 Simon Hobbs
-//
-// This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source distribution.
-#include "btAxisSweep3.h"
-
-
-btAxisSweep3::btAxisSweep3(const btVector3& worldAabbMin,const btVector3& worldAabbMax, unsigned short int maxHandles, btOverlappingPairCache* pairCache, bool disableRaycastAccelerator)
-:btAxisSweep3Internal<unsigned short int>(worldAabbMin,worldAabbMax,0xfffe,0xffff,maxHandles,pairCache,disableRaycastAccelerator)
-{
-	// 1 handle is reserved as sentinel
-	btAssert(maxHandles > 1 && maxHandles < 32767);
-
-}
-
-
-bt32BitAxisSweep3::bt32BitAxisSweep3(const btVector3& worldAabbMin,const btVector3& worldAabbMax, unsigned int maxHandles , btOverlappingPairCache* pairCache , bool disableRaycastAccelerator)
-:btAxisSweep3Internal<unsigned int>(worldAabbMin,worldAabbMax,0xfffffffe,0x7fffffff,maxHandles,pairCache,disableRaycastAccelerator)
-{
-	// 1 handle is reserved as sentinel
-	btAssert(maxHandles > 1 && maxHandles < 2147483647);
-}

libs/bullet-2.82-r2704/src/BulletCollision/BroadphaseCollision/btBroadphaseInterface.h

@@ -1,82 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef		BT_BROADPHASE_INTERFACE_H
-#define 	BT_BROADPHASE_INTERFACE_H
-
-
-
-struct btDispatcherInfo;
-class btDispatcher;
-#include "btBroadphaseProxy.h"
-
-class btOverlappingPairCache;
-
-
-
-struct	btBroadphaseAabbCallback
-{
-	virtual ~btBroadphaseAabbCallback() {}
-	virtual bool	process(const btBroadphaseProxy* proxy) = 0;
-};
-
-
-struct	btBroadphaseRayCallback : public btBroadphaseAabbCallback
-{
-	///added some cached data to accelerate ray-AABB tests
-	btVector3		m_rayDirectionInverse;
-	unsigned int	m_signs[3];
-	btScalar		m_lambda_max;
-
-	virtual ~btBroadphaseRayCallback() {}
-};
-
-#include "LinearMath/btVector3.h"
-
-///The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs.
-///Some implementations for this broadphase interface include btAxisSweep3, bt32BitAxisSweep3 and btDbvtBroadphase.
-///The actual overlapping pair management, storage, adding and removing of pairs is dealt by the btOverlappingPairCache class.
-class btBroadphaseInterface
-{
-public:
-	virtual ~btBroadphaseInterface() {}
-
-	virtual btBroadphaseProxy*	createProxy(  const btVector3& aabbMin,  const btVector3& aabbMax,int shapeType,void* userPtr, short int collisionFilterGroup,short int collisionFilterMask, btDispatcher* dispatcher,void* multiSapProxy) =0;
-	virtual void	destroyProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher)=0;
-	virtual void	setAabb(btBroadphaseProxy* proxy,const btVector3& aabbMin,const btVector3& aabbMax, btDispatcher* dispatcher)=0;
-	virtual void	getAabb(btBroadphaseProxy* proxy,btVector3& aabbMin, btVector3& aabbMax ) const =0;
-
-	virtual void	rayTest(const btVector3& rayFrom,const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin=btVector3(0,0,0), const btVector3& aabbMax = btVector3(0,0,0)) = 0;
-
-	virtual void	aabbTest(const btVector3& aabbMin, const btVector3& aabbMax, btBroadphaseAabbCallback& callback) = 0;
-
-	///calculateOverlappingPairs is optional: incremental algorithms (sweep and prune) might do it during the set aabb
-	virtual void	calculateOverlappingPairs(btDispatcher* dispatcher)=0;
-
-	virtual	btOverlappingPairCache*	getOverlappingPairCache()=0;
-	virtual	const btOverlappingPairCache*	getOverlappingPairCache() const =0;
-
-	///getAabb returns the axis aligned bounding box in the 'global' coordinate frame
-	///will add some transform later
-	virtual void getBroadphaseAabb(btVector3& aabbMin,btVector3& aabbMax) const =0;
-
-	///reset broadphase internal structures, to ensure determinism/reproducability
-	virtual void resetPool(btDispatcher* dispatcher) { (void) dispatcher; };
-
-	virtual void	printStats() = 0;
-
-};
-
-#endif //BT_BROADPHASE_INTERFACE_H

libs/bullet-2.82-r2704/src/BulletCollision/BroadphaseCollision/btBroadphaseProxy.cpp

@@ -1,17 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "btBroadphaseProxy.h"
-

libs/bullet-2.82-r2704/src/BulletCollision/BroadphaseCollision/btBroadphaseProxy.h

@@ -1,270 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef BT_BROADPHASE_PROXY_H
-#define BT_BROADPHASE_PROXY_H
-
-#include "LinearMath/btScalar.h" //for SIMD_FORCE_INLINE
-#include "LinearMath/btVector3.h"
-#include "LinearMath/btAlignedAllocator.h"
-
-
-/// btDispatcher uses these types
-/// IMPORTANT NOTE:The types are ordered polyhedral, implicit convex and concave
-/// to facilitate type checking
-/// CUSTOM_POLYHEDRAL_SHAPE_TYPE,CUSTOM_CONVEX_SHAPE_TYPE and CUSTOM_CONCAVE_SHAPE_TYPE can be used to extend Bullet without modifying source code
-enum BroadphaseNativeTypes
-{
-	// polyhedral convex shapes
-	BOX_SHAPE_PROXYTYPE,
-	TRIANGLE_SHAPE_PROXYTYPE,
-	TETRAHEDRAL_SHAPE_PROXYTYPE,
-	CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE,
-	CONVEX_HULL_SHAPE_PROXYTYPE,
-	CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE,
-	CUSTOM_POLYHEDRAL_SHAPE_TYPE,
-//implicit convex shapes
-IMPLICIT_CONVEX_SHAPES_START_HERE,
-	SPHERE_SHAPE_PROXYTYPE,
-	MULTI_SPHERE_SHAPE_PROXYTYPE,
-	CAPSULE_SHAPE_PROXYTYPE,
-	CONE_SHAPE_PROXYTYPE,
-	CONVEX_SHAPE_PROXYTYPE,
-	CYLINDER_SHAPE_PROXYTYPE,
-	UNIFORM_SCALING_SHAPE_PROXYTYPE,
-	MINKOWSKI_SUM_SHAPE_PROXYTYPE,
-	MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE,
-	BOX_2D_SHAPE_PROXYTYPE,
-	CONVEX_2D_SHAPE_PROXYTYPE,
-	CUSTOM_CONVEX_SHAPE_TYPE,
-//concave shapes
-CONCAVE_SHAPES_START_HERE,
-	//keep all the convex shapetype below here, for the check IsConvexShape in broadphase proxy!
-	TRIANGLE_MESH_SHAPE_PROXYTYPE,
-	SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE,
-	///used for demo integration FAST/Swift collision library and Bullet
-	FAST_CONCAVE_MESH_PROXYTYPE,
-	//terrain
-	TERRAIN_SHAPE_PROXYTYPE,
-///Used for GIMPACT Trimesh integration
-	GIMPACT_SHAPE_PROXYTYPE,
-///Multimaterial mesh
-    MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE,
-	
-	EMPTY_SHAPE_PROXYTYPE,
-	STATIC_PLANE_PROXYTYPE,
-	CUSTOM_CONCAVE_SHAPE_TYPE,
-CONCAVE_SHAPES_END_HERE,
-
-	COMPOUND_SHAPE_PROXYTYPE,
-
-	SOFTBODY_SHAPE_PROXYTYPE,
-	HFFLUID_SHAPE_PROXYTYPE,
-	HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE,
-	INVALID_SHAPE_PROXYTYPE,
-
-	MAX_BROADPHASE_COLLISION_TYPES
-	
-};
-
-
-///The btBroadphaseProxy is the main class that can be used with the Bullet broadphases. 
-///It stores collision shape type information, collision filter information and a client object, typically a btCollisionObject or btRigidBody.
-ATTRIBUTE_ALIGNED16(struct) btBroadphaseProxy
-{
-
-BT_DECLARE_ALIGNED_ALLOCATOR();
-	
-	///optional filtering to cull potential collisions
-	enum CollisionFilterGroups
-	{
-	        DefaultFilter = 1,
-	        StaticFilter = 2,
-	        KinematicFilter = 4,
-	        DebrisFilter = 8,
-			SensorTrigger = 16,
-			CharacterFilter = 32,
-	        AllFilter = -1 //all bits sets: DefaultFilter | StaticFilter | KinematicFilter | DebrisFilter | SensorTrigger
-	};
-
-	//Usually the client btCollisionObject or Rigidbody class
-	void*	m_clientObject;
-	short int m_collisionFilterGroup;
-	short int m_collisionFilterMask;
-	void*	m_multiSapParentProxy;		
-	int			m_uniqueId;//m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc.
-
-	btVector3	m_aabbMin;
-	btVector3	m_aabbMax;
-
-	SIMD_FORCE_INLINE int getUid() const
-	{
-		return m_uniqueId;
-	}
-
-	//used for memory pools
-	btBroadphaseProxy() :m_clientObject(0),m_multiSapParentProxy(0)
-	{
-	}
-
-	btBroadphaseProxy(const btVector3& aabbMin,const btVector3& aabbMax,void* userPtr,short int collisionFilterGroup, short int collisionFilterMask,void* multiSapParentProxy=0)
-		:m_clientObject(userPtr),
-		m_collisionFilterGroup(collisionFilterGroup),
-		m_collisionFilterMask(collisionFilterMask),
-		m_aabbMin(aabbMin),
-		m_aabbMax(aabbMax)
-	{
-		m_multiSapParentProxy = multiSapParentProxy;
-	}
-
-	
-
-	static SIMD_FORCE_INLINE bool isPolyhedral(int proxyType)
-	{
-		return (proxyType  < IMPLICIT_CONVEX_SHAPES_START_HERE);
-	}
-
-	static SIMD_FORCE_INLINE bool	isConvex(int proxyType)
-	{
-		return (proxyType < CONCAVE_SHAPES_START_HERE);
-	}
-
-	static SIMD_FORCE_INLINE bool	isNonMoving(int proxyType)
-	{
-		return (isConcave(proxyType) && !(proxyType==GIMPACT_SHAPE_PROXYTYPE));
-	}
-
-	static SIMD_FORCE_INLINE bool	isConcave(int proxyType)
-	{
-		return ((proxyType > CONCAVE_SHAPES_START_HERE) &&
-			(proxyType < CONCAVE_SHAPES_END_HERE));
-	}
-	static SIMD_FORCE_INLINE bool	isCompound(int proxyType)
-	{
-		return (proxyType == COMPOUND_SHAPE_PROXYTYPE);
-	}
-
-	static SIMD_FORCE_INLINE bool	isSoftBody(int proxyType)
-	{
-		return (proxyType == SOFTBODY_SHAPE_PROXYTYPE);
-	}
-
-	static SIMD_FORCE_INLINE bool isInfinite(int proxyType)
-	{
-		return (proxyType == STATIC_PLANE_PROXYTYPE);
-	}
-
-	static SIMD_FORCE_INLINE bool isConvex2d(int proxyType)
-	{
-		return (proxyType == BOX_2D_SHAPE_PROXYTYPE) ||	(proxyType == CONVEX_2D_SHAPE_PROXYTYPE);
-	}
-
-	
-}
-;
-
-class btCollisionAlgorithm;
-
-struct btBroadphaseProxy;
-
-
-
-///The btBroadphasePair class contains a pair of aabb-overlapping objects.
-///A btDispatcher can search a btCollisionAlgorithm that performs exact/narrowphase collision detection on the actual collision shapes.
-ATTRIBUTE_ALIGNED16(struct) btBroadphasePair
-{
-	btBroadphasePair ()
-		:
-	m_pProxy0(0),
-		m_pProxy1(0),
-		m_algorithm(0),
-		m_internalInfo1(0)
-	{
-	}
-
-BT_DECLARE_ALIGNED_ALLOCATOR();
-
-	btBroadphasePair(const btBroadphasePair& other)
-		:		m_pProxy0(other.m_pProxy0),
-				m_pProxy1(other.m_pProxy1),
-				m_algorithm(other.m_algorithm),
-				m_internalInfo1(other.m_internalInfo1)
-	{
-	}
-	btBroadphasePair(btBroadphaseProxy& proxy0,btBroadphaseProxy& proxy1)
-	{
-
-		//keep them sorted, so the std::set operations work
-		if (proxy0.m_uniqueId < proxy1.m_uniqueId)
-        { 
-            m_pProxy0 = &proxy0; 
-            m_pProxy1 = &proxy1; 
-        }
-        else 
-        { 
-			m_pProxy0 = &proxy1; 
-            m_pProxy1 = &proxy0; 
-        }
-
-		m_algorithm = 0;
-		m_internalInfo1 = 0;
-
-	}
-	
-	btBroadphaseProxy* m_pProxy0;
-	btBroadphaseProxy* m_pProxy1;
-	
-	mutable btCollisionAlgorithm* m_algorithm;
-	union { void* m_internalInfo1; int m_internalTmpValue;};//don't use this data, it will be removed in future version.
-
-};
-
-/*
-//comparison for set operation, see Solid DT_Encounter
-SIMD_FORCE_INLINE bool operator<(const btBroadphasePair& a, const btBroadphasePair& b) 
-{ 
-    return a.m_pProxy0 < b.m_pProxy0 || 
-        (a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 < b.m_pProxy1); 
-}
-*/
-
-
-
-class btBroadphasePairSortPredicate
-{
-	public:
-
-		bool operator() ( const btBroadphasePair& a, const btBroadphasePair& b ) const
-		{
-			const int uidA0 = a.m_pProxy0 ? a.m_pProxy0->m_uniqueId : -1;
-			const int uidB0 = b.m_pProxy0 ? b.m_pProxy0->m_uniqueId : -1;
-			const int uidA1 = a.m_pProxy1 ? a.m_pProxy1->m_uniqueId : -1;
-			const int uidB1 = b.m_pProxy1 ? b.m_pProxy1->m_uniqueId : -1;
-
-			 return uidA0 > uidB0 || 
-				(a.m_pProxy0 == b.m_pProxy0 && uidA1 > uidB1) ||
-				(a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 == b.m_pProxy1 && a.m_algorithm > b.m_algorithm); 
-		}
-};
-
-
-SIMD_FORCE_INLINE bool operator==(const btBroadphasePair& a, const btBroadphasePair& b) 
-{
-	 return (a.m_pProxy0 == b.m_pProxy0) && (a.m_pProxy1 == b.m_pProxy1);
-}
-
-
-#endif //BT_BROADPHASE_PROXY_H
-

libs/bullet-2.82-r2704/src/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.cpp

@@ -1,23 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "btCollisionAlgorithm.h"
-#include "btDispatcher.h"
-
-btCollisionAlgorithm::btCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci)
-{
-	m_dispatcher = ci.m_dispatcher1;
-}
-

libs/bullet-2.82-r2704/src/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h

@@ -1,81 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef BT_COLLISION_ALGORITHM_H
-#define BT_COLLISION_ALGORITHM_H
-
-#include "LinearMath/btScalar.h"
-#include "LinearMath/btAlignedObjectArray.h"
-
-struct btBroadphaseProxy;
-class btDispatcher;
-class btManifoldResult;
-class btCollisionObject;
-struct btCollisionObjectWrapper;
-struct btDispatcherInfo;
-class	btPersistentManifold;
-
-typedef btAlignedObjectArray<btPersistentManifold*>	btManifoldArray;
-
-struct btCollisionAlgorithmConstructionInfo
-{
-	btCollisionAlgorithmConstructionInfo()
-		:m_dispatcher1(0),
-		m_manifold(0)
-	{
-	}
-	btCollisionAlgorithmConstructionInfo(btDispatcher* dispatcher,int temp)
-		:m_dispatcher1(dispatcher)
-	{
-		(void)temp;
-	}
-
-	btDispatcher*	m_dispatcher1;
-	btPersistentManifold*	m_manifold;
-
-//	int	getDispatcherId();
-
-};
-
-
-///btCollisionAlgorithm is an collision interface that is compatible with the Broadphase and btDispatcher.
-///It is persistent over frames
-class btCollisionAlgorithm
-{
-
-protected:
-
-	btDispatcher*	m_dispatcher;
-
-protected:
-//	int	getDispatcherId();
-	
-public:
-
-	btCollisionAlgorithm() {};
-
-	btCollisionAlgorithm(const btCollisionAlgorithmConstructionInfo& ci);
-
-	virtual ~btCollisionAlgorithm() {};
-
-	virtual void processCollision (const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut) = 0;
-
-	virtual btScalar calculateTimeOfImpact(btCollisionObject* body0,btCollisionObject* body1,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut) = 0;
-
-	virtual	void	getAllContactManifolds(btManifoldArray&	manifoldArray) = 0;
-};
-
-
-#endif //BT_COLLISION_ALGORITHM_H

libs/bullet-2.82-r2704/src/BulletCollision/BroadphaseCollision/btDbvtBroadphase.cpp

@@ -1,796 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-///btDbvtBroadphase implementation by Nathanael Presson
-
-#include "btDbvtBroadphase.h"
-
-//
-// Profiling
-//
-
-#if DBVT_BP_PROFILE||DBVT_BP_ENABLE_BENCHMARK
-#include <stdio.h>
-#endif
-
-#if DBVT_BP_PROFILE
-struct	ProfileScope
-{
-	__forceinline ProfileScope(btClock& clock,unsigned long& value) :
-	m_clock(&clock),m_value(&value),m_base(clock.getTimeMicroseconds())
-	{
-	}
-	__forceinline ~ProfileScope()
-	{
-		(*m_value)+=m_clock->getTimeMicroseconds()-m_base;
-	}
-	btClock*		m_clock;
-	unsigned long*	m_value;
-	unsigned long	m_base;
-};
-#define	SPC(_value_)	ProfileScope	spc_scope(m_clock,_value_)
-#else
-#define	SPC(_value_)
-#endif
-
-//
-// Helpers
-//
-
-//
-template <typename T>
-static inline void	listappend(T* item,T*& list)
-{
-	item->links[0]=0;
-	item->links[1]=list;
-	if(list) list->links[0]=item;
-	list=item;
-}
-
-//
-template <typename T>
-static inline void	listremove(T* item,T*& list)
-{
-	if(item->links[0]) item->links[0]->links[1]=item->links[1]; else list=item->links[1];
-	if(item->links[1]) item->links[1]->links[0]=item->links[0];
-}
-
-//
-template <typename T>
-static inline int	listcount(T* root)
-{
-	int	n=0;
-	while(root) { ++n;root=root->links[1]; }
-	return(n);
-}
-
-//
-template <typename T>
-static inline void	clear(T& value)
-{
-	static const struct ZeroDummy : T {} zerodummy;
-	value=zerodummy;
-}
-
-//
-// Colliders
-//
-
-/* Tree collider	*/ 
-struct	btDbvtTreeCollider : btDbvt::ICollide
-{
-	btDbvtBroadphase*	pbp;
-	btDbvtProxy*		proxy;
-	btDbvtTreeCollider(btDbvtBroadphase* p) : pbp(p) {}
-	void	Process(const btDbvtNode* na,const btDbvtNode* nb)
-	{
-		if(na!=nb)
-		{
-			btDbvtProxy*	pa=(btDbvtProxy*)na->data;
-			btDbvtProxy*	pb=(btDbvtProxy*)nb->data;
-#if DBVT_BP_SORTPAIRS
-			if(pa->m_uniqueId>pb->m_uniqueId) 
-				btSwap(pa,pb);
-#endif
-			pbp->m_paircache->addOverlappingPair(pa,pb);
-			++pbp->m_newpairs;
-		}
-	}
-	void	Process(const btDbvtNode* n)
-	{
-		Process(n,proxy->leaf);
-	}
-};
-
-//
-// btDbvtBroadphase
-//
-
-//
-btDbvtBroadphase::btDbvtBroadphase(btOverlappingPairCache* paircache)
-{
-	m_deferedcollide	=	false;
-	m_needcleanup		=	true;
-	m_releasepaircache	=	(paircache!=0)?false:true;
-	m_prediction		=	0;
-	m_stageCurrent		=	0;
-	m_fixedleft			=	0;
-	m_fupdates			=	1;
-	m_dupdates			=	0;
-	m_cupdates			=	10;
-	m_newpairs			=	1;
-	m_updates_call		=	0;
-	m_updates_done		=	0;
-	m_updates_ratio		=	0;
-	m_paircache			=	paircache? paircache	: new(btAlignedAlloc(sizeof(btHashedOverlappingPairCache),16)) btHashedOverlappingPairCache();
-	m_gid				=	0;
-	m_pid				=	0;
-	m_cid				=	0;
-	for(int i=0;i<=STAGECOUNT;++i)
-	{
-		m_stageRoots[i]=0;
-	}
-#if DBVT_BP_PROFILE
-	clear(m_profiling);
-#endif
-}
-
-//
-btDbvtBroadphase::~btDbvtBroadphase()
-{
-	if(m_releasepaircache) 
-	{
-		m_paircache->~btOverlappingPairCache();
-		btAlignedFree(m_paircache);
-	}
-}
-
-//
-btBroadphaseProxy*				btDbvtBroadphase::createProxy(	const btVector3& aabbMin,
-															  const btVector3& aabbMax,
-															  int /*shapeType*/,
-															  void* userPtr,
-															  short int collisionFilterGroup,
-															  short int collisionFilterMask,
-															  btDispatcher* /*dispatcher*/,
-															  void* /*multiSapProxy*/)
-{
-	btDbvtProxy*		proxy=new(btAlignedAlloc(sizeof(btDbvtProxy),16)) btDbvtProxy(	aabbMin,aabbMax,userPtr,
-		collisionFilterGroup,
-		collisionFilterMask);
-
-	btDbvtAabbMm aabb = btDbvtVolume::FromMM(aabbMin,aabbMax);
-
-	//bproxy->aabb			=	btDbvtVolume::FromMM(aabbMin,aabbMax);
-	proxy->stage		=	m_stageCurrent;
-	proxy->m_uniqueId	=	++m_gid;
-	proxy->leaf			=	m_sets[0].insert(aabb,proxy);
-	listappend(proxy,m_stageRoots[m_stageCurrent]);
-	if(!m_deferedcollide)
-	{
-		btDbvtTreeCollider	collider(this);
-		collider.proxy=proxy;
-		m_sets[0].collideTV(m_sets[0].m_root,aabb,collider);
-		m_sets[1].collideTV(m_sets[1].m_root,aabb,collider);
-	}
-	return(proxy);
-}
-
-//
-void							btDbvtBroadphase::destroyProxy(	btBroadphaseProxy* absproxy,
-															   btDispatcher* dispatcher)
-{
-	btDbvtProxy*	proxy=(btDbvtProxy*)absproxy;
-	if(proxy->stage==STAGECOUNT)
-		m_sets[1].remove(proxy->leaf);
-	else
-		m_sets[0].remove(proxy->leaf);
-	listremove(proxy,m_stageRoots[proxy->stage]);
-	m_paircache->removeOverlappingPairsContainingProxy(proxy,dispatcher);
-	btAlignedFree(proxy);
-	m_needcleanup=true;
-}
-
-void	btDbvtBroadphase::getAabb(btBroadphaseProxy* absproxy,btVector3& aabbMin, btVector3& aabbMax ) const
-{
-	btDbvtProxy*						proxy=(btDbvtProxy*)absproxy;
-	aabbMin = proxy->m_aabbMin;
-	aabbMax = proxy->m_aabbMax;
-}
-
-struct	BroadphaseRayTester : btDbvt::ICollide
-{
-	btBroadphaseRayCallback& m_rayCallback;
-	BroadphaseRayTester(btBroadphaseRayCallback& orgCallback)
-		:m_rayCallback(orgCallback)
-	{
-	}
-	void					Process(const btDbvtNode* leaf)
-	{
-		btDbvtProxy*	proxy=(btDbvtProxy*)leaf->data;
-		m_rayCallback.process(proxy);
-	}
-};	
-
-void	btDbvtBroadphase::rayTest(const btVector3& rayFrom,const btVector3& rayTo, btBroadphaseRayCallback& rayCallback,const btVector3& aabbMin,const btVector3& aabbMax)
-{
-	BroadphaseRayTester callback(rayCallback);
-
-	m_sets[0].rayTestInternal(	m_sets[0].m_root,
-		rayFrom,
-		rayTo,
-		rayCallback.m_rayDirectionInverse,
-		rayCallback.m_signs,
-		rayCallback.m_lambda_max,
-		aabbMin,
-		aabbMax,
-		callback);
-
-	m_sets[1].rayTestInternal(	m_sets[1].m_root,
-		rayFrom,
-		rayTo,
-		rayCallback.m_rayDirectionInverse,
-		rayCallback.m_signs,
-		rayCallback.m_lambda_max,
-		aabbMin,
-		aabbMax,
-		callback);
-
-}
-
-
-struct	BroadphaseAabbTester : btDbvt::ICollide
-{
-	btBroadphaseAabbCallback& m_aabbCallback;
-	BroadphaseAabbTester(btBroadphaseAabbCallback& orgCallback)
-		:m_aabbCallback(orgCallback)
-	{
-	}
-	void					Process(const btDbvtNode* leaf)
-	{
-		btDbvtProxy*	proxy=(btDbvtProxy*)leaf->data;
-		m_aabbCallback.process(proxy);
-	}
-};	
-
-void	btDbvtBroadphase::aabbTest(const btVector3& aabbMin,const btVector3& aabbMax,btBroadphaseAabbCallback& aabbCallback)
-{
-	BroadphaseAabbTester callback(aabbCallback);
-
-	const ATTRIBUTE_ALIGNED16(btDbvtVolume)	bounds=btDbvtVolume::FromMM(aabbMin,aabbMax);
-		//process all children, that overlap with  the given AABB bounds
-	m_sets[0].collideTV(m_sets[0].m_root,bounds,callback);
-	m_sets[1].collideTV(m_sets[1].m_root,bounds,callback);
-
-}
-
-
-
-//
-void							btDbvtBroadphase::setAabb(		btBroadphaseProxy* absproxy,
-														  const btVector3& aabbMin,
-														  const btVector3& aabbMax,
-														  btDispatcher* /*dispatcher*/)
-{
-	btDbvtProxy*						proxy=(btDbvtProxy*)absproxy;
-	ATTRIBUTE_ALIGNED16(btDbvtVolume)	aabb=btDbvtVolume::FromMM(aabbMin,aabbMax);
-#if DBVT_BP_PREVENTFALSEUPDATE
-	if(NotEqual(aabb,proxy->leaf->volume))
-#endif
-	{
-		bool	docollide=false;
-		if(proxy->stage==STAGECOUNT)
-		{/* fixed -> dynamic set	*/ 
-			m_sets[1].remove(proxy->leaf);
-			proxy->leaf=m_sets[0].insert(aabb,proxy);
-			docollide=true;
-		}
-		else
-		{/* dynamic set				*/ 
-			++m_updates_call;
-			if(Intersect(proxy->leaf->volume,aabb))
-			{/* Moving				*/ 
-
-				const btVector3	delta=aabbMin-proxy->m_aabbMin;
-				btVector3		velocity(((proxy->m_aabbMax-proxy->m_aabbMin)/2)*m_prediction);
-				if(delta[0]<0) velocity[0]=-velocity[0];
-				if(delta[1]<0) velocity[1]=-velocity[1];
-				if(delta[2]<0) velocity[2]=-velocity[2];
-				if	(
-#ifdef DBVT_BP_MARGIN				
-					m_sets[0].update(proxy->leaf,aabb,velocity,DBVT_BP_MARGIN)
-#else
-					m_sets[0].update(proxy->leaf,aabb,velocity)
-#endif
-					)
-				{
-					++m_updates_done;
-					docollide=true;
-				}
-			}
-			else
-			{/* Teleporting			*/ 
-				m_sets[0].update(proxy->leaf,aabb);
-				++m_updates_done;
-				docollide=true;
-			}	
-		}
-		listremove(proxy,m_stageRoots[proxy->stage]);
-		proxy->m_aabbMin = aabbMin;
-		proxy->m_aabbMax = aabbMax;
-		proxy->stage	=	m_stageCurrent;
-		listappend(proxy,m_stageRoots[m_stageCurrent]);
-		if(docollide)
-		{
-			m_needcleanup=true;
-			if(!m_deferedcollide)
-			{
-				btDbvtTreeCollider	collider(this);
-				m_sets[1].collideTTpersistentStack(m_sets[1].m_root,proxy->leaf,collider);
-				m_sets[0].collideTTpersistentStack(m_sets[0].m_root,proxy->leaf,collider);
-			}
-		}	
-	}
-}
-
-
-//
-void							btDbvtBroadphase::setAabbForceUpdate(		btBroadphaseProxy* absproxy,
-														  const btVector3& aabbMin,
-														  const btVector3& aabbMax,
-														  btDispatcher* /*dispatcher*/)
-{
-	btDbvtProxy*						proxy=(btDbvtProxy*)absproxy;
-	ATTRIBUTE_ALIGNED16(btDbvtVolume)	aabb=btDbvtVolume::FromMM(aabbMin,aabbMax);
-	bool	docollide=false;
-	if(proxy->stage==STAGECOUNT)
-	{/* fixed -> dynamic set	*/ 
-		m_sets[1].remove(proxy->leaf);
-		proxy->leaf=m_sets[0].insert(aabb,proxy);
-		docollide=true;
-	}
-	else
-	{/* dynamic set				*/ 
-		++m_updates_call;
-		/* Teleporting			*/ 
-		m_sets[0].update(proxy->leaf,aabb);
-		++m_updates_done;
-		docollide=true;
-	}
-	listremove(proxy,m_stageRoots[proxy->stage]);
-	proxy->m_aabbMin = aabbMin;
-	proxy->m_aabbMax = aabbMax;
-	proxy->stage	=	m_stageCurrent;
-	listappend(proxy,m_stageRoots[m_stageCurrent]);
-	if(docollide)
-	{
-		m_needcleanup=true;
-		if(!m_deferedcollide)
-		{
-			btDbvtTreeCollider	collider(this);
-			m_sets[1].collideTTpersistentStack(m_sets[1].m_root,proxy->leaf,collider);
-			m_sets[0].collideTTpersistentStack(m_sets[0].m_root,proxy->leaf,collider);
-		}
-	}	
-}
-
-//
-void							btDbvtBroadphase::calculateOverlappingPairs(btDispatcher* dispatcher)
-{
-	collide(dispatcher);
-#if DBVT_BP_PROFILE
-	if(0==(m_pid%DBVT_BP_PROFILING_RATE))
-	{	
-		printf("fixed(%u) dynamics(%u) pairs(%u)\r\n",m_sets[1].m_leaves,m_sets[0].m_leaves,m_paircache->getNumOverlappingPairs());
-		unsigned int	total=m_profiling.m_total;
-		if(total<=0) total=1;
-		printf("ddcollide: %u%% (%uus)\r\n",(50+m_profiling.m_ddcollide*100)/total,m_profiling.m_ddcollide/DBVT_BP_PROFILING_RATE);
-		printf("fdcollide: %u%% (%uus)\r\n",(50+m_profiling.m_fdcollide*100)/total,m_profiling.m_fdcollide/DBVT_BP_PROFILING_RATE);
-		printf("cleanup:   %u%% (%uus)\r\n",(50+m_profiling.m_cleanup*100)/total,m_profiling.m_cleanup/DBVT_BP_PROFILING_RATE);
-		printf("total:     %uus\r\n",total/DBVT_BP_PROFILING_RATE);
-		const unsigned long	sum=m_profiling.m_ddcollide+
-			m_profiling.m_fdcollide+
-			m_profiling.m_cleanup;
-		printf("leaked: %u%% (%uus)\r\n",100-((50+sum*100)/total),(total-sum)/DBVT_BP_PROFILING_RATE);
-		printf("job counts: %u%%\r\n",(m_profiling.m_jobcount*100)/((m_sets[0].m_leaves+m_sets[1].m_leaves)*DBVT_BP_PROFILING_RATE));
-		clear(m_profiling);
-		m_clock.reset();
-	}
-#endif
-
-	performDeferredRemoval(dispatcher);
-
-}
-
-void btDbvtBroadphase::performDeferredRemoval(btDispatcher* dispatcher)
-{
-
-	if (m_paircache->hasDeferredRemoval())
-	{
-
-		btBroadphasePairArray&	overlappingPairArray = m_paircache->getOverlappingPairArray();
-
-		//perform a sort, to find duplicates and to sort 'invalid' pairs to the end
-		overlappingPairArray.quickSort(btBroadphasePairSortPredicate());
-
-		int invalidPair = 0;
-
-		
-		int i;
-
-		btBroadphasePair previousPair;
-		previousPair.m_pProxy0 = 0;
-		previousPair.m_pProxy1 = 0;
-		previousPair.m_algorithm = 0;
-		
-		
-		for (i=0;i<overlappingPairArray.size();i++)
-		{
-		
-			btBroadphasePair& pair = overlappingPairArray[i];
-
-			bool isDuplicate = (pair == previousPair);
-
-			previousPair = pair;
-
-			bool needsRemoval = false;
-
-			if (!isDuplicate)
-			{
-				//important to perform AABB check that is consistent with the broadphase
-				btDbvtProxy*		pa=(btDbvtProxy*)pair.m_pProxy0;
-				btDbvtProxy*		pb=(btDbvtProxy*)pair.m_pProxy1;
-				bool hasOverlap = Intersect(pa->leaf->volume,pb->leaf->volume);
-
-				if (hasOverlap)
-				{
-					needsRemoval = false;
-				} else
-				{
-					needsRemoval = true;
-				}
-			} else
-			{
-				//remove duplicate
-				needsRemoval = true;
-				//should have no algorithm
-				btAssert(!pair.m_algorithm);
-			}
-			
-			if (needsRemoval)
-			{
-				m_paircache->cleanOverlappingPair(pair,dispatcher);
-
-				pair.m_pProxy0 = 0;
-				pair.m_pProxy1 = 0;
-				invalidPair++;
-			} 
-			
-		}
-
-		//perform a sort, to sort 'invalid' pairs to the end
-		overlappingPairArray.quickSort(btBroadphasePairSortPredicate());
-		overlappingPairArray.resize(overlappingPairArray.size() - invalidPair);
-	}
-}
-
-//
-void							btDbvtBroadphase::collide(btDispatcher* dispatcher)
-{
-	/*printf("---------------------------------------------------------\n");
-	printf("m_sets[0].m_leaves=%d\n",m_sets[0].m_leaves);
-	printf("m_sets[1].m_leaves=%d\n",m_sets[1].m_leaves);
-	printf("numPairs = %d\n",getOverlappingPairCache()->getNumOverlappingPairs());
-	{
-		int i;
-		for (i=0;i<getOverlappingPairCache()->getNumOverlappingPairs();i++)
-		{
-			printf("pair[%d]=(%d,%d),",i,getOverlappingPairCache()->getOverlappingPairArray()[i].m_pProxy0->getUid(),
-				getOverlappingPairCache()->getOverlappingPairArray()[i].m_pProxy1->getUid());
-		}
-		printf("\n");
-	}
-*/
-
-
-
-	SPC(m_profiling.m_total);
-	/* optimize				*/ 
-	m_sets[0].optimizeIncremental(1+(m_sets[0].m_leaves*m_dupdates)/100);
-	if(m_fixedleft)
-	{
-		const int count=1+(m_sets[1].m_leaves*m_fupdates)/100;
-		m_sets[1].optimizeIncremental(1+(m_sets[1].m_leaves*m_fupdates)/100);
-		m_fixedleft=btMax<int>(0,m_fixedleft-count);
-	}
-	/* dynamic -> fixed set	*/ 
-	m_stageCurrent=(m_stageCurrent+1)%STAGECOUNT;
-	btDbvtProxy*	current=m_stageRoots[m_stageCurrent];
-	if(current)
-	{
-		btDbvtTreeCollider	collider(this);
-		do	{
-			btDbvtProxy*	next=current->links[1];
-			listremove(current,m_stageRoots[current->stage]);
-			listappend(current,m_stageRoots[STAGECOUNT]);
-#if DBVT_BP_ACCURATESLEEPING
-			m_paircache->removeOverlappingPairsContainingProxy(current,dispatcher);
-			collider.proxy=current;
-			btDbvt::collideTV(m_sets[0].m_root,current->aabb,collider);
-			btDbvt::collideTV(m_sets[1].m_root,current->aabb,collider);
-#endif
-			m_sets[0].remove(current->leaf);
-			ATTRIBUTE_ALIGNED16(btDbvtVolume)	curAabb=btDbvtVolume::FromMM(current->m_aabbMin,current->m_aabbMax);
-			current->leaf	=	m_sets[1].insert(curAabb,current);
-			current->stage	=	STAGECOUNT;	
-			current			=	next;
-		} while(current);
-		m_fixedleft=m_sets[1].m_leaves;
-		m_needcleanup=true;
-	}
-	/* collide dynamics		*/ 
-	{
-		btDbvtTreeCollider	collider(this);
-		if(m_deferedcollide)
-		{
-			SPC(m_profiling.m_fdcollide);
-			m_sets[0].collideTTpersistentStack(m_sets[0].m_root,m_sets[1].m_root,collider);
-		}
-		if(m_deferedcollide)
-		{
-			SPC(m_profiling.m_ddcollide);
-			m_sets[0].collideTTpersistentStack(m_sets[0].m_root,m_sets[0].m_root,collider);
-		}
-	}
-	/* clean up				*/ 
-	if(m_needcleanup)
-	{
-		SPC(m_profiling.m_cleanup);
-		btBroadphasePairArray&	pairs=m_paircache->getOverlappingPairArray();
-		if(pairs.size()>0)
-		{
-
-			int			ni=btMin(pairs.size(),btMax<int>(m_newpairs,(pairs.size()*m_cupdates)/100));
-			for(int i=0;i<ni;++i)
-			{
-				btBroadphasePair&	p=pairs[(m_cid+i)%pairs.size()];
-				btDbvtProxy*		pa=(btDbvtProxy*)p.m_pProxy0;
-				btDbvtProxy*		pb=(btDbvtProxy*)p.m_pProxy1;
-				if(!Intersect(pa->leaf->volume,pb->leaf->volume))
-				{
-#if DBVT_BP_SORTPAIRS
-					if(pa->m_uniqueId>pb->m_uniqueId) 
-						btSwap(pa,pb);
-#endif
-					m_paircache->removeOverlappingPair(pa,pb,dispatcher);
-					--ni;--i;
-				}
-			}
-			if(pairs.size()>0) m_cid=(m_cid+ni)%pairs.size(); else m_cid=0;
-		}
-	}
-	++m_pid;
-	m_newpairs=1;
-	m_needcleanup=false;
-	if(m_updates_call>0)
-	{ m_updates_ratio=m_updates_done/(btScalar)m_updates_call; }
-	else
-	{ m_updates_ratio=0; }
-	m_updates_done/=2;
-	m_updates_call/=2;
-}
-
-//
-void							btDbvtBroadphase::optimize()
-{
-	m_sets[0].optimizeTopDown();
-	m_sets[1].optimizeTopDown();
-}
-
-//
-btOverlappingPairCache*			btDbvtBroadphase::getOverlappingPairCache()
-{
-	return(m_paircache);
-}
-
-//
-const btOverlappingPairCache*	btDbvtBroadphase::getOverlappingPairCache() const
-{
-	return(m_paircache);
-}
-
-//
-void							btDbvtBroadphase::getBroadphaseAabb(btVector3& aabbMin,btVector3& aabbMax) const
-{
-
-	ATTRIBUTE_ALIGNED16(btDbvtVolume)	bounds;
-
-	if(!m_sets[0].empty())
-		if(!m_sets[1].empty())	Merge(	m_sets[0].m_root->volume,
-			m_sets[1].m_root->volume,bounds);
-		else
-			bounds=m_sets[0].m_root->volume;
-	else if(!m_sets[1].empty())	bounds=m_sets[1].m_root->volume;
-	else
-		bounds=btDbvtVolume::FromCR(btVector3(0,0,0),0);
-	aabbMin=bounds.Mins();
-	aabbMax=bounds.Maxs();
-}
-
-void btDbvtBroadphase::resetPool(btDispatcher* dispatcher)
-{
-	
-	int totalObjects = m_sets[0].m_leaves + m_sets[1].m_leaves;
-	if (!totalObjects)
-	{
-		//reset internal dynamic tree data structures
-		m_sets[0].clear();
-		m_sets[1].clear();
-		
-		m_deferedcollide	=	false;
-		m_needcleanup		=	true;
-		m_stageCurrent		=	0;
-		m_fixedleft			=	0;
-		m_fupdates			=	1;
-		m_dupdates			=	0;
-		m_cupdates			=	10;
-		m_newpairs			=	1;
-		m_updates_call		=	0;
-		m_updates_done		=	0;
-		m_updates_ratio		=	0;
-		
-		m_gid				=	0;
-		m_pid				=	0;
-		m_cid				=	0;
-		for(int i=0;i<=STAGECOUNT;++i)
-		{
-			m_stageRoots[i]=0;
-		}
-	}
-}
-
-//
-void							btDbvtBroadphase::printStats()
-{}
-
-//
-#if DBVT_BP_ENABLE_BENCHMARK
-
-struct	btBroadphaseBenchmark
-{
-	struct	Experiment
-	{
-		const char*			name;
-		int					object_count;
-		int					update_count;
-		int					spawn_count;
-		int					iterations;
-		btScalar			speed;
-		btScalar			amplitude;
-	};
-	struct	Object
-	{
-		btVector3			center;
-		btVector3			extents;
-		btBroadphaseProxy*	proxy;
-		btScalar			time;
-		void				update(btScalar speed,btScalar amplitude,btBroadphaseInterface* pbi)
-		{
-			time		+=	speed;
-			center[0]	=	btCos(time*(btScalar)2.17)*amplitude+
-				btSin(time)*amplitude/2;
-			center[1]	=	btCos(time*(btScalar)1.38)*amplitude+
-				btSin(time)*amplitude;
-			center[2]	=	btSin(time*(btScalar)0.777)*amplitude;
-			pbi->setAabb(proxy,center-extents,center+extents,0);
-		}
-	};
-	static int		UnsignedRand(int range=RAND_MAX-1)	{ return(rand()%(range+1)); }
-	static btScalar	UnitRand()							{ return(UnsignedRand(16384)/(btScalar)16384); }
-	static void		OutputTime(const char* name,btClock& c,unsigned count=0)
-	{
-		const unsigned long	us=c.getTimeMicroseconds();
-		const unsigned long	ms=(us+500)/1000;
-		const btScalar		sec=us/(btScalar)(1000*1000);
-		if(count>0)
-			printf("%s : %u us (%u ms), %.2f/s\r\n",name,us,ms,count/sec);
-		else
-			printf("%s : %u us (%u ms)\r\n",name,us,ms);
-	}
-};
-
-void							btDbvtBroadphase::benchmark(btBroadphaseInterface* pbi)
-{
-	static const btBroadphaseBenchmark::Experiment		experiments[]=
-	{
-		{"1024o.10%",1024,10,0,8192,(btScalar)0.005,(btScalar)100},
-		/*{"4096o.10%",4096,10,0,8192,(btScalar)0.005,(btScalar)100},
-		{"8192o.10%",8192,10,0,8192,(btScalar)0.005,(btScalar)100},*/
-	};
-	static const int										nexperiments=sizeof(experiments)/sizeof(experiments[0]);
-	btAlignedObjectArray<btBroadphaseBenchmark::Object*>	objects;
-	btClock													wallclock;
-	/* Begin			*/ 
-	for(int iexp=0;iexp<nexperiments;++iexp)
-	{
-		const btBroadphaseBenchmark::Experiment&	experiment=experiments[iexp];
-		const int									object_count=experiment.object_count;
-		const int									update_count=(object_count*experiment.update_count)/100;
-		const int									spawn_count=(object_count*experiment.spawn_count)/100;
-		const btScalar								speed=experiment.speed;	
-		const btScalar								amplitude=experiment.amplitude;
-		printf("Experiment #%u '%s':\r\n",iexp,experiment.name);
-		printf("\tObjects: %u\r\n",object_count);
-		printf("\tUpdate: %u\r\n",update_count);
-		printf("\tSpawn: %u\r\n",spawn_count);
-		printf("\tSpeed: %f\r\n",speed);
-		printf("\tAmplitude: %f\r\n",amplitude);
-		srand(180673);
-		/* Create objects	*/ 
-		wallclock.reset();
-		objects.reserve(object_count);
-		for(int i=0;i<object_count;++i)
-		{
-			btBroadphaseBenchmark::Object*	po=new btBroadphaseBenchmark::Object();
-			po->center[0]=btBroadphaseBenchmark::UnitRand()*50;
-			po->center[1]=btBroadphaseBenchmark::UnitRand()*50;
-			po->center[2]=btBroadphaseBenchmark::UnitRand()*50;
-			po->extents[0]=btBroadphaseBenchmark::UnitRand()*2+2;
-			po->extents[1]=btBroadphaseBenchmark::UnitRand()*2+2;
-			po->extents[2]=btBroadphaseBenchmark::UnitRand()*2+2;
-			po->time=btBroadphaseBenchmark::UnitRand()*2000;
-			po->proxy=pbi->createProxy(po->center-po->extents,po->center+po->extents,0,po,1,1,0,0);
-			objects.push_back(po);
-		}
-		btBroadphaseBenchmark::OutputTime("\tInitialization",wallclock);
-		/* First update		*/ 
-		wallclock.reset();
-		for(int i=0;i<objects.size();++i)
-		{
-			objects[i]->update(speed,amplitude,pbi);
-		}
-		btBroadphaseBenchmark::OutputTime("\tFirst update",wallclock);
-		/* Updates			*/ 
-		wallclock.reset();
-		for(int i=0;i<experiment.iterations;++i)
-		{
-			for(int j=0;j<update_count;++j)
-			{				
-				objects[j]->update(speed,amplitude,pbi);
-			}
-			pbi->calculateOverlappingPairs(0);
-		}
-		btBroadphaseBenchmark::OutputTime("\tUpdate",wallclock,experiment.iterations);
-		/* Clean up			*/ 
-		wallclock.reset();
-		for(int i=0;i<objects.size();++i)
-		{
-			pbi->destroyProxy(objects[i]->proxy,0);
-			delete objects[i];
-		}
-		objects.resize(0);
-		btBroadphaseBenchmark::OutputTime("\tRelease",wallclock);
-	}
-
-}
-#else
-void							btDbvtBroadphase::benchmark(btBroadphaseInterface*)
-{}
-#endif
-
-#if DBVT_BP_PROFILE
-#undef	SPC
-#endif
-

libs/bullet-2.82-r2704/src/BulletCollision/BroadphaseCollision/btDbvtBroadphase.h

@@ -1,146 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-///btDbvtBroadphase implementation by Nathanael Presson
-#ifndef BT_DBVT_BROADPHASE_H
-#define BT_DBVT_BROADPHASE_H
-
-#include "BulletCollision/BroadphaseCollision/btDbvt.h"
-#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h"
-
-//
-// Compile time config
-//
-
-#define	DBVT_BP_PROFILE					0
-//#define DBVT_BP_SORTPAIRS				1
-#define DBVT_BP_PREVENTFALSEUPDATE		0
-#define DBVT_BP_ACCURATESLEEPING		0
-#define DBVT_BP_ENABLE_BENCHMARK		0
-#define DBVT_BP_MARGIN					(btScalar)0.05
-
-#if DBVT_BP_PROFILE
-#define	DBVT_BP_PROFILING_RATE	256
-#include "LinearMath/btQuickprof.h"
-#endif
-
-//
-// btDbvtProxy
-//
-struct btDbvtProxy : btBroadphaseProxy
-{
-	/* Fields		*/ 
-	//btDbvtAabbMm	aabb;
-	btDbvtNode*		leaf;
-	btDbvtProxy*	links[2];
-	int				stage;
-	/* ctor			*/ 
-	btDbvtProxy(const btVector3& aabbMin,const btVector3& aabbMax,void* userPtr,short int collisionFilterGroup, short int collisionFilterMask) :
-	btBroadphaseProxy(aabbMin,aabbMax,userPtr,collisionFilterGroup,collisionFilterMask)
-	{
-		links[0]=links[1]=0;
-	}
-};
-
-typedef btAlignedObjectArray<btDbvtProxy*>	btDbvtProxyArray;
-
-///The btDbvtBroadphase implements a broadphase using two dynamic AABB bounding volume hierarchies/trees (see btDbvt).
-///One tree is used for static/non-moving objects, and another tree is used for dynamic objects. Objects can move from one tree to the other.
-///This is a very fast broadphase, especially for very dynamic worlds where many objects are moving. Its insert/add and remove of objects is generally faster than the sweep and prune broadphases btAxisSweep3 and bt32BitAxisSweep3.
-struct	btDbvtBroadphase : btBroadphaseInterface
-{
-	/* Config		*/ 
-	enum	{
-		DYNAMIC_SET			=	0,	/* Dynamic set index	*/ 
-		FIXED_SET			=	1,	/* Fixed set index		*/ 
-		STAGECOUNT			=	2	/* Number of stages		*/ 
-	};
-	/* Fields		*/ 
-	btDbvt					m_sets[2];					// Dbvt sets
-	btDbvtProxy*			m_stageRoots[STAGECOUNT+1];	// Stages list
-	btOverlappingPairCache*	m_paircache;				// Pair cache
-	btScalar				m_prediction;				// Velocity prediction
-	int						m_stageCurrent;				// Current stage
-	int						m_fupdates;					// % of fixed updates per frame
-	int						m_dupdates;					// % of dynamic updates per frame
-	int						m_cupdates;					// % of cleanup updates per frame
-	int						m_newpairs;					// Number of pairs created
-	int						m_fixedleft;				// Fixed optimization left
-	unsigned				m_updates_call;				// Number of updates call
-	unsigned				m_updates_done;				// Number of updates done
-	btScalar				m_updates_ratio;			// m_updates_done/m_updates_call
-	int						m_pid;						// Parse id
-	int						m_cid;						// Cleanup index
-	int						m_gid;						// Gen id
-	bool					m_releasepaircache;			// Release pair cache on delete
-	bool					m_deferedcollide;			// Defere dynamic/static collision to collide call
-	bool					m_needcleanup;				// Need to run cleanup?
-#if DBVT_BP_PROFILE
-	btClock					m_clock;
-	struct	{
-		unsigned long		m_total;
-		unsigned long		m_ddcollide;
-		unsigned long		m_fdcollide;
-		unsigned long		m_cleanup;
-		unsigned long		m_jobcount;
-	}				m_profiling;
-#endif
-	/* Methods		*/ 
-	btDbvtBroadphase(btOverlappingPairCache* paircache=0);
-	~btDbvtBroadphase();
-	void							collide(btDispatcher* dispatcher);
-	void							optimize();
-	
-	/* btBroadphaseInterface Implementation	*/
-	btBroadphaseProxy*				createProxy(const btVector3& aabbMin,const btVector3& aabbMax,int shapeType,void* userPtr,short int collisionFilterGroup,short int collisionFilterMask,btDispatcher* dispatcher,void* multiSapProxy);
-	virtual void					destroyProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher);
-	virtual void					setAabb(btBroadphaseProxy* proxy,const btVector3& aabbMin,const btVector3& aabbMax,btDispatcher* dispatcher);
-	virtual void					rayTest(const btVector3& rayFrom,const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin=btVector3(0,0,0), const btVector3& aabbMax = btVector3(0,0,0));
-	virtual void					aabbTest(const btVector3& aabbMin, const btVector3& aabbMax, btBroadphaseAabbCallback& callback);
-
-	virtual void					getAabb(btBroadphaseProxy* proxy,btVector3& aabbMin, btVector3& aabbMax ) const;
-	virtual	void					calculateOverlappingPairs(btDispatcher* dispatcher);
-	virtual	btOverlappingPairCache*	getOverlappingPairCache();
-	virtual	const btOverlappingPairCache*	getOverlappingPairCache() const;
-	virtual	void					getBroadphaseAabb(btVector3& aabbMin,btVector3& aabbMax) const;
-	virtual	void					printStats();
-
-
-	///reset broadphase internal structures, to ensure determinism/reproducability
-	virtual void resetPool(btDispatcher* dispatcher);
-
-	void	performDeferredRemoval(btDispatcher* dispatcher);
-	
-	void	setVelocityPrediction(btScalar prediction)
-	{
-		m_prediction = prediction;
-	}
-	btScalar getVelocityPrediction() const
-	{
-		return m_prediction;
-	}
-
-	///this setAabbForceUpdate is similar to setAabb but always forces the aabb update. 
-	///it is not part of the btBroadphaseInterface but specific to btDbvtBroadphase.
-	///it bypasses certain optimizations that prevent aabb updates (when the aabb shrinks), see
-	///http://code.google.com/p/bullet/issues/detail?id=223
-	void							setAabbForceUpdate(		btBroadphaseProxy* absproxy,const btVector3& aabbMin,const btVector3& aabbMax,btDispatcher* /*dispatcher*/);
-
-	static void						benchmark(btBroadphaseInterface*);
-
-
-};
-
-#endif

libs/bullet-2.82-r2704/src/BulletCollision/BroadphaseCollision/btDispatcher.cpp

@@ -1,22 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "btDispatcher.h"
-
-btDispatcher::~btDispatcher()
-{
-
-}
-

libs/bullet-2.82-r2704/src/BulletCollision/BroadphaseCollision/btDispatcher.h

@@ -1,107 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef BT_DISPATCHER_H
-#define BT_DISPATCHER_H
-#include "LinearMath/btScalar.h"
-
-class btCollisionAlgorithm;
-struct btBroadphaseProxy;
-class btRigidBody;
-class	btCollisionObject;
-class btOverlappingPairCache;
-struct btCollisionObjectWrapper;
-
-class btPersistentManifold;
-class btPoolAllocator;
-
-struct btDispatcherInfo
-{
-	enum DispatchFunc
-	{
-		DISPATCH_DISCRETE = 1,
-		DISPATCH_CONTINUOUS
-	};
-	btDispatcherInfo()
-		:m_timeStep(btScalar(0.)),
-		m_stepCount(0),
-		m_dispatchFunc(DISPATCH_DISCRETE),
-		m_timeOfImpact(btScalar(1.)),
-		m_useContinuous(true),
-		m_debugDraw(0),
-		m_enableSatConvex(false),
-		m_enableSPU(true),
-		m_useEpa(true),
-		m_allowedCcdPenetration(btScalar(0.04)),
-		m_useConvexConservativeDistanceUtil(false),
-		m_convexConservativeDistanceThreshold(0.0f)
-	{
-
-	}
-	btScalar	m_timeStep;
-	int			m_stepCount;
-	int			m_dispatchFunc;
-	mutable btScalar	m_timeOfImpact;
-	bool		m_useContinuous;
-	class btIDebugDraw*	m_debugDraw;
-	bool		m_enableSatConvex;
-	bool		m_enableSPU;
-	bool		m_useEpa;
-	btScalar	m_allowedCcdPenetration;
-	bool		m_useConvexConservativeDistanceUtil;
-	btScalar	m_convexConservativeDistanceThreshold;
-};
-
-///The btDispatcher interface class can be used in combination with broadphase to dispatch calculations for overlapping pairs.
-///For example for pairwise collision detection, calculating contact points stored in btPersistentManifold or user callbacks (game logic).
-class btDispatcher
-{
-
-
-public:
-	virtual ~btDispatcher() ;
-
-	virtual btCollisionAlgorithm* findAlgorithm(const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap,btPersistentManifold* sharedManifold=0) = 0;
-
-	virtual btPersistentManifold*	getNewManifold(const btCollisionObject* b0,const btCollisionObject* b1)=0;
-
-	virtual void releaseManifold(btPersistentManifold* manifold)=0;
-
-	virtual void clearManifold(btPersistentManifold* manifold)=0;
-
-	virtual bool	needsCollision(const btCollisionObject* body0,const btCollisionObject* body1) = 0;
-
-	virtual bool	needsResponse(const btCollisionObject* body0,const btCollisionObject* body1)=0;
-
-	virtual void	dispatchAllCollisionPairs(btOverlappingPairCache* pairCache,const btDispatcherInfo& dispatchInfo,btDispatcher* dispatcher)  =0;
-
-	virtual int getNumManifolds() const = 0;
-
-	virtual btPersistentManifold* getManifoldByIndexInternal(int index) = 0;
-
-	virtual	btPersistentManifold**	getInternalManifoldPointer() = 0;
-
-	virtual	btPoolAllocator*	getInternalManifoldPool() = 0;
-
-	virtual	const btPoolAllocator*	getInternalManifoldPool() const = 0;
-
-	virtual	void* allocateCollisionAlgorithm(int size)  = 0;
-
-	virtual	void freeCollisionAlgorithm(void* ptr) = 0;
-
-};
-
-
-#endif //BT_DISPATCHER_H

libs/bullet-2.82-r2704/src/BulletCollision/BroadphaseCollision/btMultiSapBroadphase.cpp

@@ -1,489 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "btMultiSapBroadphase.h"
-
-#include "btSimpleBroadphase.h"
-#include "LinearMath/btAabbUtil2.h"
-#include "btQuantizedBvh.h"
-
-///	btSapBroadphaseArray	m_sapBroadphases;
-
-///	btOverlappingPairCache*	m_overlappingPairs;
-extern int gOverlappingPairs;
-
-/*
-class btMultiSapSortedOverlappingPairCache : public btSortedOverlappingPairCache
-{
-public:
-
-	virtual btBroadphasePair*	addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
-	{
-		return btSortedOverlappingPairCache::addOverlappingPair((btBroadphaseProxy*)proxy0->m_multiSapParentProxy,(btBroadphaseProxy*)proxy1->m_multiSapParentProxy);
-	}
-};
-
-*/
-
-btMultiSapBroadphase::btMultiSapBroadphase(int /*maxProxies*/,btOverlappingPairCache* pairCache)
-:m_overlappingPairs(pairCache),
-m_optimizedAabbTree(0),
-m_ownsPairCache(false),
-m_invalidPair(0)
-{
-	if (!m_overlappingPairs)
-	{
-		m_ownsPairCache = true;
-		void* mem = btAlignedAlloc(sizeof(btSortedOverlappingPairCache),16);
-		m_overlappingPairs = new (mem)btSortedOverlappingPairCache();
-	}
-
-	struct btMultiSapOverlapFilterCallback : public btOverlapFilterCallback
-	{
-		virtual ~btMultiSapOverlapFilterCallback()
-		{}
-		// return true when pairs need collision
-		virtual bool	needBroadphaseCollision(btBroadphaseProxy* childProxy0,btBroadphaseProxy* childProxy1) const
-		{
-			btBroadphaseProxy* multiProxy0 = (btBroadphaseProxy*)childProxy0->m_multiSapParentProxy;
-			btBroadphaseProxy* multiProxy1 = (btBroadphaseProxy*)childProxy1->m_multiSapParentProxy;
-			
-			bool collides = (multiProxy0->m_collisionFilterGroup & multiProxy1->m_collisionFilterMask) != 0;
-			collides = collides && (multiProxy1->m_collisionFilterGroup & multiProxy0->m_collisionFilterMask);
-	
-			return collides;
-		}
-	};
-
-	void* mem = btAlignedAlloc(sizeof(btMultiSapOverlapFilterCallback),16);
-	m_filterCallback = new (mem)btMultiSapOverlapFilterCallback();
-
-	m_overlappingPairs->setOverlapFilterCallback(m_filterCallback);
-//	mem = btAlignedAlloc(sizeof(btSimpleBroadphase),16);
-//	m_simpleBroadphase = new (mem) btSimpleBroadphase(maxProxies,m_overlappingPairs);
-}
-
-btMultiSapBroadphase::~btMultiSapBroadphase()
-{
-	if (m_ownsPairCache)
-	{
-		m_overlappingPairs->~btOverlappingPairCache();
-		btAlignedFree(m_overlappingPairs);
-	}
-}
-
-
-void	btMultiSapBroadphase::buildTree(const btVector3& bvhAabbMin,const btVector3& bvhAabbMax)
-{
-	m_optimizedAabbTree = new btQuantizedBvh();
-	m_optimizedAabbTree->setQuantizationValues(bvhAabbMin,bvhAabbMax);
-	QuantizedNodeArray&	nodes = m_optimizedAabbTree->getLeafNodeArray();
-	for (int i=0;i<m_sapBroadphases.size();i++)
-	{
-		btQuantizedBvhNode node;
-		btVector3 aabbMin,aabbMax;
-		m_sapBroadphases[i]->getBroadphaseAabb(aabbMin,aabbMax);
-		m_optimizedAabbTree->quantize(&node.m_quantizedAabbMin[0],aabbMin,0);
-		m_optimizedAabbTree->quantize(&node.m_quantizedAabbMax[0],aabbMax,1);
-		int partId = 0;
-		node.m_escapeIndexOrTriangleIndex = (partId<<(31-MAX_NUM_PARTS_IN_BITS)) | i;
-		nodes.push_back(node);
-	}
-	m_optimizedAabbTree->buildInternal();
-}
-
-btBroadphaseProxy*	btMultiSapBroadphase::createProxy(  const btVector3& aabbMin,  const btVector3& aabbMax,int shapeType,void* userPtr, short int collisionFilterGroup,short int collisionFilterMask, btDispatcher* dispatcher,void* /*ignoreMe*/)
-{
-	//void* ignoreMe -> we could think of recursive multi-sap, if someone is interested
-
-	void* mem = btAlignedAlloc(sizeof(btMultiSapProxy),16);
-	btMultiSapProxy* proxy = new (mem)btMultiSapProxy(aabbMin,  aabbMax,shapeType,userPtr, collisionFilterGroup,collisionFilterMask);
-	m_multiSapProxies.push_back(proxy);
-
-	///this should deal with inserting/removal into child broadphases
-	setAabb(proxy,aabbMin,aabbMax,dispatcher);
-	return proxy;
-}
-
-void	btMultiSapBroadphase::destroyProxy(btBroadphaseProxy* /*proxy*/,btDispatcher* /*dispatcher*/)
-{
-	///not yet
-	btAssert(0);
-
-}
-
-
-void	btMultiSapBroadphase::addToChildBroadphase(btMultiSapProxy* parentMultiSapProxy, btBroadphaseProxy* childProxy, btBroadphaseInterface*	childBroadphase)
-{
-	void* mem = btAlignedAlloc(sizeof(btBridgeProxy),16);
-	btBridgeProxy* bridgeProxyRef = new(mem) btBridgeProxy;
-	bridgeProxyRef->m_childProxy = childProxy;
-	bridgeProxyRef->m_childBroadphase = childBroadphase;
-	parentMultiSapProxy->m_bridgeProxies.push_back(bridgeProxyRef);
-}
-
-
-bool boxIsContainedWithinBox(const btVector3& amin,const btVector3& amax,const btVector3& bmin,const btVector3& bmax);
-bool boxIsContainedWithinBox(const btVector3& amin,const btVector3& amax,const btVector3& bmin,const btVector3& bmax)
-{
-return
-amin.getX() >= bmin.getX() && amax.getX() <= bmax.getX() &&
-amin.getY() >= bmin.getY() && amax.getY() <= bmax.getY() &&
-amin.getZ() >= bmin.getZ() && amax.getZ() <= bmax.getZ();
-}
-
-
-
-
-
-
-void	btMultiSapBroadphase::getAabb(btBroadphaseProxy* proxy,btVector3& aabbMin, btVector3& aabbMax ) const
-{
-	btMultiSapProxy* multiProxy = static_cast<btMultiSapProxy*>(proxy);
-	aabbMin = multiProxy->m_aabbMin;
-	aabbMax = multiProxy->m_aabbMax;
-}
-
-void	btMultiSapBroadphase::rayTest(const btVector3& rayFrom,const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin,const btVector3& aabbMax)
-{
-	for (int i=0;i<m_multiSapProxies.size();i++)
-	{
-		rayCallback.process(m_multiSapProxies[i]);
-	}
-}
-
-
-//#include <stdio.h>
-
-void	btMultiSapBroadphase::setAabb(btBroadphaseProxy* proxy,const btVector3& aabbMin,const btVector3& aabbMax, btDispatcher* dispatcher)
-{
-	btMultiSapProxy* multiProxy = static_cast<btMultiSapProxy*>(proxy);
-	multiProxy->m_aabbMin = aabbMin;
-	multiProxy->m_aabbMax = aabbMax;
-	
-	
-//	bool fullyContained = false;
-//	bool alreadyInSimple = false;
-	
-
-
-	
-	struct MyNodeOverlapCallback : public btNodeOverlapCallback
-	{
-		btMultiSapBroadphase*	m_multiSap;
-		btMultiSapProxy*		m_multiProxy;
-		btDispatcher*			m_dispatcher;
-
-		MyNodeOverlapCallback(btMultiSapBroadphase* multiSap,btMultiSapProxy* multiProxy,btDispatcher* dispatcher)
-			:m_multiSap(multiSap),
-			m_multiProxy(multiProxy),
-			m_dispatcher(dispatcher)
-		{
-
-		}
-
-		virtual void processNode(int /*nodeSubPart*/, int broadphaseIndex)
-		{
-			btBroadphaseInterface* childBroadphase = m_multiSap->getBroadphaseArray()[broadphaseIndex];
-
-			int containingBroadphaseIndex = -1;
-			//already found?
-			for (int i=0;i<m_multiProxy->m_bridgeProxies.size();i++)
-			{
-
-				if (m_multiProxy->m_bridgeProxies[i]->m_childBroadphase == childBroadphase)
-				{
-					containingBroadphaseIndex = i;
-					break;
-				}
-			}
-			if (containingBroadphaseIndex<0)
-			{
-				//add it
-				btBroadphaseProxy* childProxy = childBroadphase->createProxy(m_multiProxy->m_aabbMin,m_multiProxy->m_aabbMax,m_multiProxy->m_shapeType,m_multiProxy->m_clientObject,m_multiProxy->m_collisionFilterGroup,m_multiProxy->m_collisionFilterMask, m_dispatcher,m_multiProxy);
-				m_multiSap->addToChildBroadphase(m_multiProxy,childProxy,childBroadphase);
-
-			}
-		}
-	};
-
-	MyNodeOverlapCallback	myNodeCallback(this,multiProxy,dispatcher);
-
-
-
-	
-	if (m_optimizedAabbTree)
-		m_optimizedAabbTree->reportAabbOverlappingNodex(&myNodeCallback,aabbMin,aabbMax);
-
-	int i;
-
-	for ( i=0;i<multiProxy->m_bridgeProxies.size();i++)
-	{
-		btVector3 worldAabbMin,worldAabbMax;
-		multiProxy->m_bridgeProxies[i]->m_childBroadphase->getBroadphaseAabb(worldAabbMin,worldAabbMax);
-		bool overlapsBroadphase = TestAabbAgainstAabb2(worldAabbMin,worldAabbMax,multiProxy->m_aabbMin,multiProxy->m_aabbMax);
-		if (!overlapsBroadphase)
-		{
-			//remove it now
-			btBridgeProxy* bridgeProxy = multiProxy->m_bridgeProxies[i];
-
-			btBroadphaseProxy* childProxy = bridgeProxy->m_childProxy;
-			bridgeProxy->m_childBroadphase->destroyProxy(childProxy,dispatcher);
-			
-			multiProxy->m_bridgeProxies.swap( i,multiProxy->m_bridgeProxies.size()-1);
-			multiProxy->m_bridgeProxies.pop_back();
-
-		}
-	}
-
-
-	/*
-
-	if (1)
-	{
-
-		//find broadphase that contain this multiProxy
-		int numChildBroadphases = getBroadphaseArray().size();
-		for (int i=0;i<numChildBroadphases;i++)
-		{
-			btBroadphaseInterface* childBroadphase = getBroadphaseArray()[i];
-			btVector3 worldAabbMin,worldAabbMax;
-			childBroadphase->getBroadphaseAabb(worldAabbMin,worldAabbMax);
-			bool overlapsBroadphase = TestAabbAgainstAabb2(worldAabbMin,worldAabbMax,multiProxy->m_aabbMin,multiProxy->m_aabbMax);
-			
-		//	fullyContained = fullyContained || boxIsContainedWithinBox(worldAabbMin,worldAabbMax,multiProxy->m_aabbMin,multiProxy->m_aabbMax);
-			int containingBroadphaseIndex = -1;
-			
-			//if already contains this
-			
-			for (int i=0;i<multiProxy->m_bridgeProxies.size();i++)
-			{
-				if (multiProxy->m_bridgeProxies[i]->m_childBroadphase == childBroadphase)
-				{
-					containingBroadphaseIndex = i;
-				}
-				alreadyInSimple = alreadyInSimple || (multiProxy->m_bridgeProxies[i]->m_childBroadphase == m_simpleBroadphase);
-			}
-
-			if (overlapsBroadphase)
-			{
-				if (containingBroadphaseIndex<0)
-				{
-					btBroadphaseProxy* childProxy = childBroadphase->createProxy(aabbMin,aabbMax,multiProxy->m_shapeType,multiProxy->m_clientObject,multiProxy->m_collisionFilterGroup,multiProxy->m_collisionFilterMask, dispatcher);
-					childProxy->m_multiSapParentProxy = multiProxy;
-					addToChildBroadphase(multiProxy,childProxy,childBroadphase);
-				}
-			} else
-			{
-				if (containingBroadphaseIndex>=0)
-				{
-					//remove
-					btBridgeProxy* bridgeProxy = multiProxy->m_bridgeProxies[containingBroadphaseIndex];
-
-					btBroadphaseProxy* childProxy = bridgeProxy->m_childProxy;
-					bridgeProxy->m_childBroadphase->destroyProxy(childProxy,dispatcher);
-					
-					multiProxy->m_bridgeProxies.swap( containingBroadphaseIndex,multiProxy->m_bridgeProxies.size()-1);
-					multiProxy->m_bridgeProxies.pop_back();
-				}
-			}
-		}
-
-
-		///If we are in no other child broadphase, stick the proxy in the global 'simple' broadphase (brute force)
-		///hopefully we don't end up with many entries here (can assert/provide feedback on stats)
-		if (0)//!multiProxy->m_bridgeProxies.size())
-		{
-			///we don't pass the userPtr but our multisap proxy. We need to patch this, before processing an actual collision
-			///this is needed to be able to calculate the aabb overlap
-			btBroadphaseProxy* childProxy = m_simpleBroadphase->createProxy(aabbMin,aabbMax,multiProxy->m_shapeType,multiProxy->m_clientObject,multiProxy->m_collisionFilterGroup,multiProxy->m_collisionFilterMask, dispatcher);
-			childProxy->m_multiSapParentProxy = multiProxy;
-			addToChildBroadphase(multiProxy,childProxy,m_simpleBroadphase);
-		}
-	}
-
-	if (!multiProxy->m_bridgeProxies.size())
-	{
-		///we don't pass the userPtr but our multisap proxy. We need to patch this, before processing an actual collision
-		///this is needed to be able to calculate the aabb overlap
-		btBroadphaseProxy* childProxy = m_simpleBroadphase->createProxy(aabbMin,aabbMax,multiProxy->m_shapeType,multiProxy->m_clientObject,multiProxy->m_collisionFilterGroup,multiProxy->m_collisionFilterMask, dispatcher);
-		childProxy->m_multiSapParentProxy = multiProxy;
-		addToChildBroadphase(multiProxy,childProxy,m_simpleBroadphase);
-	}
-*/
-
-
-	//update
-	for ( i=0;i<multiProxy->m_bridgeProxies.size();i++)
-	{
-		btBridgeProxy* bridgeProxyRef = multiProxy->m_bridgeProxies[i];
-		bridgeProxyRef->m_childBroadphase->setAabb(bridgeProxyRef->m_childProxy,aabbMin,aabbMax,dispatcher);
-	}
-
-}
-bool stopUpdating=false;
-
-
-
-class btMultiSapBroadphasePairSortPredicate
-{
-	public:
-
-		bool operator() ( const btBroadphasePair& a1, const btBroadphasePair& b1 ) const
-		{
-				btMultiSapBroadphase::btMultiSapProxy* aProxy0 = a1.m_pProxy0 ? (btMultiSapBroadphase::btMultiSapProxy*)a1.m_pProxy0->m_multiSapParentProxy : 0;
-				btMultiSapBroadphase::btMultiSapProxy* aProxy1 = a1.m_pProxy1 ? (btMultiSapBroadphase::btMultiSapProxy*)a1.m_pProxy1->m_multiSapParentProxy : 0;
-				btMultiSapBroadphase::btMultiSapProxy* bProxy0 = b1.m_pProxy0 ? (btMultiSapBroadphase::btMultiSapProxy*)b1.m_pProxy0->m_multiSapParentProxy : 0;
-				btMultiSapBroadphase::btMultiSapProxy* bProxy1 = b1.m_pProxy1 ? (btMultiSapBroadphase::btMultiSapProxy*)b1.m_pProxy1->m_multiSapParentProxy : 0;
-
-				 return aProxy0 > bProxy0 || 
-					(aProxy0 == bProxy0 && aProxy1 > bProxy1) ||
-					(aProxy0 == bProxy0 && aProxy1 == bProxy1 && a1.m_algorithm > b1.m_algorithm); 
-		}
-};
-
-
-        ///calculateOverlappingPairs is optional: incremental algorithms (sweep and prune) might do it during the set aabb
-void    btMultiSapBroadphase::calculateOverlappingPairs(btDispatcher* dispatcher)
-{
-
-//	m_simpleBroadphase->calculateOverlappingPairs(dispatcher);
-
-	if (!stopUpdating && getOverlappingPairCache()->hasDeferredRemoval())
-	{
-	
-		btBroadphasePairArray&	overlappingPairArray = getOverlappingPairCache()->getOverlappingPairArray();
-
-	//	quicksort(overlappingPairArray,0,overlappingPairArray.size());
-
-		overlappingPairArray.quickSort(btMultiSapBroadphasePairSortPredicate());
-
-		//perform a sort, to find duplicates and to sort 'invalid' pairs to the end
-	//	overlappingPairArray.heapSort(btMultiSapBroadphasePairSortPredicate());
-
-		overlappingPairArray.resize(overlappingPairArray.size() - m_invalidPair);
-		m_invalidPair = 0;
-
-		
-		int i;
-
-		btBroadphasePair previousPair;
-		previousPair.m_pProxy0 = 0;
-		previousPair.m_pProxy1 = 0;
-		previousPair.m_algorithm = 0;
-		
-		
-		for (i=0;i<overlappingPairArray.size();i++)
-		{
-		
-			btBroadphasePair& pair = overlappingPairArray[i];
-
-			btMultiSapProxy* aProxy0 = pair.m_pProxy0 ? (btMultiSapProxy*)pair.m_pProxy0->m_multiSapParentProxy : 0;
-			btMultiSapProxy* aProxy1 = pair.m_pProxy1 ? (btMultiSapProxy*)pair.m_pProxy1->m_multiSapParentProxy : 0;
-			btMultiSapProxy* bProxy0 = previousPair.m_pProxy0 ? (btMultiSapProxy*)previousPair.m_pProxy0->m_multiSapParentProxy : 0;
-			btMultiSapProxy* bProxy1 = previousPair.m_pProxy1 ? (btMultiSapProxy*)previousPair.m_pProxy1->m_multiSapParentProxy : 0;
-
-			bool isDuplicate = (aProxy0 == bProxy0) && (aProxy1 == bProxy1);
-			
-			previousPair = pair;
-
-			bool needsRemoval = false;
-
-			if (!isDuplicate)
-			{
-				bool hasOverlap = testAabbOverlap(pair.m_pProxy0,pair.m_pProxy1);
-
-				if (hasOverlap)
-				{
-					needsRemoval = false;//callback->processOverlap(pair);
-				} else
-				{
-					needsRemoval = true;
-				}
-			} else
-			{
-				//remove duplicate
-				needsRemoval = true;
-				//should have no algorithm
-				btAssert(!pair.m_algorithm);
-			}
-			
-			if (needsRemoval)
-			{
-				getOverlappingPairCache()->cleanOverlappingPair(pair,dispatcher);
-
-		//		m_overlappingPairArray.swap(i,m_overlappingPairArray.size()-1);
-		//		m_overlappingPairArray.pop_back();
-				pair.m_pProxy0 = 0;
-				pair.m_pProxy1 = 0;
-				m_invalidPair++;
-				gOverlappingPairs--;
-			} 
-			
-		}
-
-	///if you don't like to skip the invalid pairs in the array, execute following code:
-	#define CLEAN_INVALID_PAIRS 1
-	#ifdef CLEAN_INVALID_PAIRS
-
-		//perform a sort, to sort 'invalid' pairs to the end
-		//overlappingPairArray.heapSort(btMultiSapBroadphasePairSortPredicate());
-		overlappingPairArray.quickSort(btMultiSapBroadphasePairSortPredicate());
-
-		overlappingPairArray.resize(overlappingPairArray.size() - m_invalidPair);
-		m_invalidPair = 0;
-	#endif//CLEAN_INVALID_PAIRS
-		
-		//printf("overlappingPairArray.size()=%d\n",overlappingPairArray.size());
-	}
-
-
-}
-
-
-bool	btMultiSapBroadphase::testAabbOverlap(btBroadphaseProxy* childProxy0,btBroadphaseProxy* childProxy1)
-{
-	btMultiSapProxy* multiSapProxy0 = (btMultiSapProxy*)childProxy0->m_multiSapParentProxy;
-		btMultiSapProxy* multiSapProxy1 = (btMultiSapProxy*)childProxy1->m_multiSapParentProxy;
-
-		return	TestAabbAgainstAabb2(multiSapProxy0->m_aabbMin,multiSapProxy0->m_aabbMax,
-			multiSapProxy1->m_aabbMin,multiSapProxy1->m_aabbMax);
-		
-}
-
-
-void	btMultiSapBroadphase::printStats()
-{
-/*	printf("---------------------------------\n");
-	
-		printf("btMultiSapBroadphase.h\n");
-		printf("numHandles = %d\n",m_multiSapProxies.size());
-			//find broadphase that contain this multiProxy
-		int numChildBroadphases = getBroadphaseArray().size();
-		for (int i=0;i<numChildBroadphases;i++)
-		{
-
-			btBroadphaseInterface* childBroadphase = getBroadphaseArray()[i];
-			childBroadphase->printStats();
-
-		}
-		*/
-
-}
-
-void btMultiSapBroadphase::resetPool(btDispatcher* dispatcher)
-{
-	// not yet
-}

libs/bullet-2.82-r2704/src/BulletCollision/BroadphaseCollision/btMultiSapBroadphase.h

@@ -1,151 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-#ifndef BT_MULTI_SAP_BROADPHASE
-#define BT_MULTI_SAP_BROADPHASE
-
-#include "btBroadphaseInterface.h"
-#include "LinearMath/btAlignedObjectArray.h"
-#include "btOverlappingPairCache.h"
-
-
-class btBroadphaseInterface;
-class btSimpleBroadphase;
-
-
-typedef btAlignedObjectArray<btBroadphaseInterface*> btSapBroadphaseArray;
-
-///The btMultiSapBroadphase is a research project, not recommended to use in production. Use btAxisSweep3 or btDbvtBroadphase instead.
-///The btMultiSapBroadphase is a broadphase that contains multiple SAP broadphases.
-///The user can add SAP broadphases that cover the world. A btBroadphaseProxy can be in multiple child broadphases at the same time.
-///A btQuantizedBvh acceleration structures finds overlapping SAPs for each btBroadphaseProxy.
-///See http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=328
-///and http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1329
-class btMultiSapBroadphase :public btBroadphaseInterface
-{
-	btSapBroadphaseArray	m_sapBroadphases;
-	
-	btSimpleBroadphase*		m_simpleBroadphase;
-
-	btOverlappingPairCache*	m_overlappingPairs;
-
-	class btQuantizedBvh*			m_optimizedAabbTree;
-
-
-	bool					m_ownsPairCache;
-	
-	btOverlapFilterCallback*	m_filterCallback;
-
-	int			m_invalidPair;
-
-	struct	btBridgeProxy
-	{
-		btBroadphaseProxy*		m_childProxy;
-		btBroadphaseInterface*	m_childBroadphase;
-	};
-
-
-public:
-
-	struct	btMultiSapProxy	: public btBroadphaseProxy
-	{
-
-		///array with all the entries that this proxy belongs to
-		btAlignedObjectArray<btBridgeProxy*> m_bridgeProxies;
-		btVector3	m_aabbMin;
-		btVector3	m_aabbMax;
-
-		int	m_shapeType;
-
-/*		void*	m_userPtr;
-		short int	m_collisionFilterGroup;
-		short int	m_collisionFilterMask;
-*/
-		btMultiSapProxy(const btVector3& aabbMin,  const btVector3& aabbMax,int shapeType,void* userPtr, short int collisionFilterGroup,short int collisionFilterMask)
-			:btBroadphaseProxy(aabbMin,aabbMax,userPtr,collisionFilterGroup,collisionFilterMask),
-			m_aabbMin(aabbMin),
-			m_aabbMax(aabbMax),
-			m_shapeType(shapeType)
-		{
-			m_multiSapParentProxy =this;
-		}
-
-		
-	};
-
-protected:
-
-
-	btAlignedObjectArray<btMultiSapProxy*> m_multiSapProxies;
-
-public:
-
-	btMultiSapBroadphase(int maxProxies = 16384,btOverlappingPairCache* pairCache=0);
-
-
-	btSapBroadphaseArray&	getBroadphaseArray()
-	{
-		return m_sapBroadphases;
-	}
-
-	const btSapBroadphaseArray&	getBroadphaseArray() const
-	{
-		return m_sapBroadphases;
-	}
-
-	virtual ~btMultiSapBroadphase();
-
-	virtual btBroadphaseProxy*	createProxy(  const btVector3& aabbMin,  const btVector3& aabbMax,int shapeType,void* userPtr, short int collisionFilterGroup,short int collisionFilterMask, btDispatcher* dispatcher,void* multiSapProxy);
-	virtual void	destroyProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher);
-	virtual void	setAabb(btBroadphaseProxy* proxy,const btVector3& aabbMin,const btVector3& aabbMax, btDispatcher* dispatcher);
-	virtual void	getAabb(btBroadphaseProxy* proxy,btVector3& aabbMin, btVector3& aabbMax ) const;
-
-	virtual void	rayTest(const btVector3& rayFrom,const btVector3& rayTo, btBroadphaseRayCallback& rayCallback,const btVector3& aabbMin=btVector3(0,0,0),const btVector3& aabbMax=btVector3(0,0,0));
-
-	void	addToChildBroadphase(btMultiSapProxy* parentMultiSapProxy, btBroadphaseProxy* childProxy, btBroadphaseInterface*	childBroadphase);
-
-	///calculateOverlappingPairs is optional: incremental algorithms (sweep and prune) might do it during the set aabb
-	virtual void	calculateOverlappingPairs(btDispatcher* dispatcher);
-
-	bool	testAabbOverlap(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
-
-	virtual	btOverlappingPairCache*	getOverlappingPairCache()
-	{
-		return m_overlappingPairs;
-	}
-	virtual	const btOverlappingPairCache*	getOverlappingPairCache() const
-	{
-		return m_overlappingPairs;
-	}
-
-	///getAabb returns the axis aligned bounding box in the 'global' coordinate frame
-	///will add some transform later
-	virtual void getBroadphaseAabb(btVector3& aabbMin,btVector3& aabbMax) const
-	{
-		aabbMin.setValue(-BT_LARGE_FLOAT,-BT_LARGE_FLOAT,-BT_LARGE_FLOAT);
-		aabbMax.setValue(BT_LARGE_FLOAT,BT_LARGE_FLOAT,BT_LARGE_FLOAT);
-	}
-
-	void	buildTree(const btVector3& bvhAabbMin,const btVector3& bvhAabbMax);
-
-	virtual void	printStats();
-
-	void quicksort (btBroadphasePairArray& a, int lo, int hi);
-
-	///reset broadphase internal structures, to ensure determinism/reproducability
-	virtual void resetPool(btDispatcher* dispatcher);
-
-};
-
-#endif //BT_MULTI_SAP_BROADPHASE

libs/bullet-2.82-r2704/src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.cpp

@@ -1,633 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-
-
-#include "btOverlappingPairCache.h"
-
-#include "btDispatcher.h"
-#include "btCollisionAlgorithm.h"
-#include "LinearMath/btAabbUtil2.h"
-
-#include <stdio.h>
-
-int	gOverlappingPairs = 0;
-
-int gRemovePairs =0;
-int gAddedPairs =0;
-int gFindPairs =0;
-
-
-
-
-btHashedOverlappingPairCache::btHashedOverlappingPairCache():
-	m_overlapFilterCallback(0),
-	m_blockedForChanges(false),
-	m_ghostPairCallback(0)
-{
-	int initialAllocatedSize= 2;
-	m_overlappingPairArray.reserve(initialAllocatedSize);
-	growTables();
-}
-
-
-
-
-btHashedOverlappingPairCache::~btHashedOverlappingPairCache()
-{
-}
-
-
-
-void	btHashedOverlappingPairCache::cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher)
-{
-	if (pair.m_algorithm && dispatcher)
-	{
-		{
-			pair.m_algorithm->~btCollisionAlgorithm();
-			dispatcher->freeCollisionAlgorithm(pair.m_algorithm);
-			pair.m_algorithm=0;
-		}
-	}
-}
-
-
-
-
-void	btHashedOverlappingPairCache::cleanProxyFromPairs(btBroadphaseProxy* proxy,btDispatcher* dispatcher)
-{
-
-	class	CleanPairCallback : public btOverlapCallback
-	{
-		btBroadphaseProxy* m_cleanProxy;
-		btOverlappingPairCache*	m_pairCache;
-		btDispatcher* m_dispatcher;
-
-	public:
-		CleanPairCallback(btBroadphaseProxy* cleanProxy,btOverlappingPairCache* pairCache,btDispatcher* dispatcher)
-			:m_cleanProxy(cleanProxy),
-			m_pairCache(pairCache),
-			m_dispatcher(dispatcher)
-		{
-		}
-		virtual	bool	processOverlap(btBroadphasePair& pair)
-		{
-			if ((pair.m_pProxy0 == m_cleanProxy) ||
-				(pair.m_pProxy1 == m_cleanProxy))
-			{
-				m_pairCache->cleanOverlappingPair(pair,m_dispatcher);
-			}
-			return false;
-		}
-		
-	};
-
-	CleanPairCallback cleanPairs(proxy,this,dispatcher);
-
-	processAllOverlappingPairs(&cleanPairs,dispatcher);
-
-}
-
-
-
-
-void	btHashedOverlappingPairCache::removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher)
-{
-
-	class	RemovePairCallback : public btOverlapCallback
-	{
-		btBroadphaseProxy* m_obsoleteProxy;
-
-	public:
-		RemovePairCallback(btBroadphaseProxy* obsoleteProxy)
-			:m_obsoleteProxy(obsoleteProxy)
-		{
-		}
-		virtual	bool	processOverlap(btBroadphasePair& pair)
-		{
-			return ((pair.m_pProxy0 == m_obsoleteProxy) ||
-				(pair.m_pProxy1 == m_obsoleteProxy));
-		}
-		
-	};
-
-
-	RemovePairCallback removeCallback(proxy);
-
-	processAllOverlappingPairs(&removeCallback,dispatcher);
-}
-
-
-
-
-
-btBroadphasePair* btHashedOverlappingPairCache::findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
-{
-	gFindPairs++;
-	if(proxy0->m_uniqueId>proxy1->m_uniqueId) 
-		btSwap(proxy0,proxy1);
-	int proxyId1 = proxy0->getUid();
-	int proxyId2 = proxy1->getUid();
-
-	/*if (proxyId1 > proxyId2) 
-		btSwap(proxyId1, proxyId2);*/
-
-	int hash = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1), static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity()-1));
-
-	if (hash >= m_hashTable.size())
-	{
-		return NULL;
-	}
-
-	int index = m_hashTable[hash];
-	while (index != BT_NULL_PAIR && equalsPair(m_overlappingPairArray[index], proxyId1, proxyId2) == false)
-	{
-		index = m_next[index];
-	}
-
-	if (index == BT_NULL_PAIR)
-	{
-		return NULL;
-	}
-
-	btAssert(index < m_overlappingPairArray.size());
-
-	return &m_overlappingPairArray[index];
-}
-
-//#include <stdio.h>
-
-void	btHashedOverlappingPairCache::growTables()
-{
-
-	int newCapacity = m_overlappingPairArray.capacity();
-
-	if (m_hashTable.size() < newCapacity)
-	{
-		//grow hashtable and next table
-		int curHashtableSize = m_hashTable.size();
-
-		m_hashTable.resize(newCapacity);
-		m_next.resize(newCapacity);
-
-
-		int i;
-
-		for (i= 0; i < newCapacity; ++i)
-		{
-			m_hashTable[i] = BT_NULL_PAIR;
-		}
-		for (i = 0; i < newCapacity; ++i)
-		{
-			m_next[i] = BT_NULL_PAIR;
-		}
-
-		for(i=0;i<curHashtableSize;i++)
-		{
-	
-			const btBroadphasePair& pair = m_overlappingPairArray[i];
-			int proxyId1 = pair.m_pProxy0->getUid();
-			int proxyId2 = pair.m_pProxy1->getUid();
-			/*if (proxyId1 > proxyId2) 
-				btSwap(proxyId1, proxyId2);*/
-			int	hashValue = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1),static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity()-1));	// New hash value with new mask
-			m_next[i] = m_hashTable[hashValue];
-			m_hashTable[hashValue] = i;
-		}
-
-
-	}
-}
-
-btBroadphasePair* btHashedOverlappingPairCache::internalAddPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1)
-{
-	if(proxy0->m_uniqueId>proxy1->m_uniqueId) 
-		btSwap(proxy0,proxy1);
-	int proxyId1 = proxy0->getUid();
-	int proxyId2 = proxy1->getUid();
-
-	/*if (proxyId1 > proxyId2) 
-		btSwap(proxyId1, proxyId2);*/
-
-	int	hash = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1),static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity()-1));	// New hash value with new mask
-
-
-	btBroadphasePair* pair = internalFindPair(proxy0, proxy1, hash);
-	if (pair != NULL)
-	{
-		return pair;
-	}
-	/*for(int i=0;i<m_overlappingPairArray.size();++i)
-		{
-		if(	(m_overlappingPairArray[i].m_pProxy0==proxy0)&&
-			(m_overlappingPairArray[i].m_pProxy1==proxy1))
-			{
-			printf("Adding duplicated %u<>%u\r\n",proxyId1,proxyId2);
-			internalFindPair(proxy0, proxy1, hash);
-			}
-		}*/
-	int count = m_overlappingPairArray.size();
-	int oldCapacity = m_overlappingPairArray.capacity();
-	void* mem = &m_overlappingPairArray.expandNonInitializing();
-
-	//this is where we add an actual pair, so also call the 'ghost'
-	if (m_ghostPairCallback)
-		m_ghostPairCallback->addOverlappingPair(proxy0,proxy1);
-
-	int newCapacity = m_overlappingPairArray.capacity();
-
-	if (oldCapacity < newCapacity)
-	{
-		growTables();
-		//hash with new capacity
-		hash = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1),static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity()-1));
-	}
-	
-	pair = new (mem) btBroadphasePair(*proxy0,*proxy1);
-//	pair->m_pProxy0 = proxy0;
-//	pair->m_pProxy1 = proxy1;
-	pair->m_algorithm = 0;
-	pair->m_internalTmpValue = 0;
-	
-
-	m_next[count] = m_hashTable[hash];
-	m_hashTable[hash] = count;
-
-	return pair;
-}
-
-
-
-void* btHashedOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1,btDispatcher* dispatcher)
-{
-	gRemovePairs++;
-	if(proxy0->m_uniqueId>proxy1->m_uniqueId) 
-		btSwap(proxy0,proxy1);
-	int proxyId1 = proxy0->getUid();
-	int proxyId2 = proxy1->getUid();
-
-	/*if (proxyId1 > proxyId2) 
-		btSwap(proxyId1, proxyId2);*/
-
-	int	hash = static_cast<int>(getHash(static_cast<unsigned int>(proxyId1),static_cast<unsigned int>(proxyId2)) & (m_overlappingPairArray.capacity()-1));
-
-	btBroadphasePair* pair = internalFindPair(proxy0, proxy1, hash);
-	if (pair == NULL)
-	{
-		return 0;
-	}
-
-	cleanOverlappingPair(*pair,dispatcher);
-
-	void* userData = pair->m_internalInfo1;
-
-	btAssert(pair->m_pProxy0->getUid() == proxyId1);
-	btAssert(pair->m_pProxy1->getUid() == proxyId2);
-
-	int pairIndex = int(pair - &m_overlappingPairArray[0]);
-	btAssert(pairIndex < m_overlappingPairArray.size());
-
-	// Remove the pair from the hash table.
-	int index = m_hashTable[hash];
-	btAssert(index != BT_NULL_PAIR);
-
-	int previous = BT_NULL_PAIR;
-	while (index != pairIndex)
-	{
-		previous = index;
-		index = m_next[index];
-	}
-
-	if (previous != BT_NULL_PAIR)
-	{
-		btAssert(m_next[previous] == pairIndex);
-		m_next[previous] = m_next[pairIndex];
-	}
-	else
-	{
-		m_hashTable[hash] = m_next[pairIndex];
-	}
-
-	// We now move the last pair into spot of the
-	// pair being removed. We need to fix the hash
-	// table indices to support the move.
-
-	int lastPairIndex = m_overlappingPairArray.size() - 1;
-
-	if (m_ghostPairCallback)
-		m_ghostPairCallback->removeOverlappingPair(proxy0, proxy1,dispatcher);
-
-	// If the removed pair is the last pair, we are done.
-	if (lastPairIndex == pairIndex)
-	{
-		m_overlappingPairArray.pop_back();
-		return userData;
-	}
-
-	// Remove the last pair from the hash table.
-	const btBroadphasePair* last = &m_overlappingPairArray[lastPairIndex];
-		/* missing swap here too, Nat. */ 
-	int lastHash = static_cast<int>(getHash(static_cast<unsigned int>(last->m_pProxy0->getUid()), static_cast<unsigned int>(last->m_pProxy1->getUid())) & (m_overlappingPairArray.capacity()-1));
-
-	index = m_hashTable[lastHash];
-	btAssert(index != BT_NULL_PAIR);
-
-	previous = BT_NULL_PAIR;
-	while (index != lastPairIndex)
-	{
-		previous = index;
-		index = m_next[index];
-	}
-
-	if (previous != BT_NULL_PAIR)
-	{
-		btAssert(m_next[previous] == lastPairIndex);
-		m_next[previous] = m_next[lastPairIndex];
-	}
-	else
-	{
-		m_hashTable[lastHash] = m_next[lastPairIndex];
-	}
-
-	// Copy the last pair into the remove pair's spot.
-	m_overlappingPairArray[pairIndex] = m_overlappingPairArray[lastPairIndex];
-
-	// Insert the last pair into the hash table
-	m_next[pairIndex] = m_hashTable[lastHash];
-	m_hashTable[lastHash] = pairIndex;
-
-	m_overlappingPairArray.pop_back();
-
-	return userData;
-}
-//#include <stdio.h>
-
-void	btHashedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback,btDispatcher* dispatcher)
-{
-
-	int i;
-
-//	printf("m_overlappingPairArray.size()=%d\n",m_overlappingPairArray.size());
-	for (i=0;i<m_overlappingPairArray.size();)
-	{
-	
-		btBroadphasePair* pair = &m_overlappingPairArray[i];
-		if (callback->processOverlap(*pair))
-		{
-			removeOverlappingPair(pair->m_pProxy0,pair->m_pProxy1,dispatcher);
-
-			gOverlappingPairs--;
-		} else
-		{
-			i++;
-		}
-	}
-}
-
-void	btHashedOverlappingPairCache::sortOverlappingPairs(btDispatcher* dispatcher)
-{
-	///need to keep hashmap in sync with pair address, so rebuild all
-	btBroadphasePairArray tmpPairs;
-	int i;
-	for (i=0;i<m_overlappingPairArray.size();i++)
-	{
-		tmpPairs.push_back(m_overlappingPairArray[i]);
-	}
-
-	for (i=0;i<tmpPairs.size();i++)
-	{
-		removeOverlappingPair(tmpPairs[i].m_pProxy0,tmpPairs[i].m_pProxy1,dispatcher);
-	}
-	
-	for (i = 0; i < m_next.size(); i++)
-	{
-		m_next[i] = BT_NULL_PAIR;
-	}
-
-	tmpPairs.quickSort(btBroadphasePairSortPredicate());
-
-	for (i=0;i<tmpPairs.size();i++)
-	{
-		addOverlappingPair(tmpPairs[i].m_pProxy0,tmpPairs[i].m_pProxy1);
-	}
-
-	
-}
-
-
-void*	btSortedOverlappingPairCache::removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1, btDispatcher* dispatcher )
-{
-	if (!hasDeferredRemoval())
-	{
-		btBroadphasePair findPair(*proxy0,*proxy1);
-
-		int findIndex = m_overlappingPairArray.findLinearSearch(findPair);
-		if (findIndex < m_overlappingPairArray.size())
-		{
-			gOverlappingPairs--;
-			btBroadphasePair& pair = m_overlappingPairArray[findIndex];
-			void* userData = pair.m_internalInfo1;
-			cleanOverlappingPair(pair,dispatcher);
-			if (m_ghostPairCallback)
-				m_ghostPairCallback->removeOverlappingPair(proxy0, proxy1,dispatcher);
-			
-			m_overlappingPairArray.swap(findIndex,m_overlappingPairArray.capacity()-1);
-			m_overlappingPairArray.pop_back();
-			return userData;
-		}
-	}
-
-	return 0;
-}
-
-
-
-
-
-
-
-
-btBroadphasePair*	btSortedOverlappingPairCache::addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
-{
-	//don't add overlap with own
-	btAssert(proxy0 != proxy1);
-
-	if (!needsBroadphaseCollision(proxy0,proxy1))
-		return 0;
-	
-	void* mem = &m_overlappingPairArray.expandNonInitializing();
-	btBroadphasePair* pair = new (mem) btBroadphasePair(*proxy0,*proxy1);
-	
-	gOverlappingPairs++;
-	gAddedPairs++;
-	
-	if (m_ghostPairCallback)
-		m_ghostPairCallback->addOverlappingPair(proxy0, proxy1);
-	return pair;
-	
-}
-
-///this findPair becomes really slow. Either sort the list to speedup the query, or
-///use a different solution. It is mainly used for Removing overlapping pairs. Removal could be delayed.
-///we could keep a linked list in each proxy, and store pair in one of the proxies (with lowest memory address)
-///Also we can use a 2D bitmap, which can be useful for a future GPU implementation
- btBroadphasePair*	btSortedOverlappingPairCache::findPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
-{
-	if (!needsBroadphaseCollision(proxy0,proxy1))
-		return 0;
-
-	btBroadphasePair tmpPair(*proxy0,*proxy1);
-	int findIndex = m_overlappingPairArray.findLinearSearch(tmpPair);
-
-	if (findIndex < m_overlappingPairArray.size())
-	{
-		//btAssert(it != m_overlappingPairSet.end());
-		 btBroadphasePair* pair = &m_overlappingPairArray[findIndex];
-		return pair;
-	}
-	return 0;
-}
-
-
-
-
-
-
-
-
-
-
-//#include <stdio.h>
-
-void	btSortedOverlappingPairCache::processAllOverlappingPairs(btOverlapCallback* callback,btDispatcher* dispatcher)
-{
-
-	int i;
-
-	for (i=0;i<m_overlappingPairArray.size();)
-	{
-	
-		btBroadphasePair* pair = &m_overlappingPairArray[i];
-		if (callback->processOverlap(*pair))
-		{
-			cleanOverlappingPair(*pair,dispatcher);
-			pair->m_pProxy0 = 0;
-			pair->m_pProxy1 = 0;
-			m_overlappingPairArray.swap(i,m_overlappingPairArray.size()-1);
-			m_overlappingPairArray.pop_back();
-			gOverlappingPairs--;
-		} else
-		{
-			i++;
-		}
-	}
-}
-
-
-
-
-btSortedOverlappingPairCache::btSortedOverlappingPairCache():
-	m_blockedForChanges(false),
-	m_hasDeferredRemoval(true),
-	m_overlapFilterCallback(0),
-	m_ghostPairCallback(0)
-{
-	int initialAllocatedSize= 2;
-	m_overlappingPairArray.reserve(initialAllocatedSize);
-}
-
-btSortedOverlappingPairCache::~btSortedOverlappingPairCache()
-{
-}
-
-void	btSortedOverlappingPairCache::cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher)
-{
-	if (pair.m_algorithm)
-	{
-		{
-			pair.m_algorithm->~btCollisionAlgorithm();
-			dispatcher->freeCollisionAlgorithm(pair.m_algorithm);
-			pair.m_algorithm=0;
-			gRemovePairs--;
-		}
-	}
-}
-
-
-void	btSortedOverlappingPairCache::cleanProxyFromPairs(btBroadphaseProxy* proxy,btDispatcher* dispatcher)
-{
-
-	class	CleanPairCallback : public btOverlapCallback
-	{
-		btBroadphaseProxy* m_cleanProxy;
-		btOverlappingPairCache*	m_pairCache;
-		btDispatcher* m_dispatcher;
-
-	public:
-		CleanPairCallback(btBroadphaseProxy* cleanProxy,btOverlappingPairCache* pairCache,btDispatcher* dispatcher)
-			:m_cleanProxy(cleanProxy),
-			m_pairCache(pairCache),
-			m_dispatcher(dispatcher)
-		{
-		}
-		virtual	bool	processOverlap(btBroadphasePair& pair)
-		{
-			if ((pair.m_pProxy0 == m_cleanProxy) ||
-				(pair.m_pProxy1 == m_cleanProxy))
-			{
-				m_pairCache->cleanOverlappingPair(pair,m_dispatcher);
-			}
-			return false;
-		}
-		
-	};
-
-	CleanPairCallback cleanPairs(proxy,this,dispatcher);
-
-	processAllOverlappingPairs(&cleanPairs,dispatcher);
-
-}
-
-
-void	btSortedOverlappingPairCache::removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher)
-{
-
-	class	RemovePairCallback : public btOverlapCallback
-	{
-		btBroadphaseProxy* m_obsoleteProxy;
-
-	public:
-		RemovePairCallback(btBroadphaseProxy* obsoleteProxy)
-			:m_obsoleteProxy(obsoleteProxy)
-		{
-		}
-		virtual	bool	processOverlap(btBroadphasePair& pair)
-		{
-			return ((pair.m_pProxy0 == m_obsoleteProxy) ||
-				(pair.m_pProxy1 == m_obsoleteProxy));
-		}
-		
-	};
-
-	RemovePairCallback removeCallback(proxy);
-
-	processAllOverlappingPairs(&removeCallback,dispatcher);
-}
-
-void	btSortedOverlappingPairCache::sortOverlappingPairs(btDispatcher* dispatcher)
-{
-	//should already be sorted
-}
-

libs/bullet-2.82-r2704/src/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h

@@ -1,470 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef BT_OVERLAPPING_PAIR_CACHE_H
-#define BT_OVERLAPPING_PAIR_CACHE_H
-
-
-#include "btBroadphaseInterface.h"
-#include "btBroadphaseProxy.h"
-#include "btOverlappingPairCallback.h"
-
-#include "LinearMath/btAlignedObjectArray.h"
-class btDispatcher;
-
-typedef btAlignedObjectArray<btBroadphasePair>	btBroadphasePairArray;
-
-struct	btOverlapCallback
-{
-	virtual ~btOverlapCallback()
-	{}
-	//return true for deletion of the pair
-	virtual bool	processOverlap(btBroadphasePair& pair) = 0;
-
-};
-
-struct btOverlapFilterCallback
-{
-	virtual ~btOverlapFilterCallback()
-	{}
-	// return true when pairs need collision
-	virtual bool	needBroadphaseCollision(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) const = 0;
-};
-
-
-
-
-
-
-
-extern int gRemovePairs;
-extern int gAddedPairs;
-extern int gFindPairs;
-
-const int BT_NULL_PAIR=0xffffffff;
-
-///The btOverlappingPairCache provides an interface for overlapping pair management (add, remove, storage), used by the btBroadphaseInterface broadphases.
-///The btHashedOverlappingPairCache and btSortedOverlappingPairCache classes are two implementations.
-class btOverlappingPairCache : public btOverlappingPairCallback
-{
-public:
-	virtual ~btOverlappingPairCache() {} // this is needed so we can get to the derived class destructor
-
-	virtual btBroadphasePair*	getOverlappingPairArrayPtr() = 0;
-	
-	virtual const btBroadphasePair*	getOverlappingPairArrayPtr() const = 0;
-
-	virtual btBroadphasePairArray&	getOverlappingPairArray() = 0;
-
-	virtual	void	cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher) = 0;
-
-	virtual int getNumOverlappingPairs() const = 0;
-
-	virtual void	cleanProxyFromPairs(btBroadphaseProxy* proxy,btDispatcher* dispatcher) = 0;
-
-	virtual	void setOverlapFilterCallback(btOverlapFilterCallback* callback) = 0;
-
-	virtual void	processAllOverlappingPairs(btOverlapCallback*,btDispatcher* dispatcher) = 0;
-
-	virtual btBroadphasePair* findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1) = 0;
-
-	virtual bool	hasDeferredRemoval() = 0;
-
-	virtual	void	setInternalGhostPairCallback(btOverlappingPairCallback* ghostPairCallback)=0;
-
-	virtual void	sortOverlappingPairs(btDispatcher* dispatcher) = 0;
-
-
-};
-
-/// Hash-space based Pair Cache, thanks to Erin Catto, Box2D, http://www.box2d.org, and Pierre Terdiman, Codercorner, http://codercorner.com
-class btHashedOverlappingPairCache : public btOverlappingPairCache
-{
-	btBroadphasePairArray	m_overlappingPairArray;
-	btOverlapFilterCallback* m_overlapFilterCallback;
-	bool		m_blockedForChanges;
-
-protected:
-	
-	btAlignedObjectArray<int>	m_hashTable;
-	btAlignedObjectArray<int>	m_next;
-	btOverlappingPairCallback*	m_ghostPairCallback;
-
-
-public:
-	btHashedOverlappingPairCache();
-	virtual ~btHashedOverlappingPairCache();
-
-	
-	void	removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher);
-
-	virtual void*	removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,btDispatcher* dispatcher);
-	
-	SIMD_FORCE_INLINE bool needsBroadphaseCollision(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) const
-	{
-		if (m_overlapFilterCallback)
-			return m_overlapFilterCallback->needBroadphaseCollision(proxy0,proxy1);
-
-		bool collides = (proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0;
-		collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
-		
-		return collides;
-	}
-
-	// Add a pair and return the new pair. If the pair already exists,
-	// no new pair is created and the old one is returned.
-	virtual btBroadphasePair* 	addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
-	{
-		gAddedPairs++;
-
-		if (!needsBroadphaseCollision(proxy0,proxy1))
-			return 0;
-
-		return internalAddPair(proxy0,proxy1);
-	}
-
-	
-
-	void	cleanProxyFromPairs(btBroadphaseProxy* proxy,btDispatcher* dispatcher);
-
-	
-	virtual void	processAllOverlappingPairs(btOverlapCallback*,btDispatcher* dispatcher);
-
-	virtual btBroadphasePair*	getOverlappingPairArrayPtr()
-	{
-		return &m_overlappingPairArray[0];
-	}
-
-	const btBroadphasePair*	getOverlappingPairArrayPtr() const
-	{
-		return &m_overlappingPairArray[0];
-	}
-
-	btBroadphasePairArray&	getOverlappingPairArray()
-	{
-		return m_overlappingPairArray;
-	}
-
-	const btBroadphasePairArray&	getOverlappingPairArray() const
-	{
-		return m_overlappingPairArray;
-	}
-
-	void	cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher);
-
-
-
-	btBroadphasePair* findPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1);
-
-	int GetCount() const { return m_overlappingPairArray.size(); }
-//	btBroadphasePair* GetPairs() { return m_pairs; }
-
-	btOverlapFilterCallback* getOverlapFilterCallback()
-	{
-		return m_overlapFilterCallback;
-	}
-
-	void setOverlapFilterCallback(btOverlapFilterCallback* callback)
-	{
-		m_overlapFilterCallback = callback;
-	}
-
-	int	getNumOverlappingPairs() const
-	{
-		return m_overlappingPairArray.size();
-	}
-private:
-	
-	btBroadphasePair* 	internalAddPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
-
-	void	growTables();
-
-	SIMD_FORCE_INLINE bool equalsPair(const btBroadphasePair& pair, int proxyId1, int proxyId2)
-	{	
-		return pair.m_pProxy0->getUid() == proxyId1 && pair.m_pProxy1->getUid() == proxyId2;
-	}
-
-	/*
-	// Thomas Wang's hash, see: http://www.concentric.net/~Ttwang/tech/inthash.htm
-	// This assumes proxyId1 and proxyId2 are 16-bit.
-	SIMD_FORCE_INLINE int getHash(int proxyId1, int proxyId2)
-	{
-		int key = (proxyId2 << 16) | proxyId1;
-		key = ~key + (key << 15);
-		key = key ^ (key >> 12);
-		key = key + (key << 2);
-		key = key ^ (key >> 4);
-		key = key * 2057;
-		key = key ^ (key >> 16);
-		return key;
-	}
-	*/
-
-
-	
-	SIMD_FORCE_INLINE	unsigned int getHash(unsigned int proxyId1, unsigned int proxyId2)
-	{
-		int key = static_cast<int>(((unsigned int)proxyId1) | (((unsigned int)proxyId2) <<16));
-		// Thomas Wang's hash
-
-		key += ~(key << 15);
-		key ^=  (key >> 10);
-		key +=  (key << 3);
-		key ^=  (key >> 6);
-		key += ~(key << 11);
-		key ^=  (key >> 16);
-		return static_cast<unsigned int>(key);
-	}
-	
-
-
-
-
-	SIMD_FORCE_INLINE btBroadphasePair* internalFindPair(btBroadphaseProxy* proxy0, btBroadphaseProxy* proxy1, int hash)
-	{
-		int proxyId1 = proxy0->getUid();
-		int proxyId2 = proxy1->getUid();
-		#if 0 // wrong, 'equalsPair' use unsorted uids, copy-past devil striked again. Nat.
-		if (proxyId1 > proxyId2) 
-			btSwap(proxyId1, proxyId2);
-		#endif
-
-		int index = m_hashTable[hash];
-		
-		while( index != BT_NULL_PAIR && equalsPair(m_overlappingPairArray[index], proxyId1, proxyId2) == false)
-		{
-			index = m_next[index];
-		}
-
-		if ( index == BT_NULL_PAIR )
-		{
-			return NULL;
-		}
-
-		btAssert(index < m_overlappingPairArray.size());
-
-		return &m_overlappingPairArray[index];
-	}
-
-	virtual bool	hasDeferredRemoval()
-	{
-		return false;
-	}
-
-	virtual	void	setInternalGhostPairCallback(btOverlappingPairCallback* ghostPairCallback)
-	{
-		m_ghostPairCallback = ghostPairCallback;
-	}
-
-	virtual void	sortOverlappingPairs(btDispatcher* dispatcher);
-	
-
-	
-};
-
-
-
-
-///btSortedOverlappingPairCache maintains the objects with overlapping AABB
-///Typically managed by the Broadphase, Axis3Sweep or btSimpleBroadphase
-class	btSortedOverlappingPairCache : public btOverlappingPairCache
-{
-	protected:
-		//avoid brute-force finding all the time
-		btBroadphasePairArray	m_overlappingPairArray;
-
-		//during the dispatch, check that user doesn't destroy/create proxy
-		bool		m_blockedForChanges;
-
-		///by default, do the removal during the pair traversal
-		bool		m_hasDeferredRemoval;
-		
-		//if set, use the callback instead of the built in filter in needBroadphaseCollision
-		btOverlapFilterCallback* m_overlapFilterCallback;
-
-		btOverlappingPairCallback*	m_ghostPairCallback;
-
-	public:
-			
-		btSortedOverlappingPairCache();	
-		virtual ~btSortedOverlappingPairCache();
-
-		virtual void	processAllOverlappingPairs(btOverlapCallback*,btDispatcher* dispatcher);
-
-		void*	removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,btDispatcher* dispatcher);
-
-		void	cleanOverlappingPair(btBroadphasePair& pair,btDispatcher* dispatcher);
-		
-		btBroadphasePair*	addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
-
-		btBroadphasePair*	findPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
-			
-		
-		void	cleanProxyFromPairs(btBroadphaseProxy* proxy,btDispatcher* dispatcher);
-
-		void	removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher);
-
-
-		inline bool needsBroadphaseCollision(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) const
-		{
-			if (m_overlapFilterCallback)
-				return m_overlapFilterCallback->needBroadphaseCollision(proxy0,proxy1);
-
-			bool collides = (proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0;
-			collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
-			
-			return collides;
-		}
-		
-		btBroadphasePairArray&	getOverlappingPairArray()
-		{
-			return m_overlappingPairArray;
-		}
-
-		const btBroadphasePairArray&	getOverlappingPairArray() const
-		{
-			return m_overlappingPairArray;
-		}
-
-		
-
-
-		btBroadphasePair*	getOverlappingPairArrayPtr()
-		{
-			return &m_overlappingPairArray[0];
-		}
-
-		const btBroadphasePair*	getOverlappingPairArrayPtr() const
-		{
-			return &m_overlappingPairArray[0];
-		}
-
-		int	getNumOverlappingPairs() const
-		{
-			return m_overlappingPairArray.size();
-		}
-		
-		btOverlapFilterCallback* getOverlapFilterCallback()
-		{
-			return m_overlapFilterCallback;
-		}
-
-		void setOverlapFilterCallback(btOverlapFilterCallback* callback)
-		{
-			m_overlapFilterCallback = callback;
-		}
-
-		virtual bool	hasDeferredRemoval()
-		{
-			return m_hasDeferredRemoval;
-		}
-
-		virtual	void	setInternalGhostPairCallback(btOverlappingPairCallback* ghostPairCallback)
-		{
-			m_ghostPairCallback = ghostPairCallback;
-		}
-
-		virtual void	sortOverlappingPairs(btDispatcher* dispatcher);
-		
-
-};
-
-
-
-///btNullPairCache skips add/removal of overlapping pairs. Userful for benchmarking and unit testing.
-class btNullPairCache : public btOverlappingPairCache
-{
-
-	btBroadphasePairArray	m_overlappingPairArray;
-
-public:
-
-	virtual btBroadphasePair*	getOverlappingPairArrayPtr()
-	{
-		return &m_overlappingPairArray[0];
-	}
-	const btBroadphasePair*	getOverlappingPairArrayPtr() const
-	{
-		return &m_overlappingPairArray[0];
-	}
-	btBroadphasePairArray&	getOverlappingPairArray()
-	{
-		return m_overlappingPairArray;
-	}
-	
-	virtual	void	cleanOverlappingPair(btBroadphasePair& /*pair*/,btDispatcher* /*dispatcher*/)
-	{
-
-	}
-
-	virtual int getNumOverlappingPairs() const
-	{
-		return 0;
-	}
-
-	virtual void	cleanProxyFromPairs(btBroadphaseProxy* /*proxy*/,btDispatcher* /*dispatcher*/)
-	{
-
-	}
-
-	virtual	void setOverlapFilterCallback(btOverlapFilterCallback* /*callback*/)
-	{
-	}
-
-	virtual void	processAllOverlappingPairs(btOverlapCallback*,btDispatcher* /*dispatcher*/)
-	{
-	}
-
-	virtual btBroadphasePair* findPair(btBroadphaseProxy* /*proxy0*/, btBroadphaseProxy* /*proxy1*/)
-	{
-		return 0;
-	}
-
-	virtual bool	hasDeferredRemoval()
-	{
-		return true;
-	}
-
-	virtual	void	setInternalGhostPairCallback(btOverlappingPairCallback* /* ghostPairCallback */)
-	{
-
-	}
-
-	virtual btBroadphasePair*	addOverlappingPair(btBroadphaseProxy* /*proxy0*/,btBroadphaseProxy* /*proxy1*/)
-	{
-		return 0;
-	}
-
-	virtual void*	removeOverlappingPair(btBroadphaseProxy* /*proxy0*/,btBroadphaseProxy* /*proxy1*/,btDispatcher* /*dispatcher*/)
-	{
-		return 0;
-	}
-
-	virtual void	removeOverlappingPairsContainingProxy(btBroadphaseProxy* /*proxy0*/,btDispatcher* /*dispatcher*/)
-	{
-	}
-	
-	virtual void	sortOverlappingPairs(btDispatcher* dispatcher)
-	{
-        (void) dispatcher;
-	}
-
-
-};
-
-
-#endif //BT_OVERLAPPING_PAIR_CACHE_H
-
-

libs/bullet-2.82-r2704/src/BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h

@@ -1,40 +0,0 @@
-
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef OVERLAPPING_PAIR_CALLBACK_H
-#define OVERLAPPING_PAIR_CALLBACK_H
-
-class btDispatcher;
-struct  btBroadphasePair;
-
-///The btOverlappingPairCallback class is an additional optional broadphase user callback for adding/removing overlapping pairs, similar interface to btOverlappingPairCache.
-class btOverlappingPairCallback
-{
-public:
-	virtual ~btOverlappingPairCallback()
-	{
-
-	}
-	
-	virtual btBroadphasePair*	addOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) = 0;
-
-	virtual void*	removeOverlappingPair(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1,btDispatcher* dispatcher) = 0;
-
-	virtual void	removeOverlappingPairsContainingProxy(btBroadphaseProxy* proxy0,btDispatcher* dispatcher) = 0;
-
-};
-
-#endif //OVERLAPPING_PAIR_CALLBACK_H

libs/bullet-2.82-r2704/src/BulletCollision/BroadphaseCollision/btQuantizedBvh.h

@@ -1,581 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef BT_QUANTIZED_BVH_H
-#define BT_QUANTIZED_BVH_H
-
-class btSerializer;
-
-//#define DEBUG_CHECK_DEQUANTIZATION 1
-#ifdef DEBUG_CHECK_DEQUANTIZATION
-#ifdef __SPU__
-#define printf spu_printf
-#endif //__SPU__
-
-#include <stdio.h>
-#include <stdlib.h>
-#endif //DEBUG_CHECK_DEQUANTIZATION
-
-#include "LinearMath/btVector3.h"
-#include "LinearMath/btAlignedAllocator.h"
-
-#ifdef BT_USE_DOUBLE_PRECISION
-#define btQuantizedBvhData btQuantizedBvhDoubleData
-#define btOptimizedBvhNodeData btOptimizedBvhNodeDoubleData
-#define btQuantizedBvhDataName "btQuantizedBvhDoubleData"
-#else
-#define btQuantizedBvhData btQuantizedBvhFloatData
-#define btOptimizedBvhNodeData btOptimizedBvhNodeFloatData
-#define btQuantizedBvhDataName "btQuantizedBvhFloatData"
-#endif
-
-
-
-//http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclang/html/vclrf__m128.asp
-
-
-//Note: currently we have 16 bytes per quantized node
-#define MAX_SUBTREE_SIZE_IN_BYTES  2048
-
-// 10 gives the potential for 1024 parts, with at most 2^21 (2097152) (minus one
-// actually) triangles each (since the sign bit is reserved
-#define MAX_NUM_PARTS_IN_BITS 10
-
-///btQuantizedBvhNode is a compressed aabb node, 16 bytes.
-///Node can be used for leafnode or internal node. Leafnodes can point to 32-bit triangle index (non-negative range).
-ATTRIBUTE_ALIGNED16	(struct) btQuantizedBvhNode
-{
-	BT_DECLARE_ALIGNED_ALLOCATOR();
-
-	//12 bytes
-	unsigned short int	m_quantizedAabbMin[3];
-	unsigned short int	m_quantizedAabbMax[3];
-	//4 bytes
-	int	m_escapeIndexOrTriangleIndex;
-
-	bool isLeafNode() const
-	{
-		//skipindex is negative (internal node), triangleindex >=0 (leafnode)
-		return (m_escapeIndexOrTriangleIndex >= 0);
-	}
-	int getEscapeIndex() const
-	{
-		btAssert(!isLeafNode());
-		return -m_escapeIndexOrTriangleIndex;
-	}
-	int	getTriangleIndex() const
-	{
-		btAssert(isLeafNode());
-		unsigned int x=0;
-		unsigned int y = (~(x&0))<<(31-MAX_NUM_PARTS_IN_BITS);
-		// Get only the lower bits where the triangle index is stored
-		return (m_escapeIndexOrTriangleIndex&~(y));
-	}
-	int	getPartId() const
-	{
-		btAssert(isLeafNode());
-		// Get only the highest bits where the part index is stored
-		return (m_escapeIndexOrTriangleIndex>>(31-MAX_NUM_PARTS_IN_BITS));
-	}
-}
-;
-
-/// btOptimizedBvhNode contains both internal and leaf node information.
-/// Total node size is 44 bytes / node. You can use the compressed version of 16 bytes.
-ATTRIBUTE_ALIGNED16 (struct) btOptimizedBvhNode
-{
-	BT_DECLARE_ALIGNED_ALLOCATOR();
-
-	//32 bytes
-	btVector3	m_aabbMinOrg;
-	btVector3	m_aabbMaxOrg;
-
-	//4
-	int	m_escapeIndex;
-
-	//8
-	//for child nodes
-	int	m_subPart;
-	int	m_triangleIndex;
-
-//pad the size to 64 bytes
-	char	m_padding[20];
-};
-
-
-///btBvhSubtreeInfo provides info to gather a subtree of limited size
-ATTRIBUTE_ALIGNED16(class) btBvhSubtreeInfo
-{
-public:
-	BT_DECLARE_ALIGNED_ALLOCATOR();
-
-	//12 bytes
-	unsigned short int	m_quantizedAabbMin[3];
-	unsigned short int	m_quantizedAabbMax[3];
-	//4 bytes, points to the root of the subtree
-	int			m_rootNodeIndex;
-	//4 bytes
-	int			m_subtreeSize;
-	int			m_padding[3];
-
-	btBvhSubtreeInfo()
-	{
-		//memset(&m_padding[0], 0, sizeof(m_padding));
-	}
-
-
-	void	setAabbFromQuantizeNode(const btQuantizedBvhNode& quantizedNode)
-	{
-		m_quantizedAabbMin[0] = quantizedNode.m_quantizedAabbMin[0];
-		m_quantizedAabbMin[1] = quantizedNode.m_quantizedAabbMin[1];
-		m_quantizedAabbMin[2] = quantizedNode.m_quantizedAabbMin[2];
-		m_quantizedAabbMax[0] = quantizedNode.m_quantizedAabbMax[0];
-		m_quantizedAabbMax[1] = quantizedNode.m_quantizedAabbMax[1];
-		m_quantizedAabbMax[2] = quantizedNode.m_quantizedAabbMax[2];
-	}
-}
-;
-
-
-class btNodeOverlapCallback
-{
-public:
-	virtual ~btNodeOverlapCallback() {};
-
-	virtual void processNode(int subPart, int triangleIndex) = 0;
-};
-
-#include "LinearMath/btAlignedAllocator.h"
-#include "LinearMath/btAlignedObjectArray.h"
-
-
-
-///for code readability:
-typedef btAlignedObjectArray<btOptimizedBvhNode>	NodeArray;
-typedef btAlignedObjectArray<btQuantizedBvhNode>	QuantizedNodeArray;
-typedef btAlignedObjectArray<btBvhSubtreeInfo>		BvhSubtreeInfoArray;
-
-
-///The btQuantizedBvh class stores an AABB tree that can be quickly traversed on CPU and Cell SPU.
-///It is used by the btBvhTriangleMeshShape as midphase, and by the btMultiSapBroadphase.
-///It is recommended to use quantization for better performance and lower memory requirements.
-ATTRIBUTE_ALIGNED16(class) btQuantizedBvh
-{
-public:
-	enum btTraversalMode
-	{
-		TRAVERSAL_STACKLESS = 0,
-		TRAVERSAL_STACKLESS_CACHE_FRIENDLY,
-		TRAVERSAL_RECURSIVE
-	};
-
-protected:
-
-
-	btVector3			m_bvhAabbMin;
-	btVector3			m_bvhAabbMax;
-	btVector3			m_bvhQuantization;
-
-	int					m_bulletVersion;	//for serialization versioning. It could also be used to detect endianess.
-
-	int					m_curNodeIndex;
-	//quantization data
-	bool				m_useQuantization;
-
-
-
-	NodeArray			m_leafNodes;
-	NodeArray			m_contiguousNodes;
-	QuantizedNodeArray	m_quantizedLeafNodes;
-	QuantizedNodeArray	m_quantizedContiguousNodes;
-	
-	btTraversalMode	m_traversalMode;
-	BvhSubtreeInfoArray		m_SubtreeHeaders;
-
-	//This is only used for serialization so we don't have to add serialization directly to btAlignedObjectArray
-	mutable int m_subtreeHeaderCount;
-
-	
-
-
-
-	///two versions, one for quantized and normal nodes. This allows code-reuse while maintaining readability (no template/macro!)
-	///this might be refactored into a virtual, it is usually not calculated at run-time
-	void	setInternalNodeAabbMin(int nodeIndex, const btVector3& aabbMin)
-	{
-		if (m_useQuantization)
-		{
-			quantize(&m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[0] ,aabbMin,0);
-		} else
-		{
-			m_contiguousNodes[nodeIndex].m_aabbMinOrg = aabbMin;
-
-		}
-	}
-	void	setInternalNodeAabbMax(int nodeIndex,const btVector3& aabbMax)
-	{
-		if (m_useQuantization)
-		{
-			quantize(&m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[0],aabbMax,1);
-		} else
-		{
-			m_contiguousNodes[nodeIndex].m_aabbMaxOrg = aabbMax;
-		}
-	}
-
-	btVector3 getAabbMin(int nodeIndex) const
-	{
-		if (m_useQuantization)
-		{
-			return unQuantize(&m_quantizedLeafNodes[nodeIndex].m_quantizedAabbMin[0]);
-		}
-		//non-quantized
-		return m_leafNodes[nodeIndex].m_aabbMinOrg;
-
-	}
-	btVector3 getAabbMax(int nodeIndex) const
-	{
-		if (m_useQuantization)
-		{
-			return unQuantize(&m_quantizedLeafNodes[nodeIndex].m_quantizedAabbMax[0]);
-		} 
-		//non-quantized
-		return m_leafNodes[nodeIndex].m_aabbMaxOrg;
-		
-	}
-
-	
-	void	setInternalNodeEscapeIndex(int nodeIndex, int escapeIndex)
-	{
-		if (m_useQuantization)
-		{
-			m_quantizedContiguousNodes[nodeIndex].m_escapeIndexOrTriangleIndex = -escapeIndex;
-		} 
-		else
-		{
-			m_contiguousNodes[nodeIndex].m_escapeIndex = escapeIndex;
-		}
-
-	}
-
-	void mergeInternalNodeAabb(int nodeIndex,const btVector3& newAabbMin,const btVector3& newAabbMax) 
-	{
-		if (m_useQuantization)
-		{
-			unsigned short int quantizedAabbMin[3];
-			unsigned short int quantizedAabbMax[3];
-			quantize(quantizedAabbMin,newAabbMin,0);
-			quantize(quantizedAabbMax,newAabbMax,1);
-			for (int i=0;i<3;i++)
-			{
-				if (m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[i] > quantizedAabbMin[i])
-					m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMin[i] = quantizedAabbMin[i];
-
-				if (m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[i] < quantizedAabbMax[i])
-					m_quantizedContiguousNodes[nodeIndex].m_quantizedAabbMax[i] = quantizedAabbMax[i];
-
-			}
-		} else
-		{
-			//non-quantized
-			m_contiguousNodes[nodeIndex].m_aabbMinOrg.setMin(newAabbMin);
-			m_contiguousNodes[nodeIndex].m_aabbMaxOrg.setMax(newAabbMax);		
-		}
-	}
-
-	void	swapLeafNodes(int firstIndex,int secondIndex);
-
-	void	assignInternalNodeFromLeafNode(int internalNode,int leafNodeIndex);
-
-protected:
-
-	
-
-	void	buildTree	(int startIndex,int endIndex);
-
-	int	calcSplittingAxis(int startIndex,int endIndex);
-
-	int	sortAndCalcSplittingIndex(int startIndex,int endIndex,int splitAxis);
-	
-	void	walkStacklessTree(btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const;
-
-	void	walkStacklessQuantizedTreeAgainstRay(btNodeOverlapCallback* nodeCallback, const btVector3& raySource, const btVector3& rayTarget, const btVector3& aabbMin, const btVector3& aabbMax, int startNodeIndex,int endNodeIndex) const;
-	void	walkStacklessQuantizedTree(btNodeOverlapCallback* nodeCallback,unsigned short int* quantizedQueryAabbMin,unsigned short int* quantizedQueryAabbMax,int startNodeIndex,int endNodeIndex) const;
-	void	walkStacklessTreeAgainstRay(btNodeOverlapCallback* nodeCallback, const btVector3& raySource, const btVector3& rayTarget, const btVector3& aabbMin, const btVector3& aabbMax, int startNodeIndex,int endNodeIndex) const;
-
-	///tree traversal designed for small-memory processors like PS3 SPU
-	void	walkStacklessQuantizedTreeCacheFriendly(btNodeOverlapCallback* nodeCallback,unsigned short int* quantizedQueryAabbMin,unsigned short int* quantizedQueryAabbMax) const;
-
-	///use the 16-byte stackless 'skipindex' node tree to do a recursive traversal
-	void	walkRecursiveQuantizedTreeAgainstQueryAabb(const btQuantizedBvhNode* currentNode,btNodeOverlapCallback* nodeCallback,unsigned short int* quantizedQueryAabbMin,unsigned short int* quantizedQueryAabbMax) const;
-
-	///use the 16-byte stackless 'skipindex' node tree to do a recursive traversal
-	void	walkRecursiveQuantizedTreeAgainstQuantizedTree(const btQuantizedBvhNode* treeNodeA,const btQuantizedBvhNode* treeNodeB,btNodeOverlapCallback* nodeCallback) const;
-	
-
-
-
-	void	updateSubtreeHeaders(int leftChildNodexIndex,int rightChildNodexIndex);
-
-public:
-	
-	BT_DECLARE_ALIGNED_ALLOCATOR();
-
-	btQuantizedBvh();
-
-	virtual ~btQuantizedBvh();
-
-	
-	///***************************************** expert/internal use only *************************
-	void	setQuantizationValues(const btVector3& bvhAabbMin,const btVector3& bvhAabbMax,btScalar quantizationMargin=btScalar(1.0));
-	QuantizedNodeArray&	getLeafNodeArray() {			return	m_quantizedLeafNodes;	}
-	///buildInternal is expert use only: assumes that setQuantizationValues and LeafNodeArray are initialized
-	void	buildInternal();
-	///***************************************** expert/internal use only *************************
-
-	void	reportAabbOverlappingNodex(btNodeOverlapCallback* nodeCallback,const btVector3& aabbMin,const btVector3& aabbMax) const;
-	void	reportRayOverlappingNodex (btNodeOverlapCallback* nodeCallback, const btVector3& raySource, const btVector3& rayTarget) const;
-	void	reportBoxCastOverlappingNodex(btNodeOverlapCallback* nodeCallback, const btVector3& raySource, const btVector3& rayTarget, const btVector3& aabbMin,const btVector3& aabbMax) const;
-
-		SIMD_FORCE_INLINE void quantize(unsigned short* out, const btVector3& point,int isMax) const
-	{
-
-		btAssert(m_useQuantization);
-
-		btAssert(point.getX() <= m_bvhAabbMax.getX());
-		btAssert(point.getY() <= m_bvhAabbMax.getY());
-		btAssert(point.getZ() <= m_bvhAabbMax.getZ());
-
-		btAssert(point.getX() >= m_bvhAabbMin.getX());
-		btAssert(point.getY() >= m_bvhAabbMin.getY());
-		btAssert(point.getZ() >= m_bvhAabbMin.getZ());
-
-		btVector3 v = (point - m_bvhAabbMin) * m_bvhQuantization;
-		///Make sure rounding is done in a way that unQuantize(quantizeWithClamp(...)) is conservative
-		///end-points always set the first bit, so that they are sorted properly (so that neighbouring AABBs overlap properly)
-		///@todo: double-check this
-		if (isMax)
-		{
-			out[0] = (unsigned short) (((unsigned short)(v.getX()+btScalar(1.)) | 1));
-			out[1] = (unsigned short) (((unsigned short)(v.getY()+btScalar(1.)) | 1));
-			out[2] = (unsigned short) (((unsigned short)(v.getZ()+btScalar(1.)) | 1));
-		} else
-		{
-			out[0] = (unsigned short) (((unsigned short)(v.getX()) & 0xfffe));
-			out[1] = (unsigned short) (((unsigned short)(v.getY()) & 0xfffe));
-			out[2] = (unsigned short) (((unsigned short)(v.getZ()) & 0xfffe));
-		}
-
-
-#ifdef DEBUG_CHECK_DEQUANTIZATION
-		btVector3 newPoint = unQuantize(out);
-		if (isMax)
-		{
-			if (newPoint.getX() < point.getX())
-			{
-				printf("unconservative X, diffX = %f, oldX=%f,newX=%f\n",newPoint.getX()-point.getX(), newPoint.getX(),point.getX());
-			}
-			if (newPoint.getY() < point.getY())
-			{
-				printf("unconservative Y, diffY = %f, oldY=%f,newY=%f\n",newPoint.getY()-point.getY(), newPoint.getY(),point.getY());
-			}
-			if (newPoint.getZ() < point.getZ())
-			{
-
-				printf("unconservative Z, diffZ = %f, oldZ=%f,newZ=%f\n",newPoint.getZ()-point.getZ(), newPoint.getZ(),point.getZ());
-			}
-		} else
-		{
-			if (newPoint.getX() > point.getX())
-			{
-				printf("unconservative X, diffX = %f, oldX=%f,newX=%f\n",newPoint.getX()-point.getX(), newPoint.getX(),point.getX());
-			}
-			if (newPoint.getY() > point.getY())
-			{
-				printf("unconservative Y, diffY = %f, oldY=%f,newY=%f\n",newPoint.getY()-point.getY(), newPoint.getY(),point.getY());
-			}
-			if (newPoint.getZ() > point.getZ())
-			{
-				printf("unconservative Z, diffZ = %f, oldZ=%f,newZ=%f\n",newPoint.getZ()-point.getZ(), newPoint.getZ(),point.getZ());
-			}
-		}
-#endif //DEBUG_CHECK_DEQUANTIZATION
-
-	}
-
-
-	SIMD_FORCE_INLINE void quantizeWithClamp(unsigned short* out, const btVector3& point2,int isMax) const
-	{
-
-		btAssert(m_useQuantization);
-
-		btVector3 clampedPoint(point2);
-		clampedPoint.setMax(m_bvhAabbMin);
-		clampedPoint.setMin(m_bvhAabbMax);
-
-		quantize(out,clampedPoint,isMax);
-
-	}
-	
-	SIMD_FORCE_INLINE btVector3	unQuantize(const unsigned short* vecIn) const
-	{
-			btVector3	vecOut;
-			vecOut.setValue(
-			(btScalar)(vecIn[0]) / (m_bvhQuantization.getX()),
-			(btScalar)(vecIn[1]) / (m_bvhQuantization.getY()),
-			(btScalar)(vecIn[2]) / (m_bvhQuantization.getZ()));
-			vecOut += m_bvhAabbMin;
-			return vecOut;
-	}
-
-	///setTraversalMode let's you choose between stackless, recursive or stackless cache friendly tree traversal. Note this is only implemented for quantized trees.
-	void	setTraversalMode(btTraversalMode	traversalMode)
-	{
-		m_traversalMode = traversalMode;
-	}
-
-
-	SIMD_FORCE_INLINE QuantizedNodeArray&	getQuantizedNodeArray()
-	{	
-		return	m_quantizedContiguousNodes;
-	}
-
-
-	SIMD_FORCE_INLINE BvhSubtreeInfoArray&	getSubtreeInfoArray()
-	{
-		return m_SubtreeHeaders;
-	}
-
-////////////////////////////////////////////////////////////////////
-
-	/////Calculate space needed to store BVH for serialization
-	unsigned calculateSerializeBufferSize() const;
-
-	/// Data buffer MUST be 16 byte aligned
-	virtual bool serialize(void *o_alignedDataBuffer, unsigned i_dataBufferSize, bool i_swapEndian) const;
-
-	///deSerializeInPlace loads and initializes a BVH from a buffer in memory 'in place'
-	static btQuantizedBvh *deSerializeInPlace(void *i_alignedDataBuffer, unsigned int i_dataBufferSize, bool i_swapEndian);
-
-	static unsigned int getAlignmentSerializationPadding();
-//////////////////////////////////////////////////////////////////////
-
-	
-	virtual	int	calculateSerializeBufferSizeNew() const;
-
-	///fills the dataBuffer and returns the struct name (and 0 on failure)
-	virtual	const char*	serialize(void* dataBuffer, btSerializer* serializer) const;
-
-	virtual	void deSerializeFloat(struct btQuantizedBvhFloatData& quantizedBvhFloatData);
-
-	virtual	void deSerializeDouble(struct btQuantizedBvhDoubleData& quantizedBvhDoubleData);
-
-
-////////////////////////////////////////////////////////////////////
-
-	SIMD_FORCE_INLINE bool isQuantized()
-	{
-		return m_useQuantization;
-	}
-
-private:
-	// Special "copy" constructor that allows for in-place deserialization
-	// Prevents btVector3's default constructor from being called, but doesn't inialize much else
-	// ownsMemory should most likely be false if deserializing, and if you are not, don't call this (it also changes the function signature, which we need)
-	btQuantizedBvh(btQuantizedBvh &other, bool ownsMemory);
-
-}
-;
-
-
-struct	btBvhSubtreeInfoData
-{
-	int			m_rootNodeIndex;
-	int			m_subtreeSize;
-	unsigned short m_quantizedAabbMin[3];
-	unsigned short m_quantizedAabbMax[3];
-};
-
-struct btOptimizedBvhNodeFloatData
-{
-	btVector3FloatData	m_aabbMinOrg;
-	btVector3FloatData	m_aabbMaxOrg;
-	int	m_escapeIndex;
-	int	m_subPart;
-	int	m_triangleIndex;
-	char m_pad[4];
-};
-
-struct btOptimizedBvhNodeDoubleData
-{
-	btVector3DoubleData	m_aabbMinOrg;
-	btVector3DoubleData	m_aabbMaxOrg;
-	int	m_escapeIndex;
-	int	m_subPart;
-	int	m_triangleIndex;
-	char	m_pad[4];
-};
-
-
-struct btQuantizedBvhNodeData
-{
-	unsigned short m_quantizedAabbMin[3];
-	unsigned short m_quantizedAabbMax[3];
-	int	m_escapeIndexOrTriangleIndex;
-};
-
-struct	btQuantizedBvhFloatData
-{
-	btVector3FloatData			m_bvhAabbMin;
-	btVector3FloatData			m_bvhAabbMax;
-	btVector3FloatData			m_bvhQuantization;
-	int					m_curNodeIndex;
-	int					m_useQuantization;
-	int					m_numContiguousLeafNodes;
-	int					m_numQuantizedContiguousNodes;
-	btOptimizedBvhNodeFloatData	*m_contiguousNodesPtr;
-	btQuantizedBvhNodeData		*m_quantizedContiguousNodesPtr;
-	btBvhSubtreeInfoData	*m_subTreeInfoPtr;
-	int					m_traversalMode;
-	int					m_numSubtreeHeaders;
-	
-};
-
-struct	btQuantizedBvhDoubleData
-{
-	btVector3DoubleData			m_bvhAabbMin;
-	btVector3DoubleData			m_bvhAabbMax;
-	btVector3DoubleData			m_bvhQuantization;
-	int							m_curNodeIndex;
-	int							m_useQuantization;
-	int							m_numContiguousLeafNodes;
-	int							m_numQuantizedContiguousNodes;
-	btOptimizedBvhNodeDoubleData	*m_contiguousNodesPtr;
-	btQuantizedBvhNodeData			*m_quantizedContiguousNodesPtr;
-
-	int							m_traversalMode;
-	int							m_numSubtreeHeaders;
-	btBvhSubtreeInfoData		*m_subTreeInfoPtr;
-};
-
-
-SIMD_FORCE_INLINE	int	btQuantizedBvh::calculateSerializeBufferSizeNew() const
-{
-	return sizeof(btQuantizedBvhData);
-}
-
-
-
-#endif //BT_QUANTIZED_BVH_H

libs/bullet-2.82-r2704/src/BulletCollision/BroadphaseCollision/btSimpleBroadphase.cpp

@@ -1,349 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "btSimpleBroadphase.h"
-#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
-
-#include "LinearMath/btVector3.h"
-#include "LinearMath/btTransform.h"
-#include "LinearMath/btMatrix3x3.h"
-#include "LinearMath/btAabbUtil2.h"
-
-#include <new>
-
-extern int gOverlappingPairs;
-
-void	btSimpleBroadphase::validate()
-{
-	for (int i=0;i<m_numHandles;i++)
-	{
-		for (int j=i+1;j<m_numHandles;j++)
-		{
-			btAssert(&m_pHandles[i] != &m_pHandles[j]);
-		}
-	}
-	
-}
-
-btSimpleBroadphase::btSimpleBroadphase(int maxProxies, btOverlappingPairCache* overlappingPairCache)
-	:m_pairCache(overlappingPairCache),
-	m_ownsPairCache(false),
-	m_invalidPair(0)
-{
-
-	if (!overlappingPairCache)
-	{
-		void* mem = btAlignedAlloc(sizeof(btHashedOverlappingPairCache),16);
-		m_pairCache = new (mem)btHashedOverlappingPairCache();
-		m_ownsPairCache = true;
-	}
-
-	// allocate handles buffer and put all handles on free list
-	m_pHandlesRawPtr = btAlignedAlloc(sizeof(btSimpleBroadphaseProxy)*maxProxies,16);
-	m_pHandles = new(m_pHandlesRawPtr) btSimpleBroadphaseProxy[maxProxies];
-	m_maxHandles = maxProxies;
-	m_numHandles = 0;
-	m_firstFreeHandle = 0;
-	m_LastHandleIndex = -1;
-	
-
-	{
-		for (int i = m_firstFreeHandle; i < maxProxies; i++)
-		{
-			m_pHandles[i].SetNextFree(i + 1);
-			m_pHandles[i].m_uniqueId = i+2;//any UID will do, we just avoid too trivial values (0,1) for debugging purposes
-		}
-		m_pHandles[maxProxies - 1].SetNextFree(0);
-	
-	}
-
-}
-
-btSimpleBroadphase::~btSimpleBroadphase()
-{
-	btAlignedFree(m_pHandlesRawPtr);
-
-	if (m_ownsPairCache)
-	{
-		m_pairCache->~btOverlappingPairCache();
-		btAlignedFree(m_pairCache);
-	}
-}
-
-
-btBroadphaseProxy*	btSimpleBroadphase::createProxy(  const btVector3& aabbMin,  const btVector3& aabbMax,int shapeType,void* userPtr ,short int collisionFilterGroup,short int collisionFilterMask, btDispatcher* /*dispatcher*/,void* multiSapProxy)
-{
-	if (m_numHandles >= m_maxHandles)
-	{
-		btAssert(0);
-		return 0; //should never happen, but don't let the game crash ;-)
-	}
-	btAssert(aabbMin[0]<= aabbMax[0] && aabbMin[1]<= aabbMax[1] && aabbMin[2]<= aabbMax[2]);
-
-	int newHandleIndex = allocHandle();
-	btSimpleBroadphaseProxy* proxy = new (&m_pHandles[newHandleIndex])btSimpleBroadphaseProxy(aabbMin,aabbMax,shapeType,userPtr,collisionFilterGroup,collisionFilterMask,multiSapProxy);
-
-	return proxy;
-}
-
-class	RemovingOverlapCallback : public btOverlapCallback
-{
-protected:
-	virtual bool	processOverlap(btBroadphasePair& pair)
-	{
-		(void)pair;
-		btAssert(0);
-		return false;
-	}
-};
-
-class RemovePairContainingProxy
-{
-
-	btBroadphaseProxy*	m_targetProxy;
-	public:
-	virtual ~RemovePairContainingProxy()
-	{
-	}
-protected:
-	virtual bool processOverlap(btBroadphasePair& pair)
-	{
-		btSimpleBroadphaseProxy* proxy0 = static_cast<btSimpleBroadphaseProxy*>(pair.m_pProxy0);
-		btSimpleBroadphaseProxy* proxy1 = static_cast<btSimpleBroadphaseProxy*>(pair.m_pProxy1);
-
-		return ((m_targetProxy == proxy0 || m_targetProxy == proxy1));
-	};
-};
-
-void	btSimpleBroadphase::destroyProxy(btBroadphaseProxy* proxyOrg,btDispatcher* dispatcher)
-{
-		
-		btSimpleBroadphaseProxy* proxy0 = static_cast<btSimpleBroadphaseProxy*>(proxyOrg);
-		freeHandle(proxy0);
-
-		m_pairCache->removeOverlappingPairsContainingProxy(proxyOrg,dispatcher);
-
-		//validate();
-		
-}
-
-void	btSimpleBroadphase::getAabb(btBroadphaseProxy* proxy,btVector3& aabbMin, btVector3& aabbMax ) const
-{
-	const btSimpleBroadphaseProxy* sbp = getSimpleProxyFromProxy(proxy);
-	aabbMin = sbp->m_aabbMin;
-	aabbMax = sbp->m_aabbMax;
-}
-
-void	btSimpleBroadphase::setAabb(btBroadphaseProxy* proxy,const btVector3& aabbMin,const btVector3& aabbMax, btDispatcher* /*dispatcher*/)
-{
-	btSimpleBroadphaseProxy* sbp = getSimpleProxyFromProxy(proxy);
-	sbp->m_aabbMin = aabbMin;
-	sbp->m_aabbMax = aabbMax;
-}
-
-void	btSimpleBroadphase::rayTest(const btVector3& rayFrom,const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin,const btVector3& aabbMax)
-{
-	for (int i=0; i <= m_LastHandleIndex; i++)
-	{
-		btSimpleBroadphaseProxy* proxy = &m_pHandles[i];
-		if(!proxy->m_clientObject)
-		{
-			continue;
-		}
-		rayCallback.process(proxy);
-	}
-}
-
-
-void	btSimpleBroadphase::aabbTest(const btVector3& aabbMin, const btVector3& aabbMax, btBroadphaseAabbCallback& callback)
-{
-	for (int i=0; i <= m_LastHandleIndex; i++)
-	{
-		btSimpleBroadphaseProxy* proxy = &m_pHandles[i];
-		if(!proxy->m_clientObject)
-		{
-			continue;
-		}
-		if (TestAabbAgainstAabb2(aabbMin,aabbMax,proxy->m_aabbMin,proxy->m_aabbMax))
-		{
-			callback.process(proxy);
-		}
-	}
-}
-
-
-
-	
-
-
-
-bool	btSimpleBroadphase::aabbOverlap(btSimpleBroadphaseProxy* proxy0,btSimpleBroadphaseProxy* proxy1)
-{
-	return proxy0->m_aabbMin[0] <= proxy1->m_aabbMax[0] && proxy1->m_aabbMin[0] <= proxy0->m_aabbMax[0] && 
-		   proxy0->m_aabbMin[1] <= proxy1->m_aabbMax[1] && proxy1->m_aabbMin[1] <= proxy0->m_aabbMax[1] &&
-		   proxy0->m_aabbMin[2] <= proxy1->m_aabbMax[2] && proxy1->m_aabbMin[2] <= proxy0->m_aabbMax[2];
-
-}
-
-
-
-//then remove non-overlapping ones
-class CheckOverlapCallback : public btOverlapCallback
-{
-public:
-	virtual bool processOverlap(btBroadphasePair& pair)
-	{
-		return (!btSimpleBroadphase::aabbOverlap(static_cast<btSimpleBroadphaseProxy*>(pair.m_pProxy0),static_cast<btSimpleBroadphaseProxy*>(pair.m_pProxy1)));
-	}
-};
-
-void	btSimpleBroadphase::calculateOverlappingPairs(btDispatcher* dispatcher)
-{
-	//first check for new overlapping pairs
-	int i,j;
-	if (m_numHandles >= 0)
-	{
-		int new_largest_index = -1;
-		for (i=0; i <= m_LastHandleIndex; i++)
-		{
-			btSimpleBroadphaseProxy* proxy0 = &m_pHandles[i];
-			if(!proxy0->m_clientObject)
-			{
-				continue;
-			}
-			new_largest_index = i;
-			for (j=i+1; j <= m_LastHandleIndex; j++)
-			{
-				btSimpleBroadphaseProxy* proxy1 = &m_pHandles[j];
-				btAssert(proxy0 != proxy1);
-				if(!proxy1->m_clientObject)
-				{
-					continue;
-				}
-
-				btSimpleBroadphaseProxy* p0 = getSimpleProxyFromProxy(proxy0);
-				btSimpleBroadphaseProxy* p1 = getSimpleProxyFromProxy(proxy1);
-
-				if (aabbOverlap(p0,p1))
-				{
-					if ( !m_pairCache->findPair(proxy0,proxy1))
-					{
-						m_pairCache->addOverlappingPair(proxy0,proxy1);
-					}
-				} else
-				{
-					if (!m_pairCache->hasDeferredRemoval())
-					{
-						if ( m_pairCache->findPair(proxy0,proxy1))
-						{
-							m_pairCache->removeOverlappingPair(proxy0,proxy1,dispatcher);
-						}
-					}
-				}
-			}
-		}
-
-		m_LastHandleIndex = new_largest_index;
-
-		if (m_ownsPairCache && m_pairCache->hasDeferredRemoval())
-		{
-
-			btBroadphasePairArray&	overlappingPairArray = m_pairCache->getOverlappingPairArray();
-
-			//perform a sort, to find duplicates and to sort 'invalid' pairs to the end
-			overlappingPairArray.quickSort(btBroadphasePairSortPredicate());
-
-			overlappingPairArray.resize(overlappingPairArray.size() - m_invalidPair);
-			m_invalidPair = 0;
-
-
-			btBroadphasePair previousPair;
-			previousPair.m_pProxy0 = 0;
-			previousPair.m_pProxy1 = 0;
-			previousPair.m_algorithm = 0;
-
-
-			for (i=0;i<overlappingPairArray.size();i++)
-			{
-
-				btBroadphasePair& pair = overlappingPairArray[i];
-
-				bool isDuplicate = (pair == previousPair);
-
-				previousPair = pair;
-
-				bool needsRemoval = false;
-
-				if (!isDuplicate)
-				{
-					bool hasOverlap = testAabbOverlap(pair.m_pProxy0,pair.m_pProxy1);
-
-					if (hasOverlap)
-					{
-						needsRemoval = false;//callback->processOverlap(pair);
-					} else
-					{
-						needsRemoval = true;
-					}
-				} else
-				{
-					//remove duplicate
-					needsRemoval = true;
-					//should have no algorithm
-					btAssert(!pair.m_algorithm);
-				}
-
-				if (needsRemoval)
-				{
-					m_pairCache->cleanOverlappingPair(pair,dispatcher);
-
-					//		m_overlappingPairArray.swap(i,m_overlappingPairArray.size()-1);
-					//		m_overlappingPairArray.pop_back();
-					pair.m_pProxy0 = 0;
-					pair.m_pProxy1 = 0;
-					m_invalidPair++;
-					gOverlappingPairs--;
-				} 
-
-			}
-
-			///if you don't like to skip the invalid pairs in the array, execute following code:
-#define CLEAN_INVALID_PAIRS 1
-#ifdef CLEAN_INVALID_PAIRS
-
-			//perform a sort, to sort 'invalid' pairs to the end
-			overlappingPairArray.quickSort(btBroadphasePairSortPredicate());
-
-			overlappingPairArray.resize(overlappingPairArray.size() - m_invalidPair);
-			m_invalidPair = 0;
-#endif//CLEAN_INVALID_PAIRS
-
-		}
-	}
-}
-
-
-bool btSimpleBroadphase::testAabbOverlap(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1)
-{
-	btSimpleBroadphaseProxy* p0 = getSimpleProxyFromProxy(proxy0);
-	btSimpleBroadphaseProxy* p1 = getSimpleProxyFromProxy(proxy1);
-	return aabbOverlap(p0,p1);
-}
-
-void	btSimpleBroadphase::resetPool(btDispatcher* dispatcher)
-{
-	//not yet
-}

libs/bullet-2.82-r2704/src/BulletCollision/BroadphaseCollision/btSimpleBroadphase.h

@@ -1,171 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef BT_SIMPLE_BROADPHASE_H
-#define BT_SIMPLE_BROADPHASE_H
-
-
-#include "btOverlappingPairCache.h"
-
-
-struct btSimpleBroadphaseProxy : public btBroadphaseProxy
-{
-	int			m_nextFree;
-	
-//	int			m_handleId;
-
-	
-	btSimpleBroadphaseProxy() {};
-
-	btSimpleBroadphaseProxy(const btVector3& minpt,const btVector3& maxpt,int shapeType,void* userPtr,short int collisionFilterGroup,short int collisionFilterMask,void* multiSapProxy)
-	:btBroadphaseProxy(minpt,maxpt,userPtr,collisionFilterGroup,collisionFilterMask,multiSapProxy)
-	{
-		(void)shapeType;
-	}
-	
-	
-	SIMD_FORCE_INLINE void SetNextFree(int next) {m_nextFree = next;}
-	SIMD_FORCE_INLINE int GetNextFree() const {return m_nextFree;}
-
-	
-
-
-};
-
-///The SimpleBroadphase is just a unit-test for btAxisSweep3, bt32BitAxisSweep3, or btDbvtBroadphase, so use those classes instead.
-///It is a brute force aabb culling broadphase based on O(n^2) aabb checks
-class btSimpleBroadphase : public btBroadphaseInterface
-{
-
-protected:
-
-	int		m_numHandles;						// number of active handles
-	int		m_maxHandles;						// max number of handles
-	int		m_LastHandleIndex;							
-	
-	btSimpleBroadphaseProxy* m_pHandles;						// handles pool
-
-	void* m_pHandlesRawPtr;
-	int		m_firstFreeHandle;		// free handles list
-	
-	int allocHandle()
-	{
-		btAssert(m_numHandles < m_maxHandles);
-		int freeHandle = m_firstFreeHandle;
-		m_firstFreeHandle = m_pHandles[freeHandle].GetNextFree();
-		m_numHandles++;
-		if(freeHandle > m_LastHandleIndex)
-		{
-			m_LastHandleIndex = freeHandle;
-		}
-		return freeHandle;
-	}
-
-	void freeHandle(btSimpleBroadphaseProxy* proxy)
-	{
-		int handle = int(proxy-m_pHandles);
-		btAssert(handle >= 0 && handle < m_maxHandles);
-		if(handle == m_LastHandleIndex)
-		{
-			m_LastHandleIndex--;
-		}
-		proxy->SetNextFree(m_firstFreeHandle);
-		m_firstFreeHandle = handle;
-
-		proxy->m_clientObject = 0;
-
-		m_numHandles--;
-	}
-
-	btOverlappingPairCache*	m_pairCache;
-	bool	m_ownsPairCache;
-
-	int	m_invalidPair;
-
-	
-	
-	inline btSimpleBroadphaseProxy*	getSimpleProxyFromProxy(btBroadphaseProxy* proxy)
-	{
-		btSimpleBroadphaseProxy* proxy0 = static_cast<btSimpleBroadphaseProxy*>(proxy);
-		return proxy0;
-	}
-
-	inline const btSimpleBroadphaseProxy*	getSimpleProxyFromProxy(btBroadphaseProxy* proxy) const
-	{
-		const btSimpleBroadphaseProxy* proxy0 = static_cast<const btSimpleBroadphaseProxy*>(proxy);
-		return proxy0;
-	}
-
-	///reset broadphase internal structures, to ensure determinism/reproducability
-	virtual void resetPool(btDispatcher* dispatcher);
-
-
-	void	validate();
-
-protected:
-
-
-	
-
-public:
-	btSimpleBroadphase(int maxProxies=16384,btOverlappingPairCache* overlappingPairCache=0);
-	virtual ~btSimpleBroadphase();
-
-
-		static bool	aabbOverlap(btSimpleBroadphaseProxy* proxy0,btSimpleBroadphaseProxy* proxy1);
-
-
-	virtual btBroadphaseProxy*	createProxy(  const btVector3& aabbMin,  const btVector3& aabbMax,int shapeType,void* userPtr ,short int collisionFilterGroup,short int collisionFilterMask, btDispatcher* dispatcher,void* multiSapProxy);
-
-	virtual void	calculateOverlappingPairs(btDispatcher* dispatcher);
-
-	virtual void	destroyProxy(btBroadphaseProxy* proxy,btDispatcher* dispatcher);
-	virtual void	setAabb(btBroadphaseProxy* proxy,const btVector3& aabbMin,const btVector3& aabbMax, btDispatcher* dispatcher);
-	virtual void	getAabb(btBroadphaseProxy* proxy,btVector3& aabbMin, btVector3& aabbMax ) const;
-
-	virtual void	rayTest(const btVector3& rayFrom,const btVector3& rayTo, btBroadphaseRayCallback& rayCallback, const btVector3& aabbMin=btVector3(0,0,0),const btVector3& aabbMax=btVector3(0,0,0));
-	virtual void	aabbTest(const btVector3& aabbMin, const btVector3& aabbMax, btBroadphaseAabbCallback& callback);
-		
-	btOverlappingPairCache*	getOverlappingPairCache()
-	{
-		return m_pairCache;
-	}
-	const btOverlappingPairCache*	getOverlappingPairCache() const
-	{
-		return m_pairCache;
-	}
-
-	bool	testAabbOverlap(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1);
-
-
-	///getAabb returns the axis aligned bounding box in the 'global' coordinate frame
-	///will add some transform later
-	virtual void getBroadphaseAabb(btVector3& aabbMin,btVector3& aabbMax) const
-	{
-		aabbMin.setValue(-BT_LARGE_FLOAT,-BT_LARGE_FLOAT,-BT_LARGE_FLOAT);
-		aabbMax.setValue(BT_LARGE_FLOAT,BT_LARGE_FLOAT,BT_LARGE_FLOAT);
-	}
-
-	virtual void	printStats()
-	{
-//		printf("btSimpleBroadphase.h\n");
-//		printf("numHandles = %d, maxHandles = %d\n",m_numHandles,m_maxHandles);
-	}
-};
-
-
-
-#endif //BT_SIMPLE_BROADPHASE_H
-

libs/bullet-2.82-r2704/src/BulletCollision/CMakeLists.txt

@@ -1,286 +0,0 @@
-INCLUDE_DIRECTORIES( ${BULLET_PHYSICS_SOURCE_DIR}/src  )
-
-SET(BulletCollision_SRCS
-	BroadphaseCollision/btAxisSweep3.cpp
-	BroadphaseCollision/btBroadphaseProxy.cpp
-	BroadphaseCollision/btCollisionAlgorithm.cpp
-	BroadphaseCollision/btDbvt.cpp
-	BroadphaseCollision/btDbvtBroadphase.cpp
-	BroadphaseCollision/btDispatcher.cpp
-	BroadphaseCollision/btMultiSapBroadphase.cpp
-	BroadphaseCollision/btOverlappingPairCache.cpp
-	BroadphaseCollision/btQuantizedBvh.cpp
-	BroadphaseCollision/btSimpleBroadphase.cpp
-	CollisionDispatch/btActivatingCollisionAlgorithm.cpp
-	CollisionDispatch/btBoxBoxCollisionAlgorithm.cpp
-	CollisionDispatch/btBox2dBox2dCollisionAlgorithm.cpp
-	CollisionDispatch/btBoxBoxDetector.cpp
-	CollisionDispatch/btCollisionDispatcher.cpp
-	CollisionDispatch/btCollisionObject.cpp
-	CollisionDispatch/btCollisionWorld.cpp
-	CollisionDispatch/btCompoundCollisionAlgorithm.cpp
-	CollisionDispatch/btCompoundCompoundCollisionAlgorithm.cpp
-	CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp
-	CollisionDispatch/btConvexConvexAlgorithm.cpp
-	CollisionDispatch/btConvexPlaneCollisionAlgorithm.cpp
-	CollisionDispatch/btConvex2dConvex2dAlgorithm.cpp
-	CollisionDispatch/btDefaultCollisionConfiguration.cpp
-	CollisionDispatch/btEmptyCollisionAlgorithm.cpp
-	CollisionDispatch/btGhostObject.cpp
-	CollisionDispatch/btHashedSimplePairCache.cpp
-	CollisionDispatch/btInternalEdgeUtility.cpp
-	CollisionDispatch/btInternalEdgeUtility.h
-	CollisionDispatch/btManifoldResult.cpp
-	CollisionDispatch/btSimulationIslandManager.cpp
-	CollisionDispatch/btSphereBoxCollisionAlgorithm.cpp
-	CollisionDispatch/btSphereSphereCollisionAlgorithm.cpp
-	CollisionDispatch/btSphereTriangleCollisionAlgorithm.cpp
-	CollisionDispatch/btUnionFind.cpp
-	CollisionDispatch/SphereTriangleDetector.cpp
-	CollisionShapes/btBoxShape.cpp
-	CollisionShapes/btBox2dShape.cpp
-	CollisionShapes/btBvhTriangleMeshShape.cpp
-	CollisionShapes/btCapsuleShape.cpp
-	CollisionShapes/btCollisionShape.cpp
-	CollisionShapes/btCompoundShape.cpp
-	CollisionShapes/btConcaveShape.cpp
-	CollisionShapes/btConeShape.cpp
-	CollisionShapes/btConvexHullShape.cpp
-	CollisionShapes/btConvexInternalShape.cpp
-	CollisionShapes/btConvexPointCloudShape.cpp
-	CollisionShapes/btConvexPolyhedron.cpp
-	CollisionShapes/btConvexShape.cpp
-	CollisionShapes/btConvex2dShape.cpp
-	CollisionShapes/btConvexTriangleMeshShape.cpp
-	CollisionShapes/btCylinderShape.cpp
-	CollisionShapes/btEmptyShape.cpp
-	CollisionShapes/btHeightfieldTerrainShape.cpp
-	CollisionShapes/btMinkowskiSumShape.cpp
-	CollisionShapes/btMultimaterialTriangleMeshShape.cpp
-	CollisionShapes/btMultiSphereShape.cpp
-	CollisionShapes/btOptimizedBvh.cpp
-	CollisionShapes/btPolyhedralConvexShape.cpp
-	CollisionShapes/btScaledBvhTriangleMeshShape.cpp
-	CollisionShapes/btShapeHull.cpp
-	CollisionShapes/btSphereShape.cpp
-	CollisionShapes/btStaticPlaneShape.cpp
-	CollisionShapes/btStridingMeshInterface.cpp
-	CollisionShapes/btTetrahedronShape.cpp
-	CollisionShapes/btTriangleBuffer.cpp
-	CollisionShapes/btTriangleCallback.cpp
-	CollisionShapes/btTriangleIndexVertexArray.cpp
-	CollisionShapes/btTriangleIndexVertexMaterialArray.cpp
-	CollisionShapes/btTriangleMesh.cpp
-	CollisionShapes/btTriangleMeshShape.cpp
-	CollisionShapes/btUniformScalingShape.cpp
-	Gimpact/btContactProcessing.cpp
-	Gimpact/btGenericPoolAllocator.cpp
-	Gimpact/btGImpactBvh.cpp
-	Gimpact/btGImpactCollisionAlgorithm.cpp
-	Gimpact/btGImpactQuantizedBvh.cpp
-	Gimpact/btGImpactShape.cpp
-	Gimpact/btTriangleShapeEx.cpp
-	Gimpact/gim_box_set.cpp
-	Gimpact/gim_contact.cpp
-	Gimpact/gim_memory.cpp
-	Gimpact/gim_tri_collision.cpp
-	NarrowPhaseCollision/btContinuousConvexCollision.cpp
-	NarrowPhaseCollision/btConvexCast.cpp
-	NarrowPhaseCollision/btGjkConvexCast.cpp
-	NarrowPhaseCollision/btGjkEpa2.cpp
-	NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp
-	NarrowPhaseCollision/btGjkPairDetector.cpp
-	NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.cpp
-	NarrowPhaseCollision/btPersistentManifold.cpp
-	NarrowPhaseCollision/btRaycastCallback.cpp
-	NarrowPhaseCollision/btSubSimplexConvexCast.cpp
-	NarrowPhaseCollision/btVoronoiSimplexSolver.cpp
-	NarrowPhaseCollision/btPolyhedralContactClipping.cpp
-)
-
-SET(Root_HDRS
-	../btBulletCollisionCommon.h
-)
-SET(BroadphaseCollision_HDRS
-	BroadphaseCollision/btAxisSweep3.h
-	BroadphaseCollision/btBroadphaseInterface.h
-	BroadphaseCollision/btBroadphaseProxy.h
-	BroadphaseCollision/btCollisionAlgorithm.h
-	BroadphaseCollision/btDbvt.h
-	BroadphaseCollision/btDbvtBroadphase.h
-	BroadphaseCollision/btDispatcher.h
-	BroadphaseCollision/btMultiSapBroadphase.h
-	BroadphaseCollision/btOverlappingPairCache.h
-	BroadphaseCollision/btOverlappingPairCallback.h
-	BroadphaseCollision/btQuantizedBvh.h
-	BroadphaseCollision/btSimpleBroadphase.h
-)
-SET(CollisionDispatch_HDRS
-	CollisionDispatch/btActivatingCollisionAlgorithm.h
-	CollisionDispatch/btBoxBoxCollisionAlgorithm.h
-	CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h
-	CollisionDispatch/btBoxBoxDetector.h
-	CollisionDispatch/btCollisionConfiguration.h
-	CollisionDispatch/btCollisionCreateFunc.h
-	CollisionDispatch/btCollisionDispatcher.h
-	CollisionDispatch/btCollisionObject.h
-	CollisionDispatch/btCollisionObjectWrapper.h
-	CollisionDispatch/btCollisionWorld.h
-	CollisionDispatch/btCompoundCollisionAlgorithm.h
-	CollisionDispatch/btCompoundCompoundCollisionAlgorithm.h
-	CollisionDispatch/btConvexConcaveCollisionAlgorithm.h
-	CollisionDispatch/btConvexConvexAlgorithm.h
-	CollisionDispatch/btConvex2dConvex2dAlgorithm.h
-	CollisionDispatch/btConvexPlaneCollisionAlgorithm.h
-	CollisionDispatch/btDefaultCollisionConfiguration.h
-	CollisionDispatch/btEmptyCollisionAlgorithm.h
-	CollisionDispatch/btGhostObject.h
-	CollisionDispatch/btHashedSimplePairCache.h
-	CollisionDispatch/btManifoldResult.h
-	CollisionDispatch/btSimulationIslandManager.h
-	CollisionDispatch/btSphereBoxCollisionAlgorithm.h
-	CollisionDispatch/btSphereSphereCollisionAlgorithm.h
-	CollisionDispatch/btSphereTriangleCollisionAlgorithm.h
-	CollisionDispatch/btUnionFind.h
-	CollisionDispatch/SphereTriangleDetector.h
-)
-SET(CollisionShapes_HDRS
-	CollisionShapes/btBoxShape.h
-	CollisionShapes/btBox2dShape.h
-	CollisionShapes/btBvhTriangleMeshShape.h
-	CollisionShapes/btCapsuleShape.h
-	CollisionShapes/btCollisionMargin.h
-	CollisionShapes/btCollisionShape.h
-	CollisionShapes/btCompoundShape.h
-	CollisionShapes/btConcaveShape.h
-	CollisionShapes/btConeShape.h
-	CollisionShapes/btConvexHullShape.h
-	CollisionShapes/btConvexInternalShape.h
-	CollisionShapes/btConvexPointCloudShape.h
-	CollisionShapes/btConvexPolyhedron.h
-	CollisionShapes/btConvexShape.h
-	CollisionShapes/btConvex2dShape.h
-	CollisionShapes/btConvexTriangleMeshShape.h
-	CollisionShapes/btCylinderShape.h
-	CollisionShapes/btEmptyShape.h
-	CollisionShapes/btHeightfieldTerrainShape.h
-	CollisionShapes/btMaterial.h
-	CollisionShapes/btMinkowskiSumShape.h
-	CollisionShapes/btMultimaterialTriangleMeshShape.h
-	CollisionShapes/btMultiSphereShape.h
-	CollisionShapes/btOptimizedBvh.h
-	CollisionShapes/btPolyhedralConvexShape.h
-	CollisionShapes/btScaledBvhTriangleMeshShape.h
-	CollisionShapes/btShapeHull.h
-	CollisionShapes/btSphereShape.h
-	CollisionShapes/btStaticPlaneShape.h
-	CollisionShapes/btStridingMeshInterface.h
-	CollisionShapes/btTetrahedronShape.h
-	CollisionShapes/btTriangleBuffer.h
-	CollisionShapes/btTriangleCallback.h
-	CollisionShapes/btTriangleIndexVertexArray.h
-	CollisionShapes/btTriangleIndexVertexMaterialArray.h
-	CollisionShapes/btTriangleInfoMap.h
-	CollisionShapes/btTriangleMesh.h
-	CollisionShapes/btTriangleMeshShape.h
-	CollisionShapes/btTriangleShape.h
-	CollisionShapes/btUniformScalingShape.h
-)
-SET(Gimpact_HDRS
-	Gimpact/btBoxCollision.h
-	Gimpact/btClipPolygon.h
-	Gimpact/btContactProcessing.h
-	Gimpact/btGenericPoolAllocator.h
-	Gimpact/btGeometryOperations.h
-	Gimpact/btGImpactBvh.h
-	Gimpact/btGImpactCollisionAlgorithm.h
-	Gimpact/btGImpactMassUtil.h
-	Gimpact/btGImpactQuantizedBvh.h
-	Gimpact/btGImpactShape.h
-	Gimpact/btQuantization.h
-	Gimpact/btTriangleShapeEx.h
-	Gimpact/gim_array.h
-	Gimpact/gim_basic_geometry_operations.h
-	Gimpact/gim_bitset.h
-	Gimpact/gim_box_collision.h
-	Gimpact/gim_box_set.h
-	Gimpact/gim_clip_polygon.h
-	Gimpact/gim_contact.h
-	Gimpact/gim_geom_types.h
-	Gimpact/gim_geometry.h
-	Gimpact/gim_hash_table.h
-	Gimpact/gim_linear_math.h
-	Gimpact/gim_math.h
-	Gimpact/gim_memory.h
-	Gimpact/gim_radixsort.h
-	Gimpact/gim_tri_collision.h
-)
-SET(NarrowPhaseCollision_HDRS
-	NarrowPhaseCollision/btContinuousConvexCollision.h
-	NarrowPhaseCollision/btConvexCast.h
-	NarrowPhaseCollision/btConvexPenetrationDepthSolver.h
-	NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h
-	NarrowPhaseCollision/btGjkConvexCast.h
-	NarrowPhaseCollision/btGjkEpa2.h
-	NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h
-	NarrowPhaseCollision/btGjkPairDetector.h
-	NarrowPhaseCollision/btManifoldPoint.h
-	NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h
-	NarrowPhaseCollision/btPersistentManifold.h
-	NarrowPhaseCollision/btPointCollector.h
-	NarrowPhaseCollision/btRaycastCallback.h
-	NarrowPhaseCollision/btSimplexSolverInterface.h
-	NarrowPhaseCollision/btSubSimplexConvexCast.h
-	NarrowPhaseCollision/btVoronoiSimplexSolver.h
-	NarrowPhaseCollision/btPolyhedralContactClipping.h
-)
-
-SET(BulletCollision_HDRS
-	${Root_HDRS}
-	${BroadphaseCollision_HDRS}
-	${CollisionDispatch_HDRS}
-	${CollisionShapes_HDRS}
-	${Gimpact_HDRS}
-	${NarrowPhaseCollision_HDRS}
-)
-
-
-ADD_LIBRARY(BulletCollision ${BulletCollision_SRCS} ${BulletCollision_HDRS})
-SET_TARGET_PROPERTIES(BulletCollision PROPERTIES VERSION ${BULLET_VERSION})
-SET_TARGET_PROPERTIES(BulletCollision PROPERTIES SOVERSION ${BULLET_VERSION})
-IF (BUILD_SHARED_LIBS)
-  TARGET_LINK_LIBRARIES(BulletCollision LinearMath)
-ENDIF (BUILD_SHARED_LIBS)
-
-
-IF (INSTALL_LIBS)
-	IF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
-		#INSTALL of other files requires CMake 2.6
-		IF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
-			IF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
-				INSTALL(TARGETS BulletCollision DESTINATION .)
-			ELSE (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
-				INSTALL(TARGETS BulletCollision RUNTIME DESTINATION bin
-								LIBRARY DESTINATION lib${LIB_SUFFIX}
-								ARCHIVE DESTINATION lib${LIB_SUFFIX})
-				INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-DESTINATION ${INCLUDE_INSTALL_DIR} FILES_MATCHING PATTERN "*.h" PATTERN ".svn" EXCLUDE PATTERN "CMakeFiles" EXCLUDE)
-				INSTALL(FILES ../btBulletCollisionCommon.h
-DESTINATION ${INCLUDE_INSTALL_DIR}/BulletCollision)
-			ENDIF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
-		ENDIF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.5)
-		
-		IF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
-			SET_TARGET_PROPERTIES(BulletCollision PROPERTIES FRAMEWORK true)
-		
-			SET_TARGET_PROPERTIES(BulletCollision PROPERTIES PUBLIC_HEADER "${Root_HDRS}")
-			# Have to list out sub-directories manually:
-			SET_PROPERTY(SOURCE ${BroadphaseCollision_HDRS} PROPERTY MACOSX_PACKAGE_LOCATION Headers/BroadphaseCollision)
-			SET_PROPERTY(SOURCE ${CollisionDispatch_HDRS} PROPERTY MACOSX_PACKAGE_LOCATION Headers/CollisionDispatch)
-			SET_PROPERTY(SOURCE ${CollisionShapes_HDRS} PROPERTY MACOSX_PACKAGE_LOCATION Headers/CollisionShapes)
-			SET_PROPERTY(SOURCE ${Gimpact_HDRS} PROPERTY MACOSX_PACKAGE_LOCATION Headers/Gimpact)
-			SET_PROPERTY(SOURCE ${NarrowPhaseCollision_HDRS} PROPERTY MACOSX_PACKAGE_LOCATION Headers/NarrowPhaseCollision)
-		
-		ENDIF (APPLE AND BUILD_SHARED_LIBS AND FRAMEWORK)
-	ENDIF (NOT INTERNAL_CREATE_DISTRIBUTABLE_MSVC_PROJECTFILES)
-ENDIF (INSTALL_LIBS)

libs/bullet-2.82-r2704/src/BulletCollision/CollisionDispatch/SphereTriangleDetector.cpp

@@ -1,200 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "LinearMath/btScalar.h"
-#include "SphereTriangleDetector.h"
-#include "BulletCollision/CollisionShapes/btTriangleShape.h"
-#include "BulletCollision/CollisionShapes/btSphereShape.h"
-
-
-SphereTriangleDetector::SphereTriangleDetector(btSphereShape* sphere,btTriangleShape* triangle,btScalar contactBreakingThreshold)
-:m_sphere(sphere),
-m_triangle(triangle),
-m_contactBreakingThreshold(contactBreakingThreshold)
-{
-
-}
-
-void	SphereTriangleDetector::getClosestPoints(const ClosestPointInput& input,Result& output,class btIDebugDraw* debugDraw,bool swapResults)
-{
-
-	(void)debugDraw;
-	const btTransform& transformA = input.m_transformA;
-	const btTransform& transformB = input.m_transformB;
-
-	btVector3 point,normal;
-	btScalar timeOfImpact = btScalar(1.);
-	btScalar depth = btScalar(0.);
-//	output.m_distance = btScalar(BT_LARGE_FLOAT);
-	//move sphere into triangle space
-	btTransform	sphereInTr = transformB.inverseTimes(transformA);
-
-	if (collide(sphereInTr.getOrigin(),point,normal,depth,timeOfImpact,m_contactBreakingThreshold))
-	{
-		if (swapResults)
-		{
-			btVector3 normalOnB = transformB.getBasis()*normal;
-			btVector3 normalOnA = -normalOnB;
-			btVector3 pointOnA = transformB*point+normalOnB*depth;
-			output.addContactPoint(normalOnA,pointOnA,depth);
-		} else
-		{
-			output.addContactPoint(transformB.getBasis()*normal,transformB*point,depth);
-		}
-	}
-
-}
-
-
-
-// See also geometrictools.com
-// Basic idea: D = |p - (lo + t0*lv)| where t0 = lv . (p - lo) / lv . lv
-btScalar SegmentSqrDistance(const btVector3& from, const btVector3& to,const btVector3 &p, btVector3 &nearest);
-
-btScalar SegmentSqrDistance(const btVector3& from, const btVector3& to,const btVector3 &p, btVector3 &nearest) {
-	btVector3 diff = p - from;
-	btVector3 v = to - from;
-	btScalar t = v.dot(diff);
-	
-	if (t > 0) {
-		btScalar dotVV = v.dot(v);
-		if (t < dotVV) {
-			t /= dotVV;
-			diff -= t*v;
-		} else {
-			t = 1;
-			diff -= v;
-		}
-	} else
-		t = 0;
-
-	nearest = from + t*v;
-	return diff.dot(diff);	
-}
-
-bool SphereTriangleDetector::facecontains(const btVector3 &p,const btVector3* vertices,btVector3& normal)  {
-	btVector3 lp(p);
-	btVector3 lnormal(normal);
-	
-	return pointInTriangle(vertices, lnormal, &lp);
-}
-
-bool SphereTriangleDetector::collide(const btVector3& sphereCenter,btVector3 &point, btVector3& resultNormal, btScalar& depth, btScalar &timeOfImpact, btScalar contactBreakingThreshold)
-{
-
-	const btVector3* vertices = &m_triangle->getVertexPtr(0);
-	
-	btScalar radius = m_sphere->getRadius();
-	btScalar radiusWithThreshold = radius + contactBreakingThreshold;
-
-	btVector3 normal = (vertices[1]-vertices[0]).cross(vertices[2]-vertices[0]);
-	normal.normalize();
-	btVector3 p1ToCentre = sphereCenter - vertices[0];
-	btScalar distanceFromPlane = p1ToCentre.dot(normal);
-
-	if (distanceFromPlane < btScalar(0.))
-	{
-		//triangle facing the other way
-		distanceFromPlane *= btScalar(-1.);
-		normal *= btScalar(-1.);
-	}
-
-	bool isInsideContactPlane = distanceFromPlane < radiusWithThreshold;
-	
-	// Check for contact / intersection
-	bool hasContact = false;
-	btVector3 contactPoint;
-	if (isInsideContactPlane) {
-		if (facecontains(sphereCenter,vertices,normal)) {
-			// Inside the contact wedge - touches a point on the shell plane
-			hasContact = true;
-			contactPoint = sphereCenter - normal*distanceFromPlane;
-		} else {
-			// Could be inside one of the contact capsules
-			btScalar contactCapsuleRadiusSqr = radiusWithThreshold*radiusWithThreshold;
-			btVector3 nearestOnEdge;
-			for (int i = 0; i < m_triangle->getNumEdges(); i++) {
-				
-				btVector3 pa;
-				btVector3 pb;
-				
-				m_triangle->getEdge(i,pa,pb);
-
-				btScalar distanceSqr = SegmentSqrDistance(pa,pb,sphereCenter, nearestOnEdge);
-				if (distanceSqr < contactCapsuleRadiusSqr) {
-					// Yep, we're inside a capsule
-					hasContact = true;
-					contactPoint = nearestOnEdge;
-				}
-				
-			}
-		}
-	}
-
-	if (hasContact) {
-		btVector3 contactToCentre = sphereCenter - contactPoint;
-		btScalar distanceSqr = contactToCentre.length2();
-
-		if (distanceSqr < radiusWithThreshold*radiusWithThreshold)
-		{
-			if (distanceSqr>SIMD_EPSILON)
-			{
-				btScalar distance = btSqrt(distanceSqr);
-				resultNormal = contactToCentre;
-				resultNormal.normalize();
-				point = contactPoint;
-				depth = -(radius-distance);
-			} else
-			{
-				resultNormal = normal;
-				point = contactPoint;
-				depth = -radius;
-			}
-			return true;
-		}
-	}
-	
-	return false;
-}
-
-
-bool SphereTriangleDetector::pointInTriangle(const btVector3 vertices[], const btVector3 &normal, btVector3 *p )
-{
-	const btVector3* p1 = &vertices[0];
-	const btVector3* p2 = &vertices[1];
-	const btVector3* p3 = &vertices[2];
-
-	btVector3 edge1( *p2 - *p1 );
-	btVector3 edge2( *p3 - *p2 );
-	btVector3 edge3( *p1 - *p3 );
-
-	btVector3 p1_to_p( *p - *p1 );
-	btVector3 p2_to_p( *p - *p2 );
-	btVector3 p3_to_p( *p - *p3 );
-
-	btVector3 edge1_normal( edge1.cross(normal));
-	btVector3 edge2_normal( edge2.cross(normal));
-	btVector3 edge3_normal( edge3.cross(normal));
-	
-	btScalar r1, r2, r3;
-	r1 = edge1_normal.dot( p1_to_p );
-	r2 = edge2_normal.dot( p2_to_p );
-	r3 = edge3_normal.dot( p3_to_p );
-	if ( ( r1 > 0 && r2 > 0 && r3 > 0 ) ||
-	     ( r1 <= 0 && r2 <= 0 && r3 <= 0 ) )
-		return true;
-	return false;
-
-}

libs/bullet-2.82-r2704/src/BulletCollision/CollisionDispatch/SphereTriangleDetector.h

@@ -1,51 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef BT_SPHERE_TRIANGLE_DETECTOR_H
-#define BT_SPHERE_TRIANGLE_DETECTOR_H
-
-#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h"
-
-
-
-class btSphereShape;
-class btTriangleShape;
-
-
-
-/// sphere-triangle to match the btDiscreteCollisionDetectorInterface
-struct SphereTriangleDetector : public btDiscreteCollisionDetectorInterface
-{
-	virtual void	getClosestPoints(const ClosestPointInput& input,Result& output,class btIDebugDraw* debugDraw,bool swapResults=false);
-
-	SphereTriangleDetector(btSphereShape* sphere,btTriangleShape* triangle, btScalar contactBreakingThreshold);
-
-	virtual ~SphereTriangleDetector() {};
-
-	bool collide(const btVector3& sphereCenter,btVector3 &point, btVector3& resultNormal, btScalar& depth, btScalar &timeOfImpact, btScalar	contactBreakingThreshold);
-
-private:
-
-	
-	bool pointInTriangle(const btVector3 vertices[], const btVector3 &normal, btVector3 *p );
-	bool facecontains(const btVector3 &p,const btVector3* vertices,btVector3& normal);
-
-	btSphereShape* m_sphere;
-	btTriangleShape* m_triangle;
-	btScalar	m_contactBreakingThreshold;
-	
-};
-#endif //BT_SPHERE_TRIANGLE_DETECTOR_H
-

libs/bullet-2.82-r2704/src/BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.cpp

@@ -1,47 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2008 Erwin Coumans  http://bulletphysics.com
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include "btActivatingCollisionAlgorithm.h"
-#include "btCollisionDispatcher.h"
-#include "btCollisionObject.h"
-
-btActivatingCollisionAlgorithm::btActivatingCollisionAlgorithm (const btCollisionAlgorithmConstructionInfo& ci)
-:btCollisionAlgorithm(ci)
-//,
-//m_colObj0(0),
-//m_colObj1(0)
-{
-}
-btActivatingCollisionAlgorithm::btActivatingCollisionAlgorithm (const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* ,const btCollisionObjectWrapper* )
-:btCollisionAlgorithm(ci)
-//,
-//m_colObj0(0),
-//m_colObj1(0)
-{
-//	if (ci.m_dispatcher1->needsCollision(colObj0,colObj1))
-//	{
-//		m_colObj0 = colObj0;
-//		m_colObj1 = colObj1;
-//		
-//		m_colObj0->activate();
-//		m_colObj1->activate();
-//	}
-}
-
-btActivatingCollisionAlgorithm::~btActivatingCollisionAlgorithm()
-{
-//		m_colObj0->activate();
-//		m_colObj1->activate();
-}

libs/bullet-2.82-r2704/src/BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h

@@ -1,36 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2003-2008 Erwin Coumans  http://bulletphysics.com
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef __BT_ACTIVATING_COLLISION_ALGORITHM_H
-#define __BT_ACTIVATING_COLLISION_ALGORITHM_H
-
-#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
-
-///This class is not enabled yet (work-in-progress) to more aggressively activate objects.
-class btActivatingCollisionAlgorithm : public btCollisionAlgorithm
-{
-//	btCollisionObject* m_colObj0;
-//	btCollisionObject* m_colObj1;
-
-public:
-
-	btActivatingCollisionAlgorithm (const btCollisionAlgorithmConstructionInfo& ci);
-
-	btActivatingCollisionAlgorithm (const btCollisionAlgorithmConstructionInfo& ci, const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap);
-
-	virtual ~btActivatingCollisionAlgorithm();
-
-};
-#endif //__BT_ACTIVATING_COLLISION_ALGORITHM_H

libs/bullet-2.82-r2704/src/BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.cpp

@@ -1,421 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-* The b2CollidePolygons routines are Copyright (c) 2006-2007 Erin Catto http://www.gphysics.com
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-///btBox2dBox2dCollisionAlgorithm, with modified b2CollidePolygons routines from the Box2D library.
-///The modifications include: switching from b2Vec to btVector3, redefinition of b2Dot, b2Cross
-
-#include "btBox2dBox2dCollisionAlgorithm.h"
-#include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h"
-#include "BulletCollision/CollisionShapes/btBoxShape.h"
-#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
-#include "BulletCollision/CollisionDispatch/btBoxBoxDetector.h"
-#include "BulletCollision/CollisionShapes/btBox2dShape.h"
-#include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h"
-
-#define USE_PERSISTENT_CONTACTS 1
-
-btBox2dBox2dCollisionAlgorithm::btBox2dBox2dCollisionAlgorithm(btPersistentManifold* mf,const btCollisionAlgorithmConstructionInfo& ci,const btCollisionObjectWrapper* obj0Wrap,const btCollisionObjectWrapper* obj1Wrap)
-: btActivatingCollisionAlgorithm(ci,obj0Wrap,obj1Wrap),
-m_ownManifold(false),
-m_manifoldPtr(mf)
-{
-	if (!m_manifoldPtr && m_dispatcher->needsCollision(obj0Wrap->getCollisionObject(),obj1Wrap->getCollisionObject()))
-	{
-		m_manifoldPtr = m_dispatcher->getNewManifold(obj0Wrap->getCollisionObject(),obj1Wrap->getCollisionObject());
-		m_ownManifold = true;
-	}
-}
-
-btBox2dBox2dCollisionAlgorithm::~btBox2dBox2dCollisionAlgorithm()
-{
-	
-	if (m_ownManifold)
-	{
-		if (m_manifoldPtr)
-			m_dispatcher->releaseManifold(m_manifoldPtr);
-	}
-	
-}
-
-
-void b2CollidePolygons(btManifoldResult* manifold,  const btBox2dShape* polyA, const btTransform& xfA, const btBox2dShape* polyB, const btTransform& xfB);
-
-//#include <stdio.h>
-void btBox2dBox2dCollisionAlgorithm::processCollision (const btCollisionObjectWrapper* body0Wrap,const btCollisionObjectWrapper* body1Wrap,const btDispatcherInfo& dispatchInfo,btManifoldResult* resultOut)
-{
-	if (!m_manifoldPtr)
-		return;
-
-	
-	const btBox2dShape* box0 = (const btBox2dShape*)body0Wrap->getCollisionShape();
-	const btBox2dShape* box1 = (const btBox2dShape*)body1Wrap->getCollisionShape();
-
-	resultOut->setPersistentManifold(m_manifoldPtr);
-
-	b2CollidePolygons(resultOut,box0,body0Wrap->getWorldTransform(),box1,body1Wrap->getWorldTransform());
-
-	//  refreshContactPoints is only necessary when using persistent contact points. otherwise all points are newly added
-	if (m_ownManifold)
-	{
-		resultOut->refreshContactPoints();
-	}
-
-}
-
-btScalar btBox2dBox2dCollisionAlgorithm::calculateTimeOfImpact(btCollisionObject* /*body0*/,btCollisionObject* /*body1*/,const btDispatcherInfo& /*dispatchInfo*/,btManifoldResult* /*resultOut*/)
-{
-	//not yet
-	return 1.f;
-}
-
-
-struct ClipVertex
-{
-	btVector3 v;
-	int id;
-	//b2ContactID id;
-	//b2ContactID id;
-};
-
-#define b2Dot(a,b) (a).dot(b)
-#define b2Mul(a,b) (a)*(b)
-#define b2MulT(a,b) (a).transpose()*(b)
-#define b2Cross(a,b) (a).cross(b)
-#define btCrossS(a,s) btVector3(s * a.getY(), -s * a.getX(),0.f)
-
-int b2_maxManifoldPoints =2;
-
-static int ClipSegmentToLine(ClipVertex vOut[2], ClipVertex vIn[2],
-					  const btVector3& normal, btScalar offset)
-{
-	// Start with no output points
-	int numOut = 0;
-
-	// Calculate the distance of end points to the line
-	btScalar distance0 = b2Dot(normal, vIn[0].v) - offset;
-	btScalar distance1 = b2Dot(normal, vIn[1].v) - offset;
-
-	// If the points are behind the plane
-	if (distance0 <= 0.0f) vOut[numOut++] = vIn[0];
-	if (distance1 <= 0.0f) vOut[numOut++] = vIn[1];
-
-	// If the points are on different sides of the plane
-	if (distance0 * distance1 < 0.0f)
-	{
-		// Find intersection point of edge and plane
-		btScalar interp = distance0 / (distance0 - distance1);
-		vOut[numOut].v = vIn[0].v + interp * (vIn[1].v - vIn[0].v);
-		if (distance0 > 0.0f)
-		{
-			vOut[numOut].id = vIn[0].id;
-		}
-		else
-		{
-			vOut[numOut].id = vIn[1].id;
-		}
-		++numOut;
-	}
-
-	return numOut;
-}
-
-// Find the separation between poly1 and poly2 for a give edge normal on poly1.
-static btScalar EdgeSeparation(const btBox2dShape* poly1, const btTransform& xf1, int edge1,
-							  const btBox2dShape* poly2, const btTransform& xf2)
-{
-	const btVector3* vertices1 = poly1->getVertices();
-	const btVector3* normals1 = poly1->getNormals();
-
-	int count2 = poly2->getVertexCount();
-	const btVector3* vertices2 = poly2->getVertices();
-
-	btAssert(0 <= edge1 && edge1 < poly1->getVertexCount());
-
-	// Convert normal from poly1's frame into poly2's frame.
-	btVector3 normal1World = b2Mul(xf1.getBasis(), normals1[edge1]);
-	btVector3 normal1 = b2MulT(xf2.getBasis(), normal1World);
-
-	// Find support vertex on poly2 for -normal.
-	int index = 0;
-	btScalar minDot = BT_LARGE_FLOAT;
-
-    if( count2 > 0 )
-        index = (int) normal1.minDot( vertices2, count2, minDot);
-
-	btVector3 v1 = b2Mul(xf1, vertices1[edge1]);
-	btVector3 v2 = b2Mul(xf2, vertices2[index]);
-	btScalar separation = b2Dot(v2 - v1, normal1World);
-	return separation;
-}
-
-// Find the max separation between poly1 and poly2 using edge normals from poly1.
-static btScalar FindMaxSeparation(int* edgeIndex,
-								 const btBox2dShape* poly1, const btTransform& xf1,
-								 const btBox2dShape* poly2, const btTransform& xf2)
-{
-	int count1 = poly1->getVertexCount();
-	const btVector3* normals1 = poly1->getNormals();
-
-	// Vector pointing from the centroid of poly1 to the centroid of poly2.
-	btVector3 d = b2Mul(xf2, poly2->getCentroid()) - b2Mul(xf1, poly1->getCentroid());
-	btVector3 dLocal1 = b2MulT(xf1.getBasis(), d);
-
-	// Find edge normal on poly1 that has the largest projection onto d.
-	int edge = 0;
-    btScalar maxDot;
-    if( count1 > 0 )
-        edge = (int) dLocal1.maxDot( normals1, count1, maxDot);
-
-	// Get the separation for the edge normal.
-	btScalar s = EdgeSeparation(poly1, xf1, edge, poly2, xf2);
-	if (s > 0.0f)
-	{
-		return s;
-	}
-
-	// Check the separation for the previous edge normal.
-	int prevEdge = edge - 1 >= 0 ? edge - 1 : count1 - 1;
-	btScalar sPrev = EdgeSeparation(poly1, xf1, prevEdge, poly2, xf2);
-	if (sPrev > 0.0f)
-	{
-		return sPrev;
-	}
-
-	// Check the separation for the next edge normal.
-	int nextEdge = edge + 1 < count1 ? edge + 1 : 0;
-	btScalar sNext = EdgeSeparation(poly1, xf1, nextEdge, poly2, xf2);
-	if (sNext > 0.0f)
-	{
-		return sNext;
-	}
-
-	// Find the best edge and the search direction.
-	int bestEdge;
-	btScalar bestSeparation;
-	int increment;
-	if (sPrev > s && sPrev > sNext)
-	{
-		increment = -1;
-		bestEdge = prevEdge;
-		bestSeparation = sPrev;
-	}
-	else if (sNext > s)
-	{
-		increment = 1;
-		bestEdge = nextEdge;
-		bestSeparation = sNext;
-	}
-	else
-	{
-		*edgeIndex = edge;
-		return s;
-	}
-
-	// Perform a local search for the best edge normal.
-	for ( ; ; )
-	{
-		if (increment == -1)
-			edge = bestEdge - 1 >= 0 ? bestEdge - 1 : count1 - 1;
-		else
-			edge = bestEdge + 1 < count1 ? bestEdge + 1 : 0;
-
-		s = EdgeSeparation(poly1, xf1, edge, poly2, xf2);
-		if (s > 0.0f)
-		{
-			return s;
-		}
-
-		if (s > bestSeparation)
-		{
-			bestEdge = edge;
-			bestSeparation = s;
-		}
-		else
-		{
-			break;
-		}
-	}
-
-	*edgeIndex = bestEdge;
-	return bestSeparation;
-}
-
-static void FindIncidentEdge(ClipVertex c[2],
-							 const btBox2dShape* poly1, const btTransform& xf1, int edge1,
-							 const btBox2dShape* poly2, const btTransform& xf2)
-{
-	const btVector3* normals1 = poly1->getNormals();
-
-	int count2 = poly2->getVertexCount();
-	const btVector3* vertices2 = poly2->getVertices();
-	const btVector3* normals2 = poly2->getNormals();
-
-	btAssert(0 <= edge1 && edge1 < poly1->getVertexCount());
-
-	// Get the normal of the reference edge in poly2's frame.
-	btVector3 normal1 = b2MulT(xf2.getBasis(), b2Mul(xf1.getBasis(), normals1[edge1]));
-
-	// Find the incident edge on poly2.
-	int index = 0;
-	btScalar minDot = BT_LARGE_FLOAT;
-	for (int i = 0; i < count2; ++i)
-	{
-		btScalar dot = b2Dot(normal1, normals2[i]);
-		if (dot < minDot)
-		{
-			minDot = dot;
-			index = i;
-		}
-	}
-
-	// Build the clip vertices for the incident edge.
-	int i1 = index;
-	int i2 = i1 + 1 < count2 ? i1 + 1 : 0;
-
-	c[0].v = b2Mul(xf2, vertices2[i1]);
-//	c[0].id.features.referenceEdge = (unsigned char)edge1;
-//	c[0].id.features.incidentEdge = (unsigned char)i1;
-//	c[0].id.features.incidentVertex = 0;
-
-	c[1].v = b2Mul(xf2, vertices2[i2]);
-//	c[1].id.features.referenceEdge = (unsigned char)edge1;
-//	c[1].id.features.incidentEdge = (unsigned char)i2;
-//	c[1].id.features.incidentVertex = 1;
-}
-
-// Find edge normal of max separation on A - return if separating axis is found
-// Find edge normal of max separation on B - return if separation axis is found
-// Choose reference edge as min(minA, minB)
-// Find incident edge
-// Clip
-
-// The normal points from 1 to 2
-void b2CollidePolygons(btManifoldResult* manifold,
-					  const btBox2dShape* polyA, const btTransform& xfA,
-					  const btBox2dShape* polyB, const btTransform& xfB)
-{
-
-	int edgeA = 0;
-	btScalar separationA = FindMaxSeparation(&edgeA, polyA, xfA, polyB, xfB);
-	if (separationA > 0.0f)
-		return;
-
-	int edgeB = 0;
-	btScalar separationB = FindMaxSeparation(&edgeB, polyB, xfB, polyA, xfA);
-	if (separationB > 0.0f)
-		return;
-
-	const btBox2dShape* poly1;	// reference poly
-	const btBox2dShape* poly2;	// incident poly
-	btTransform xf1, xf2;
-	int edge1;		// reference edge
-	unsigned char flip;
-	const btScalar k_relativeTol = 0.98f;
-	const btScalar k_absoluteTol = 0.001f;
-
-	// TODO_ERIN use "radius" of poly for absolute tolerance.
-	if (separationB > k_relativeTol * separationA + k_absoluteTol)
-	{
-		poly1 = polyB;
-		poly2 = polyA;
-		xf1 = xfB;
-		xf2 = xfA;
-		edge1 = edgeB;
-		flip = 1;
-	}
-	else
-	{
-		poly1 = polyA;
-		poly2 = polyB;
-		xf1 = xfA;
-		xf2 = xfB;
-		edge1 = edgeA;
-		flip = 0;
-	}
-
-	ClipVertex incidentEdge[2];
-	FindIncidentEdge(incidentEdge, poly1, xf1, edge1, poly2, xf2);
-
-	int count1 = poly1->getVertexCount();
-	const btVector3* vertices1 = poly1->getVertices();
-
-	btVector3 v11 = vertices1[edge1];
-	btVector3 v12 = edge1 + 1 < count1 ? vertices1[edge1+1] : vertices1[0];
-
-	//btVector3 dv = v12 - v11;
-	btVector3 sideNormal = b2Mul(xf1.getBasis(), v12 - v11);
-	sideNormal.normalize();
-	btVector3 frontNormal = btCrossS(sideNormal, 1.0f);
-	
-	
-	v11 = b2Mul(xf1, v11);
-	v12 = b2Mul(xf1, v12);
-
-	btScalar frontOffset = b2Dot(frontNormal, v11);
-	btScalar sideOffset1 = -b2Dot(sideNormal, v11);
-	btScalar sideOffset2 = b2Dot(sideNormal, v12);
-
-	// Clip incident edge against extruded edge1 side edges.
-	ClipVertex clipPoints1[2];
-	clipPoints1[0].v.setValue(0,0,0);
-	clipPoints1[1].v.setValue(0,0,0);
-
-	ClipVertex clipPoints2[2];
-	clipPoints2[0].v.setValue(0,0,0);
-	clipPoints2[1].v.setValue(0,0,0);
-
-
-	int np;
-
-	// Clip to box side 1
-	np = ClipSegmentToLine(clipPoints1, incidentEdge, -sideNormal, sideOffset1);
-
-	if (np < 2)
-		return;
-
-	// Clip to negative box side 1
-	np = ClipSegmentToLine(clipPoints2, clipPoints1,  sideNormal, sideOffset2);
-
-	if (np < 2)
-	{
-		return;
-	}
-
-	// Now clipPoints2 contains the clipped points.
-	btVector3 manifoldNormal = flip ? -frontNormal : frontNormal;
-
-	int pointCount = 0;
-	for (int i = 0; i < b2_maxManifoldPoints; ++i)
-	{
-		btScalar separation = b2Dot(frontNormal, clipPoints2[i].v) - frontOffset;
-
-		if (separation <= 0.0f)
-		{
-			
-			//b2ManifoldPoint* cp = manifold->points + pointCount;
-			//btScalar separation = separation;
-			//cp->localPoint1 = b2MulT(xfA, clipPoints2[i].v);
-			//cp->localPoint2 = b2MulT(xfB, clipPoints2[i].v);
-
-			manifold->addContactPoint(-manifoldNormal,clipPoints2[i].v,separation);
-
-//			cp->id = clipPoints2[i].id;
-//			cp->id.features.flip = flip;
-			++pointCount;
-		}
-	}
-
-//	manifold->pointCount = pointCount;}
-}